2. 程式人生 > >等待喚醒機制，UDP通信和TCP通信

等待喚醒機制，UDP通信和TCP通信

阿新 • • 發佈：2018-08-30
其它 www. cal 輸入 width tro interrupt 客戶端 ann

等待喚醒機制

　　通過等待喚醒機制使各個線程能有效的利用資源。

等待喚醒機制所涉及到的方法：

　　 wait（） :等待，將正在執行的線程釋放其執行資格 和 執行權，並存儲到線程池中。

　　notify（）：喚醒，喚醒線程池中被wait（）的線程，一次喚醒一個，而且是任意的。

　　notifyAll（）： 喚醒全部：可以將線程池中的所有wait() 線程都喚醒。

　　所謂喚醒的意思就是讓 線程池中的線程具備執行資格。

　　必須註意的是：這些方法都是在 同步中才有效；

　　　　　　同時這些方法在使用時必須標明所屬鎖，這樣才可以明確出這些方法操作的到底是哪　　個鎖上的線程。而鎖又可以是任意對象。能被任意對象調用的方法一定定義在Object類中。

技術分享圖片

例子：

技術分享圖片

代碼如下：

模擬資源類：

package com.oracle.Resourse;

public class Resourse {
    public String name;
    public String sex;
    public boolean flag = false;
    
}

輸入線程任務類：

package com.oracle.Resourse;

public class InputR  implements Runnable{
    private int i=0;
    private Resourse r=new
 
 Resourse();
    
    public InputR(Resourse r){
        this.r=r;
    }
    public void run() {
        while(true){
            synchronized (r){
                if(r.flag){
                    
                    try {
                        r.wait();
                    } catch (InterruptedException e) {
                        
 
// TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }
                if(i%2==0){
                    r.name="張三";
                    r.sex="男";
                }else{
                    r.name="LISI";
                    r.sex="NV";
                }
                r.flag=true;
                r.notify();
            }
            i++;
        }
    }

}

輸出線程任務類：

package com.oracle.Resourse;

public class OutputR   implements Runnable{

    private Resourse r=new Resourse();
    public OutputR(Resourse r){
        this.r=r;
    
    }
    public void run() {
        while(true){
            synchronized (r){
                if(r.flag==false){
                    try {
                        r.wait();
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }
                System.out.println(r.name+"..."+r.sex);
                r.flag=false;
                r.notify();
                
            }
        }
        
    }

}

測試類：

package com.oracle.Resourse;

public class TEST {

    public static void main(String[] args) {
        Resourse r=new Resourse();
        InputR in=new InputR(r);
        OutputR out=new OutputR(r)    ;
        Thread t1=new Thread(in);
        Thread t2=new Thread(out);
        t1.start();
        t2.start();


    }

}

結果如下:

技術分享圖片

InetAddress類

InetAdderss類，該類用於封裝一個IP地址，並提供了一系列與IP地址相關的方法

技術分享圖片

例子：

public class Example01 {
    public static void main(String[] args) throws Exception {
        InetAddress local = InetAddress.getLocalHost();
        InetAddress remote = InetAddress.getByName("www.oracle.cn");
        System.out.println("本機的IP地址：" + local.getHostAddress());
        System.out.println("oracle的IP地址：" + remote.getHostAddress());
        System.out.println("oracle的主機名為：" + remote.getHostName());
    }
}

UDP是一種面向無連接的協議，因此，在通信時發送端和接收端不用建立連接。

DatagramPacket類

　　該類的實例對象就相當於一個集裝箱，用於封裝UDP通信中發送或者接收的數據。

構造方法

技術分享圖片　

技術分享圖片

發送端一定要明確指出數據的目的地(ip地址和端口號)，而接收端不需要明確知道數據的來源，只需要接收到數據即可。

DatagramPacket類中的常用方法

技術分享圖片

DatagramSocket類

　　DatagramSocket類的作用就類似於碼頭，使用這個類的實例對象就可以發送和接收DatagramPacket數據包

構造方法：

技術分享圖片

　　該構造方法用於創建發送端的DatagramSocket對象，在創建DatagramSocket對象時，並沒有指定端口號，此時，系統會分配一個沒有被其它網絡程序所使用的端口號。

技術分享圖片

　　該構造方法既可用於創建接收端的DatagramSocket對象，又可以創建發送端的DatagramSocket對象，在創建接收端的DatagramSocket對象時，必須要指定一個端口號，這樣就可以監聽指定的端口。

常用方法：

技術分享圖片

例子：

UDP完成數據的發送：

package com.oracle.UdpTcp;

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.util.Scanner;

public class UDPSend {
    public static void main(String[] args) throws IOException {
        Scanner sc=new Scanner(System.in    );
        //InetAddress類調用getbyName方法返回一個本類對象
        InetAddress i=InetAddress.getByName("192.168.1.171");
        //創建DatagramSocket對象，
        DatagramSocket ds = new DatagramSocket();
        while(true){
            
            //構造數據報包，用來將長度為 length 的包發送到指定主機上的指定端口號。
            
            //定義字節數組來接收發送端的內容
            String mes=sc.next();
            byte[] bytes=mes.getBytes();
            //裝包
            DatagramPacket dp = new DatagramPacket(bytes, bytes.length, i, 6666);
            ds.send(dp);    
        }
                
    }
            
}

UDP完成數據的接收：

package com.oracle.UdpTcp;

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;

public class UdpS {
        public static void main(String[] args) throws IOException {
            //1,創建DatagramSocket對象,並指定端口號
            DatagramSocket ds = new DatagramSocket(8888);
            //創建接收數據的字節數組
            byte[] bytes =new byte[1024];
            //創建接收數據包
            while(true){
                DatagramPacket dp = new DatagramPacket(bytes, bytes.length);
                //接收
                ds.receive(dp);
                //獲取數據
                String ip=dp.getAddress().getHostAddress();//獲取IP地址
                int port=dp.getPort();//獲取端口號
                int length = dp.getLength();//獲取多少條數據
                System.out.println(ip+"..."+port+"發送的內容為"+new String(bytes,0,length));
            }
            
//            ds.close();
        }
}

TCP通信

　　在JDK中提供了兩個類用於實現TCP程序，一個是ServerSocket類，用於表示服務器端，一個是Socket類，用於表示客戶端。

　　通信時，首先創建代表服務器端的ServerSocket對象，該對象相當於開啟一個服務，並等待客戶端的連接，然後創建代表客戶端的Socket對象向服務器端發出連接請求，服務器端響應請求，兩者建立連接開始通信。

ServerSocket類

構造方法

技術分享圖片

　　使用該構造方法在創建ServerSocket對象時，就可以將其綁定到一個指定的端口號上（參數port就是端口號）。

ServerSocket的常用方法：

技術分享圖片

　　ServerSocket對象負責監聽某臺計算機的某個端口號，在創建ServerSocket對象後，需要繼續調用該對象的accept()方法，接收來自客戶端的請求。當執行了accept()方法之後，服務器端程序會發生阻塞，直到客戶端發出連接請求，accept()方法才會返回一個Scoket對象用於和客戶端實現通信，程序才能繼續向下執行。

Socket類

構造方法

技術分享圖片

技術分享圖片

常用方法;

方法聲明

功能描述

int getPort()

該方法返回一個int類型對象，該對象是Socket對象與服務器端連接的端口號

InetAddress getLocalAddress()

該方法用於獲取Socket對象綁定的本地IP地址，並將IP地址封裝成InetAddress類型的對象返回

void close()

該方法用於關閉Socket連接，結束本次通信。在關閉socket之前，應將與socket相關的所有的輸入/輸出流全部關閉，這是因為一個良好的程序應該在執行完畢時釋放所有的資源

InputStream getInputStream()

該方法返回一個InputStream類型的輸入流對象，如果該對象是由服務器端的Socket返回，就用於讀取客戶端發送的數據，反之，用於讀取服務器端發送的數據

OutputStream getOutputStream()

該方法返回一個OutputStream類型的輸出流對象，如果該對象是由服務器端的Socket返回，就用於向客戶端發送數據，反之，用於向服務器端發送數據

技術分享圖片

例子：

客戶端程序：

package com.oracle.Tcp;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.Socket;

public class TCPK {
    public static void main(String[] args) throws IOException {
        //創建socket對象，連接服務器
        Socket s=new Socket    ("127.0.0.1",7777    );
        //通過客戶端套接字對象Socket對象中的獲取字節輸出流的方法
        OutputStream out=s.getOutputStream();
        //將數據寫向服務器
        out.write("服務器你好".getBytes());
    //接收服務器端的回復
        InputStream in=s.getInputStream();
        byte[] bytes=new byte[1024];
        int len=in.read(bytes);
        System.out.println(new String(bytes,0,len));
        s.close();

    }
    
    
}

服務器端程序：

package com.oracle.Tcp;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;

public class TCPS {

    public static void main(String[] args) throws IOException {
        //創建服務器套接字
        ServerSocket  ss=new ServerSocket(7777);
        //調用ACCEPT方法與客戶端創建鏈接
        Socket s=ss.accept();
        InputStream in=s.getInputStream();
        byte[] bytes=new byte[1024];
        int len=in.read(bytes);
        System.out.println(new String(bytes,0,len));
        //服務器端給回復
        OutputStream out=s.getOutputStream();
        out.write("收到".getBytes());

    }

}

文件上傳案例

首先編寫服務器端程序，用來接收圖片。

package com.oracle.TCPS;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Random;

public class TCPS {

    public static void main(String[] args) throws IOException {
        ServerSocket  server=new ServerSocket(7500);//明確端口號
        Socket socket=server.accept();
        //讀取文件，明確數據源
        InputStream in=socket.getInputStream();
        //明確目的地
        File file=new File("e:\\JPG");
        //判斷文件是否存在
        if(!file.exists()){
            file.mkdirs();//沒有則創建文件夾
        }
        //域名+毫秒值+6位隨機數
//        隨機數
        String num="";
        for(int i=0;i<6;i++){
            num+=new Random().nextInt(10);
        }
        String filename="oracle"+System.currentTimeMillis()+num+".jpg";
        FileOutputStream fos=new FileOutputStream(file+File.separator+filename);
        //復制‘
        int len=0;
        byte[] bytes=new byte[1024];
        while((len=in.read(bytes))!=-1){
            fos.write(bytes,0,len);//往服務器端寫
        }
        //回復客戶端
        OutputStream out=socket.getOutputStream();
        out.write("上傳成功".getBytes());
        fos.close();
        server.close();
        
    }

}

客戶端程序：

package com.oracle.TCPS;

import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.Socket;
import java.net.UnknownHostException;

public class TCPK {

    public static void main(String[] args) throws UnknownHostException, IOException {
        //創建socket對象，連接服務器
                Socket socket=new Socket    ("127.0.0.1",7500    );
                //獲取Socket流中的輸出流，功能：用來把數據寫到服務器
                OutputStream out=socket.getOutputStream();
                //從文件讀到客戶端
                FileInputStream fis=new FileInputStream("E:\\QQwenjian\\1972680739\\FileRecv\\0601.jpg");
                //定義字節數組接收文件
                byte[] bytes=new byte[1024];
                
                int len=0;
                while((len=fis.read(bytes))!=-1){
                    out.write(bytes,0,len);
                }
                //客戶端發送數據完畢，結束Socket輸出流的寫入操作，告知服務器端，不再讀了
                socket.shutdownOutput();

                //接收服務器端的回復
                InputStream in=socket.getInputStream();
                 len=in.read(bytes);
                System.out.println(new String(bytes,0,len));//將字節數組內容轉成字符串打印出來
                //釋放資源
                fis.close();
                socket.close();
    }

}

多文件上傳案例

只需將服務器端代碼封裝改一下：

package com.oracle.TCPS;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.InetAddress;
import java.net.Socket;
import java.util.Random;

public class UpLoad implements Runnable{

    private Socket socket;
    public UpLoad(Socket socket){
        this.socket=socket;
    }
    public void run() {
        FileOutputStream fos=null;
        
        try{
            //顯示哪個客戶端Socket連接上了服務器
            InetAddress ipObject = socket.getInetAddress();//得到IP地址對象
            String ip = ipObject.getHostAddress(); //得到IP地址字符串
            System.out.println("小樣，抓到你了，連接我！！" + "IP:" + ip);
            
            //讀取文件，明確數據源
            InputStream in=socket.getInputStream();
            //明確目的地
            File file=new File("e:\\JPG");
            //判斷文件是否存在
            if(!file.exists()){
                file.mkdirs();//沒有則創建文件夾
            }
            //域名+毫秒值+6位隨機數
            String filename="oracle"+System.currentTimeMillis()+new Random().nextInt(6)+".jpg";
             fos=new FileOutputStream(file+File.separator+filename);
            //復制,把Socket輸入流中的數據，寫入目的地的字節輸出流中‘
            int len=0;
            byte[] bytes=new byte[1024];
            while((len=in.read(bytes))!=-1){
                fos.write(bytes,0,len);//往服務器端寫
            }
            //回復客戶端
            OutputStream out=socket.getOutputStream();
            out.write("上傳成功".getBytes());
            }catch (IOException ex){
                ex.printStackTrace();
            }finally{
                try {
                    fos.close();
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }

    
        
    }
    
}

測試類：

package com.oracle.TCPS;

import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;

public class Demo {

    public static void main(String[] args) throws IOException {
        ServerSocket  server=new ServerSocket(7500);//明確端口號
        while(true){
            Socket socket=server.accept();
            new Thread(new UpLoad(socket)).start();//匿名內部類
            
        }
    }

}

等待喚醒機制，UDP通信和TCP通信

相關推薦

等待喚醒機制，UDP通信和TCP通信

其它 www. cal 輸入 width tro interrupt 客戶端 ann 等待喚醒機制 　　通過等待喚醒機制使各個線程能有效的利用資源。 等待喚醒機制所涉及到的方法： 　　 wait（） :等待，將正在執行的線程釋放其執行資格 和 執行權，並存儲到線程池

python中多執行緒開啟的兩種方式（內含有event的應用，即安全的機制，類似於java的等待喚醒機制，不會出現多個執行緒之間的錯亂問題）

 event是類似於java中的等待喚醒機制，具體方法參照上一篇CSDN 下面來介紹開啟執行緒的第一種方式 #Filename:threading1.py #開啟執行緒的第一種方式 import threading import time event=threadin

線程間的通信--等待喚醒機制

return sta 程序 private 實現 tac 如何解決 因此 循環 1.多個線程操作相同的資源，但是操作動作不同，所以存在安全問題例如： public class Test { public static void main(String[] args)

【線程間通信：等待喚醒機制】

runnable lean ride system not 必須 this 消費者 clas 在線程安全解決之後，還是一樣存在著如下的問題： A：如果消費者先搶到CPU的執行權，就會去消費數據，但是現在的數據是默認值，沒有意義，應該等著數據有意義，再消費。 B：如果生產者先

TCP，UDP協議下的socket通信

() tcp write close 結構體 設置 In cep acc TCP通信流程 Server端： 創建套接字：socket( ) 創建sockaddr_in結構體變量，並設置相關參數 將套接字與IP、端口綁定：bind( ) 使套接字處於監聽狀態，等待Client

多執行緒的等待喚醒機制之消費者和生產者模式

/** * 等待喚醒之生產者和消費者模型 * 生成者: 建立和新增資料的執行緒 * 消費者: 銷燬和刪除資料的執行緒 * 問題1: 生成者生成資料過快, 消費者消費資料相對慢,不接收資料了, 會造成資料丟失 * 問題2: 消費者消費資料過快, 生成者生成資料相對慢,不傳送資料了, 會造成資料被重複讀取

Java第十四天學習筆記~多執行緒（執行緒直接通訊---等待喚醒機制、多生產者多消費者問題、JDK1.5新特性、wait和sleep區別）

執行緒直接通訊示例 //資源 class Resource { String name; String sex; } //輸入 class Input implements Runnable { Resource r; Input(Resource r) { this.r=r;

生產者和消費者之等待喚醒機制

package test48; /*** * 多執行緒：生產者消費者問題程式碼 * * 分析： 資源類：Student * 設定學生資料：SetThread(生產者) * 獲取學生資料：GetThread(消費者) * 測試類：Studen

執行緒間通訊、等待喚醒機制、生產者消費者問題(Lock,Condition)、停止執行緒和守護執行緒、執行緒優先順序

1  執行緒間通訊 1.1  執行緒間通訊 其實就是多個執行緒在操作同一個資源，但是操作的動作不同。 比如一個執行緒給一個變數賦值，而另一個執行緒列印這個變數。 1.2  等待喚醒機制 wait()：將執行緒等待，釋放了CPU執行權，同時將執行緒物件儲存到執行緒池中。 n

Java多執行緒生產者消費者說明等待喚醒機制問題和虛假喚醒問題

不用等待喚醒機制實現的生產者與消費者 程式碼 package com.hust.juc; /* * 生產者和消費者案例 */ public class TestProductorAndConsumer { public static vo

多執行緒等待喚醒機制：從wait()和sleep()的差別說起

1. wait():釋放資源，釋放鎖 sleep():釋放資源，不釋放鎖 wait():Object的方法，用在同步當中，是同步鎖的方法，以鎖控制執行緒 sleep():執行緒類Thread本身的靜態方法wait(),notify(),notifyAll()方法是用在同步當

多線程間的通訊之等待喚醒機制

run 出了 需求 stat 我們 out man http pre 線程間的通訊： 事實上就是多個線程在操作同一個資源。 可是操作動作不同 樣例： 需求：模擬簡單賣票系統(輸入一個人。緊接著輸出一個人) class Res { Stri

day11(多線程,喚醒機制，生產消費者模式，多線程的生命周期)

i++ 一個 false -- 輸出結果 ets exti tar ++ A:進程： 　　　　進程指正在運行的程序。確切的來說，當一個程序進入內存運行，即變成一個進程，進程是處於運行過程中的程序，並且具有一定獨立功能。 B:線程： 　　　　線程是進程中的一個執行單元，負責

WireShark開啟IP, TCP，UDP校驗和的辦法

分享 http 選項 .com har 校驗和 info 開啟 點擊 首先點擊編輯->首選項 WireShark開啟IP, TCP，UDP校驗和的辦法

模擬通信和數字通信

導致 高質量 處理 距離 圖像 放大 模擬 疊加 設備 無論何種通信系統，目的都是要完成一點到另一點的信息傳遞，這樣可以吧通信系統概括為一個統一的模型，如圖1. 圖1 信源：信源指發出信息的信息源，即信息的發出者。 變換器：變換器的功能是將信源發出的信息變換成適合在信道上

34-多執行緒--死鎖+執行緒間通訊+等待喚醒機制+多生產者多消費者問題

一、死鎖 1、死鎖的常見情形之一：同步的巢狀 說明：同步的巢狀，至少得有兩個鎖，且第一個鎖中有第二個鎖，第二個鎖中有第一個鎖。eg：同步程式碼塊中有同步函式，同步函式中有同步程式碼塊。下面的例子，同步程式碼塊的鎖是obj，同步函式的鎖是this。t1執行緒先執行同步程式碼塊，獲取鎖obj，需

多線程進階之等待喚醒機制

err read spa zed bject vat stat 算法 pre /* * 線程間通訊實例 * 多個線程在處理同一資源,但是任務不同 */ //資源 class Resource { String name; String sex; }

多執行緒等待喚醒機制

示例程式碼取自傳智播客畢向東老師25天Java基礎教程，添加了一些觀測列印程式碼，便於理解分析。對於程序分析理解純粹個人理解，剛學Java沒多久，難免有錯，僅供參考，如果大神們發現錯誤，希望能幫忙指出，也幫我走出錯誤的理解。 先貼程式碼 class Res{ String name; Str

python中多執行緒中event的使用-----------------即一個靈活的方法標誌位,類似於java的等待喚醒機制（python與java不同的地方）

event是python中一個特有的標誌位方法，他一共有三種方法 1.event.wait()：如果標誌位設定了，它不做任何事，如果沒有設定，則將會鎖住，等待標誌位的設定 2.event.set()：設定標誌位 3.event.clear()：清除標誌位 這一種機制很

java多執行緒之等待喚醒機制（wait-notify）

wait()、notify()、notifyAll()方法 Object類裡面提供了這幾個方法： wait()：讓當前執行緒處於等待（阻塞狀態），直到其他執行緒呼叫此物件的notify()或noti