2. 程式人生 > >java多執行緒實現TCP網路Socket程式設計(C/S通訊)

java多執行緒實現TCP網路Socket程式設計(C/S通訊)

阿新 • • 發佈：2020-10-30

目錄

開篇必知必會

一、多執行緒技術

二、實現多執行緒接收

       1、單執行緒版本

　　2、多執行緒版本

三、多執行緒與程序的關係

四、客戶端介面完整程式碼

五、多執行緒通訊對比

最後

開篇必知必會

在前一篇《Java：基於TCP協議網路socket程式設計(實現C/S通訊) 》，實際存在一個問題，如果伺服器端在建立連線後傳送多條資訊給客戶端，客戶端是無法全部接收的，原因在於客戶端為單執行緒，只接受了第一條資訊，剩餘資訊阻塞等待下一次傳送。所以，這造成了客戶端無法處理訊息佇列，每次只接收並輸出一條伺服器資訊，出現資訊不同步問題。

本篇將解決這個問題，詳細記錄實現java多執行緒通訊，目標是使客戶端可以一次接收伺服器傳送的多條資訊，避免阻塞。方法是將客戶端接收資訊功能獨立為一個執行緒來完成，進一步完善TCP的Socket網路通訊，C/S軟體架構的程式設計！

Java實現socket網路程式設計系列文章：

  1. UDP協議網路Socket程式設計(java實現C/S通訊案例) 
  2. Java：基於TCP協議網路socket程式設計(實現C/S通訊) 

一、多執行緒技術

首先，瞭解多執行緒技術。下圖是程式呼叫的順序執行（左：單執行緒）與執行緒呼叫的並行執行（右：多執行緒）

多執行緒程式則是右邊並行執行的方法。

在上一篇的TCPClientFX.java程式中，傳送資訊是可以通過“傳送”按鈕來實現主動控制，但是接收資訊是被動的，只能接收一條資訊，對於輸入流中有多少資訊是不可控制的。為此，我們使用多執行緒技術，新增一個執行緒專門負責讀取輸入流中的資訊。

在java中，主要有兩種實現多執行緒的方法，一是使用Thread類，二是使用Runnable類並實現run()方法。下面我是用Thread類實現，匿名內部類使用了lambda的寫法 ，顯得更加簡潔。

readThread = new Thread(()->{
    //匿名內部類函式體
 
});

二、實現多執行緒接收

1、單執行緒版本

首先，跟之前的單執行緒通訊對比一下，下面程式碼只能實現客戶端接收伺服器單條資訊，如果伺服器連續多條資訊傳送，則無法全部正確接收。連線成功後只能接收一條來自伺服器資訊。

        //連線按鈕
        btConn.setOnAction(event -> {
            String ip=ipAddress.getText().trim();
            String port=tfport.getText().trim();
 
            try {
                //tcpClient是本程式定義的一個TCPClient型別的成員變數
                tcpClient = new TCPClient(ip, port);
                //成功連線伺服器，接受伺服器發來的第一條歡迎資訊
                String firstMsg=tcpClient.receive();
                taDisplay.appendText(firstMsg+"\n");
                //連線伺服器之後未結束服務前禁用再次連線
                btConn.setDisable(true);
                //重新連線伺服器時啟用輸入傳送功能
                tfSend.setDisable(false);
                btnSend.setDisable(false);
            }catch (Exception e){
                taDisplay.appendText("伺服器連線失敗！"+e.getMessage()+"\n");
            }
        });

同樣，在傳送按鈕，每次也只能“發一條，收一條”，如下程式碼：

        //傳送按鈕事件
        btnSend.setOnAction(event -> {
            String msg=tfSend.getText();
            tcpClient.send(msg);//向伺服器傳送一串字元
            taDisplay.appendText("客戶端傳送："+msg+"\n");
            String receiveMsg=tcpClient.receive();//從伺服器接收一串字元
            taDisplay.appendText(receiveMsg+"\n");
            if (msg.equals("bye")){
                btnSend.setDisable(true);//傳送bye後禁用傳送按鈕
                tfSend.setDisable(true);//禁用Enter傳送資訊輸入區域
                //結束服務後再次啟用連線按鈕
                btConn.setDisable(false);
            }
            tfSend.clear();
        });

2、多執行緒版本

根據前面分析，只需要將客戶端接收的功能交給一個執行緒處理，就能夠達到目的，不會因為接收語句阻塞使得主程序卡住。

所以，將執行緒放到連線按鈕裡面為好，在成功連線伺服器之後，程式就啟動執行緒，時機正好。程式碼修改如下：

        //連線按鈕
        btConn.setOnAction(event -> {
            String ip=ipAddress.getText().trim();
            String port=tfport.getText().trim();
 
            try {
                //tcpClient是本程式定義的一個TCPClient型別的成員變數
                tcpClient = new TCPClient(ip, port);
                //用於接收伺服器資訊的單獨執行緒
                readThread = new Thread(()->{
                    String receiveMsg=null;//從伺服器接收一串字元
                    while ((receiveMsg=tcpClient.receive())!=null){
                        //lambda表示式不能直接訪問外部非final型別區域性變數，需要定義一個臨時變數
                        //若將receiveMsg定義為類成員變數，則無需臨時變數
                        String msgTemp = receiveMsg;
                        Platform.runLater(()->{
                            now = LocalDateTime.now();
                            taDisplay.setStyle("-fx-text-fill:red");
                            taDisplay.appendText(dtf.format(now) +"\n");
//                            taDisplay.setStyle("-fx-text-fill:black");
                            taDisplay.appendText(msgTemp+"\n");
                        });
                    }
                    Platform.runLater(()->{
                        taDisplay.appendText("對話已關閉！\n");
                    });
                });
 
                readThread.start();
                //連線伺服器之後未結束服務前禁用再次連線
                btConn.setDisable(true);
                //重新連線伺服器時啟用輸入傳送功能
                tfSend.setDisable(false);
                btnSend.setDisable(false);
            }catch (Exception e){
                taDisplay.appendText("伺服器連線失敗！"+e.getMessage()+"\n");
            }
        });

三、多執行緒與程序的關係

做到這裡，已經完成多執行緒通訊的功能。不過，在不斷除錯時候會發現，關閉窗體的時候，終端會出現Socket已關閉，輸入輸出流未正常關閉、執行緒異常等問題。如下錯誤：

java.net.SocketException: Socket closed

這是為何呢？原因就是多執行緒與程式的關係。

由於程式開啟了多執行緒，這就存在有幾個執行緒處理問題。那麼，在我們手動關閉窗體的時候，有的執行緒處於等待狀態，等待IO操作，並非在關閉的同時所有執行緒立即也關閉了，所以解決方法就是，設定一小段間隔時間保證所有執行緒已關閉。

在退出方法裡面設定執行緒睡眠時間，保證退出按鈕和關閉窗體不丟擲此類異常。

    private void exit() throws InterruptedException {
        if (tcpClient!=null){
            tcpClient.send("bye");
            readThread.sleep(1000);//多執行緒等待，關閉視窗時還有執行緒等待IO，設定1s間隔保證所有執行緒已關閉
            tcpClient.close();
        }
        System.exit(0);
    }

四、客戶端介面完整程式碼

/*
 *  TCPClientThreadFX.java
 * Copyright (c) 2020-10-25
 * author : Charzous
 * All right reserved.
 */
 
import javafx.application.Application;
import javafx.application.Platform;
import javafx.event.EventHandler;
import javafx.geometry.Insets;
import javafx.geometry.Pos;
import javafx.scene.Scene;
import javafx.scene.control.Button;
import javafx.scene.control.Label;
import javafx.scene.control.TextArea;
import javafx.scene.control.TextField;
import javafx.scene.input.KeyCode;
import javafx.scene.input.KeyEvent;
import javafx.scene.layout.BorderPane;
import javafx.scene.layout.HBox;
import javafx.scene.layout.Priority;
import javafx.scene.layout.VBox;
import javafx.stage.Stage;
 
 
 
public class TCPClientThreadFX extends Application {
 
    private Button btnExit=new Button("退出");
    private Button btnSend = new Button("傳送");
 
    private TextField tfSend=new TextField();//輸入資訊區域
 
    private TextArea taDisplay=new TextArea();//顯示區域
    private TextField ipAddress=new TextField();//填寫ip地址
    private TextField tfport=new TextField();//填寫埠
    private Button btConn=new Button("連線");
    private TCPClient tcpClient;
    private Thread readThread;
 
    public static void main(String[] args) {
        launch(args);
    }
 
    @Override
    public void start(Stage primaryStage) {
        BorderPane mainPane=new BorderPane();
 
        //連線伺服器區域
        HBox hBox1=new HBox();
        hBox1.setSpacing(10);
        hBox1.setPadding(new Insets(10,20,10,20));
        hBox1.setAlignment(Pos.CENTER);
        hBox1.getChildren().addAll(new Label("ip地址："),ipAddress,new Label("埠："),tfport,btConn);
        mainPane.setTop(hBox1);
 
        VBox vBox=new VBox();
        vBox.setSpacing(10);
 
        vBox.setPadding(new Insets(10,20,10,20));
        vBox.getChildren().addAll(new javafx.scene.control.Label("資訊顯示區"),taDisplay,new Label("資訊輸入區"),tfSend);
 
        VBox.setVgrow(taDisplay, Priority.ALWAYS);
        mainPane.setCenter(vBox);
 
 
 
        HBox hBox=new HBox();
        hBox.setSpacing(10);
        hBox.setPadding(new Insets(10,20,10,20));
        hBox.setAlignment(Pos.CENTER_RIGHT);
        hBox.getChildren().addAll(btnSend,btnExit);
        mainPane.setBottom(hBox);
 
        Scene scene =new Scene(mainPane,700,500);
        primaryStage.setScene(scene);
        primaryStage.show();
        //連線按鈕
        btConn.setOnAction(event -> {
            String ip=ipAddress.getText().trim();
            String port=tfport.getText().trim();
 
            try {
                //tcpClient是本程式定義的一個TCPClient型別的成員變數
                tcpClient = new TCPClient(ip, port);
                //用於接收伺服器資訊的單獨執行緒
                readThread = new Thread(()->{
                    String receiveMsg=null;//從伺服器接收一串字元
                    while ((receiveMsg=tcpClient.receive())!=null){
                        //lambda表示式不能直接訪問外部非final型別區域性變數，需要定義一個臨時變數
                        //若將receiveMsg定義為類成員變數，則無需臨時變數
                        String msgTemp = receiveMsg;
                        Platform.runLater(()->{
                            taDisplay.appendText(msgTemp+"\n");
                        });
                    }
                    Platform.runLater(()->{
                        taDisplay.appendText("對話已關閉！\n");
                    });
                });
 
                readThread.start();
                //連線伺服器之後未結束服務前禁用再次連線
                btConn.setDisable(true);
                //重新連線伺服器時啟用輸入傳送功能
                tfSend.setDisable(false);
                btnSend.setDisable(false);
            }catch (Exception e){
                taDisplay.appendText("伺服器連線失敗！"+e.getMessage()+"\n");
            }
        });
 
//        btConn.defaultButtonProperty();
 
        //傳送按鈕事件
        btnSend.setOnAction(event -> {
            String msg=tfSend.getText();
            tcpClient.send(msg);//向伺服器傳送一串字元
            taDisplay.appendText("客戶端傳送："+msg+"\n");
            if (msg.equalsIgnoreCase("bye")){
                btnSend.setDisable(true);//傳送bye後禁用傳送按鈕
                tfSend.setDisable(true);//禁用Enter傳送資訊輸入區域
                //結束服務後再次啟用連線按鈕
                btConn.setDisable(false);
            }
            tfSend.clear();
        });
        //對輸入區域繫結鍵盤事件
        tfSend.setOnKeyPressed(new EventHandler<KeyEvent>() {
            @Override
            public void handle(KeyEvent event) {
               if(event.getCode()==KeyCode.ENTER){
                   String msg=tfSend.getText();
                   tcpClient.send(msg);//向伺服器傳送一串字元
                   taDisplay.appendText("客戶端傳送："+msg+"\n");
 
                   if (msg.equalsIgnoreCase("bye")){
                       tfSend.setDisable(true);//禁用Enter傳送資訊輸入區域
                       btnSend.setDisable(true);//傳送bye後禁用傳送按鈕
                       //結束服務後再次啟用連線按鈕
                       btConn.setDisable(false);
                   }
                   tfSend.clear();
                }
            }
        });
 
        btnExit.setOnAction(event -> {
            try {
                exit();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        //窗體關閉響應的事件,點選右上角的×關閉,客戶端也關閉
        primaryStage.setOnCloseRequest(event -> {
            try {
                exit();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
    }
 
    private void exit() throws InterruptedException {
        if (tcpClient!=null){
            tcpClient.send("bye");
            readThread.sleep(1000);//多執行緒等待，關閉視窗時還有執行緒等待IO，設定1s間隔保證所有執行緒已關閉
            tcpClient.close();
        }
        System.exit(0);
    }
}
View Code

服務端和客戶端的程式可以沿用上一篇的內容，這裡不再貼出程式碼，詳見這篇：Java：基於TCP協議網路socket程式設計(實現C/S通訊) 

五、多執行緒通訊對比

那到底可以看出有什麼不同呢，現在來驗證一下，我們修改一下服務端返回資訊的程式碼，在增加一行使伺服器連續傳送重複資訊。

pw.println("來自伺服器訊息："+msg);
pw.println("來自伺服器,重複訊息："+msg);

之前單執行緒程式效果這樣，當服務端也是“一發一收”狀態，客戶端“一發一收”，這沒有問題：

服務端增加一行使伺服器連續傳送重複資訊，結果變成這樣，明顯出現錯誤，可以自行分析單執行緒與多訊息的執行情況：

客戶端介面實現多執行緒之後，解決問題！

最後

本篇詳細記錄實現java多執行緒通訊，目標達到客戶端可以一次接收伺服器傳送的多條資訊，避免阻塞。將客戶端接收資訊功能獨立為一個執行緒來完成，進一步完善TCP的Socket網路通訊，解決單執行緒存在的問題，也是上一篇部落格留下來的一個問題。

另外一個問題是什麼呢？這裡停留思考3秒！

……

……

……

就是：現在只能單使用者與伺服器正常通訊，如果多使用者情況下，比如開啟多個客戶端介面連線伺服器，存在一個很大問題，伺服器端只實現了單使用者功能，那麼，馬上想到，舉一反三，使用本篇多執行緒技術應用到伺服器端，是否能夠解決多使用者的功能呢？要解決這個問題，等待更新下一篇！

如果覺得不錯歡迎推薦收藏關注，有問題直接評論，交流學習！

Java實現socket網路程式設計系列文章：

  1. UDP協議網路Socket程式設計(java實現C/S通訊案例) 
  2. Java：基於TCP協議網路socket程式設計(實現C/S通訊) 

我的部落格園：https://www.cnblogs.com/chenzhenhong/p/13901096.html

我的CSDN部落格：https://blog.csdn.net/Charzous/article/details/109283697

版權宣告：本文為博主原創文章，遵循 CC 4.0 BY-SA 版權協議，轉載請附上原文出處連結和本宣告。 本文連結：https://blog.csdn.net/Charzous/article/details/1092836

相關推薦

java多執行緒實現TCP網路Socket程式設計(C/S通訊)

目錄 開篇必知必會 一、多執行緒技術 二、實現多執行緒接收        1、單執行緒版本 　　2、多執行緒版本 三、多執行緒與程序的關係 四、客戶端介面完整程式碼 五、多執行緒通訊對比 最後 開篇必知必會 在前一篇《Java：基於TCP協議網路socket程式設計(

二、多執行緒實現簡單的socket通訊例項（TCP）

1.伺服器端 import java.io.*; import java.net.ServerSocket; import java.net.Socket; /** * 類功能描述：先啟動伺服器端，再啟動客戶端 * * @author：*** * @createTime：2018/

網路採集器Demo：Jsoup+Java多執行緒實現[爬蟲]（上）

裡面最簡單，但是很常用的一個部分，就是網路爬蟲，從網頁上獲取文字資訊 這裡用到兩個工具，一個就是Java多執行緒（基於Java5 以上的執行緒池模式，區別於過時的Runable），另外一個是一個小工具：Jsoup，用於解析html網頁，獲取其中的內容，關於Jsoup的使用

Java多執行緒實現電影院售票案例

某電影院目前正在上映賀歲大片，共有100張票，而它有3個售票視窗，請設計一個程式模擬該電影院售票。 定義Sell類實現Runnable介面，很好的解決了單繼承共享資源問題 public class Sell implements Runnable { // 定義100張票，三個售票

Java 多執行緒實現死鎖場景

簡述： 《Java 程式設計思想》  P718 ~ P722 模擬死鎖的場景， 三個人 三根筷子，每個人需要拿到身邊的兩根筷子才能開始吃飯 出現死鎖的場景是，三個人都拿到了右邊的筷子，但是由於筷子都被搶佔，均無法獲得左邊的筷子 Chopstick.java

多執行緒實現udp網路通訊

本章節將介紹主執行緒與子執行緒的關係；使用udp利用多執行緒在python環境下實現全雙工通訊程式碼的兩種實現。（未完待續。。。） 一、主執行緒與子執行緒的關係： 1,若主執行緒無程式碼執行，主執行緒將等待子執行緒結束而結束。 2,執行緒的執行並無先後順序。 3,若主執行緒因特殊原因先結束，子執行緒也

java:多執行緒(實現Runnable的原理)及二種方式的區別

* 1,看Thread類的建構函式,傳遞了Runnable介面的引用  * 2,通過init()方法找到傳遞的target給成員變數的target賦值 * 3,檢視run方法,發現run方法中有判斷,如果target不為null就會呼叫Runnable介面子類物件的run方法 *

Java多執行緒實現的方式

Java多執行緒實現的方式有四種 1.繼承Thread類，重寫run方法 2.實現Runnable介面，重寫run方法，實現Runnable介面的實現類的例項物件作為Thread建構函式的target 3.通過Callable和FutureTask建立執行緒 4.通過執行緒池建立執行

(CSDN遷移) JAVA多執行緒實現-實現Runnable介面

實現Runnable介面  implements Runnable 重寫run()方法 @Override public void run(){//TODO} 建立執行緒物件： Thread thread1 = new Thread(new Implement

(CSDN遷移)JAVA多執行緒實現-單執行緒化執行緒池newSingleThreadExecutor

JAVA通過Executors提供了四種執行緒池，單執行緒化執行緒池(newSingleThreadExecutor)、可控最大併發數執行緒池(newFixedThreadPool)、可回收快取執行緒池(newCachedThreadPool)、支援定時與週期性任務的執行緒池(newScheduledThre

(CSDN遷移) JAVA多執行緒實現-可控最大併發數執行緒池(newFixedThreadPool)

上篇文章中介紹了單執行緒化執行緒池newSingleThreadExecutor，可控最大併發數執行緒池(newFixedThreadPool)與其最大的區別是可以通知執行多個執行緒，可以簡單的將newSingleThreadExecutor理解為newFixedThreadPool(1)。例如執行一下兩個程

Java多執行緒實現以及執行緒安全筆記

Java虛擬機器允許應用程式併發地執行多個執行緒。 以下為多執行緒的實現常用的2種方法 （1）繼承Thread類，重寫run()方法      Thread本質上也是實現了Runnable介面的一個例項，代表一個執行緒的例項。啟用執行緒的唯一方法就是通過Thread類的

用java多執行緒實現一個簡單的水池進出水問題

需求： 有一個水池100L，有出水口和入水口,出水口和入水口不能同時開啟，入水口每次注入5L水，出水口每次出4L水，如果池子注滿水，或者池子中沒有水就停止。 使用繼承Thread類的方式編寫出水口，使用實現Runnable方式編寫入水口，執行結果。 package po

Java多執行緒實現加法計算

採用多執行緒的方式實現從1到N的和 1.直接順序計算 public static void Sum(int N){ long start1 = System.currentTimeMillis(); long sum = 0;

JAVA多執行緒實現的四種方式

         昨天自己用ExecutorService建立執行緒池做穿透測試了一下,感覺挺有意思,所以又好好的看了一下執行緒的問題,在此轉載了一篇博友的文章,感覺總結的不錯,所以分享一下. Java多執行緒實現方式主要有四種： 繼承Thread類、實現Runnable

JAVA 多執行緒實現方式

一般實現得方式有倆種： 實現Runnable介面。該介面中的方法run()，來實現建立執行緒。 繼承Thread類。 這倆種實現執行緒得方式對比而言： 一個Thread物件只能建立一個執行緒，即使它呼叫多次的.start()也會只執行一個的執行緒。建立多個執行緒就需要多個Thread

java多執行緒實現搶紅包

在準備寫這個程式碼之前，我著實的複習和加深了對執行緒操作的使用，同步和資料共享！ 說一下程式碼的思路： 首先搶紅包，人、紅包抽象為兩個物件，人（獲取到紅包）紅包（總額，數量，提供生成隨機金額方法） 其

Java多執行緒-----實現生產者消費者模式的幾種方式

   1 生產者消費者模式概述      生產者消費者模式就是通過一個容器來解決生產者和消費者的強耦合問題。生產者和消費者彼此之間不直接通訊，而通過阻塞佇列來進行通訊，所以生產者生產完資料之後不用等待消費者處理， 直接扔給阻塞佇列，消費者不找生產者要資料，

JAVA多執行緒實現的三種方式及內部原理

JAVA多執行緒實現方式主要有三種：繼承Thread類、實現Runnable介面、使用ExecutorService、Callable、Future實現有返回結果的多執行緒。其中前兩種方式執行緒執行完

java多執行緒實現Runnable

class aa implements Runnable{ private String name; public aa(String name){ this.name=name; } public void run() { for(i