socket，執行緒池（TCP通訊）

阿新 • • 發佈：2019-02-13

Server 1

package day20150914socket;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.InetAddress;
import java.net.ServerSocket;
import java.net.Socket;

/**
 * 服務端應用程式
 * （MINA的本質也是使用server）
 */
public class Server 
 {
    //服務端的Socket
    private ServerSocket server;
    //構造方法，用於初始化服務端
    public Server() throws IOException{
        try {
            System.out.println("初始化服務端");
            /*
             * 建立ServerSocket時需要指定的服務埠
             */
            server = new ServerSocket(8088);
            System.out.println("服務端初始化完畢" 
);
        } catch (IOException e) {
            throw e;
        }
    }

    public void start(){
        try {
            System.out.println("等待客戶端連線。。。");
            /*
             * ServerSocket的accept()方法：
             * 用於監聽8088埠，等待客戶連線， 否則該方法阻塞。
             * 若一個客戶端連線了，會返回給客戶端的Socket
             */ 

            Socket socket = server.accept();
            //獲取遠端（客戶端）地址
            InetAddress address = socket.getInetAddress();
            //獲取遠端IP地址
            String ip = address.getHostAddress();
            //獲取遠端埠號
            int port = socket.getPort();
            System.out.println(ip+":"+port+"客戶端連線上了");
            /*
             * 通過剛剛連線上來的客戶端的Socket獲取輸入流
             * 來讀取客戶端發過來的資訊
             */
            InputStream in = socket.getInputStream();
            //將位元組輸入流包裝為字元輸入流，這樣就可指定編碼集
            InputStreamReader isr = new InputStreamReader(in,"utf-8");
            //將字元流轉為緩衝字元輸入流，這樣就可以以行為單位來讀取字串了
            BufferedReader br = new BufferedReader(isr);
            String message = null;
            while((message=br.readLine())!=null){
                System.out.println("客戶端說："+message);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }

    }

    public static void main(String[] args) {
        try {
            Server server = new Server();
            server.start();
        } catch (IOException e) {
            e.printStackTrace();
            System.out.println("伺服器初始化失敗");
        }

    }

}

Client 1

package day20150914socket;

import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.net.Socket;
import java.util.Scanner;

public class Client {
    //用於連線伺服器端的Socket
    private Socket socket;

    public Client() throws Exception{
        try {
            System.out.println("正在連線服務端。。。");
            /*
             * 建立Socket物件，
             * 就會嘗試根據給定的地址與埠連線伺服器
             * 所以，若該物件建立成功，說明與伺服器端連線正常
             */
            //localhost:本機。連線其他計算機可寫IP
            socket = new Socket("localhost",8088);
            System.out.println("成功連線服務端。");
        } catch (Exception e) {
            throw e;
        }
    }

    public void start(){
        try{
            /*
             * 可以通過Socket的getOutputStream()方法獲取一條輸出流
             * 用於將資訊傳送至伺服器
             */
            OutputStream out = socket.getOutputStream();
            /*
             *使用字元流指定編碼集將字串轉為位元組後，
             *再通過out傳送給伺服器 
             */
            OutputStreamWriter osr = new OutputStreamWriter(out,"utf-8");
            /*
             * 將字元流包裝為緩衝字元流
             * 就可以以行為單位寫出字串了。
             */
            PrintWriter pw = new PrintWriter(osr);

            Scanner sc = new Scanner(System.in);
            while(true){
                String str = sc.nextLine();
                pw.println(str);
                pw.flush();
            }
        }catch(Exception e){
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        try {
            Client client = new Client();
            client.start();
        } catch (Exception e) {
            e.printStackTrace();
            System.out.println("客戶端初始化失敗");
        }
    }

}

Server(2)

package day20150914socket2;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.net.InetAddress;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * 服務端應用程式
 * （MINA的本質也是使用server）
 */
public class Server2 {
    //服務端的Socket
    private ServerSocket server;
    //執行緒池，用於管理客戶端連線的互動執行緒
    private ExecutorService threadPool;
    //儲存所有客戶端輸出流的集合
    private List<PrintWriter> allOut;
    //構造方法，用於初始化服務端
    public Server2() throws IOException{
        try {
            System.out.println("初始化服務端");
            /*
             * 建立ServerSocket時需要指定的服務埠
             */
            server = new ServerSocket(8088);
            //初始化執行緒池
            threadPool = Executors.newFixedThreadPool(50);
            /*
             * 初始化存放所有客戶端輸出流的集合
             * 使用ArrayList而不是linkedList的原因：
             * 增刪元素不頻繁，而是使用遍歷頻繁
             */
            allOut = new ArrayList<PrintWriter>();
            System.out.println("服務端初始化完畢");
        } catch (IOException e) {
            throw e;
        }
    }

    public void start(){
        try {
            /*
             * ServerSocket的accept()方法：
             * 用於監聽8088埠，等待客戶連線， 否則該方法阻塞。
             * 若一個客戶端連線了，會返回給客戶端的Socket
             */
            while(true){
                System.out.println("等待客戶端連線。。。");
                Socket socket = server.accept();
                /*
                 * 當一個客戶端連線後，啟動一個執行緒ClientHandler
                 * 將客戶端的socket傳入，使得該執行緒處理與該客戶端的互動
                 * 這樣，可再次進入迴圈，接收下一個客戶端的連線
                 */
                Runnable handler = new ClientHandler(socket);
                //Thread t = new Thread(handler);
                //t.start();
                /*
                 * 使用執行緒池分配空閒執行緒來處理當前連線的客戶端
                 */
                threadPool.execute(handler);
            }

        } catch (IOException e) {
            e.printStackTrace();
        }

    }
    /**
     * 將給定的輸出流存入共享集合
     * 
     * 加synchronized關鍵字，鎖定Server物件，
     * 下面3個方法鎖定後，互斥（3個方法鎖定同一個物件）
     * 即一個執行緒訪問其中一個方法後，
     * 其他執行緒不可訪問這3個方法中的任何一個
     */
    public synchronized void addOut(PrintWriter pw){
        allOut.add(pw);
    }
    /**
     * 將給定的輸出流從共享集合中刪除
     */
    public synchronized void removeOut(PrintWriter pw){
        allOut.remove(pw);
    }
    /**
     * 將給定的訊息轉發給所有客戶端
     */
    public synchronized void sendMessage(String message){
        for(PrintWriter pw : allOut){
            pw.println(message);
        }
    }
    public static void main(String[] args) {
        try {
            Server2 server = new Server2();
            server.start();
        } catch (IOException e) {
            e.printStackTrace();
            System.out.println("伺服器初始化失敗");
        }

    }
    /**
     * 伺服器端的一個執行緒，用於與某個客戶端互動，
     * 使用執行緒的目的是使得伺服器可以處理多個客戶端了
     */
    class ClientHandler implements Runnable{
        //當前執行緒處理的客戶端的socket
        private Socket socket;
        //當前客戶端的IP
        private String ip;
        //當前客戶端的暱稱
        private String nickname;
        /**
         * 根據給定的客戶端的Socket，建立執行緒體
         */
        public ClientHandler(Socket socket){
            this.socket = socket;
            //獲取遠端（客戶端）地址
            InetAddress address = socket.getInetAddress();
            //獲取遠端IP地址
            ip = address.getHostAddress();
            //獲取遠端埠號
            int port = socket.getPort();
            //改為使用暱稱，所以不在這裡通知了
            //System.out.println(ip+":"+port+"客戶端連線上了");
        }
        /**
         * 該執行緒會將當前socket中的輸入流獲取
         * 用來迴圈讀取客戶端傳送過來的訊息
         */
        @Override
        public void run() {
            PrintWriter pw = null;
            try{
                /*
                 * 為了讓服務端向客戶端傳送資訊
                 * 通過socket獲取輸出流
                 */
                OutputStream out = socket.getOutputStream();
                //轉為字元流，用於指定編碼集
                OutputStreamWriter osr = new OutputStreamWriter(out,"utf-8");
                //建立緩衝字元輸出流，true自動行重新整理
                pw = new PrintWriter(osr,true);
                /*
                 * 將該客戶端的輸出流存入共享集合
                 * 以便使得該客戶端也能接收伺服器轉發的訊息
                 */
                //allOut.add(pw);
                addOut(pw);
                System.out.println("當前線上人數："+allOut.size());
                /*
                 * 通過剛剛連線上來的客戶端的Socket獲取輸入流
                 * 來讀取客戶端發過來的資訊
                 */
                InputStream in = socket.getInputStream();
                //將位元組輸入流包裝為字元輸入流，這樣就可指定編碼集
                InputStreamReader isr = new InputStreamReader(in,"utf-8");
                //將字元流轉為緩衝字元輸入流，這樣就可以以行為單位來讀取字串了
                BufferedReader br = new BufferedReader(isr);
                //當建立好當前客戶端的輸入流後，讀取的第一個字串應當是暱稱
                nickname = br.readLine();
                //通知所有客戶端，當前使用者上線了
                sendMessage("["+nickname+"]上線了");
                sendMessage("當前線上人數為："+allOut.size());//告知所有客戶端線上人數
                String message = null;
                /*
                 * 讀取客戶端發來的一行字串
                 * windows與linux的差異：
                 * linux：當客戶端斷開連線後，通過輸入流會讀取到null,
                 * 這是合乎邏輯的，
                 * 因為緩衝流的readLine方法若返回null就無法通過該流讀取到資訊
                 * 
                 * windows：當客戶端與伺服器端斷開接連後
                 * readLine()方法會丟擲異常
                 */
                while((message=br.readLine())!=null){
                    //System.out.println("客戶端說："+message);
                    //pw.println(message);//把客戶端發來的訊息回給客戶端
                    //當前客戶端說話內容告訴給所有客戶端
                    sendMessage(nickname+"說："+message);
                }
            }catch(Exception e){
                /*
                 * 在windows中的客戶端
                 * 報錯通常是因為客戶端斷開了連線
                 * 
                 * 不用關流，可直接關Socket
                 */
            }finally{
                /*
                 * 首先將該客戶端的輸出流從共享集合中刪除
                 */
                //allOut.remove(pw);
                removeOut(pw);

                //控制檯顯示該使用者下線了
                System.out.println("["+nickname+"]下線了");
                //通知其他使用者該使用者下線了
                sendMessage("["+nickname+"]下線了");

                //輸出當前線上人數（輸出流的個數）
                System.out.println("當前線上人數為："+allOut.size());
                sendMessage("當前線上人數為："+allOut.size());//告知所有客戶端線上人數

                /*
                 * 無論是linux使用者還是windows使用者，
                 * 當客戶與服務端斷開連線後，
                 * 我們都應當在伺服器端與客戶端斷開連線
                 */
                try {
                    socket.close();
                    //關閉之後，catch處理意義也不大，故catch塊裡的內容可為空
                } catch (IOException e) {
                }
                //System.out.println("一個客戶端下線了");
            }
        }

    }

}

Client(2)

package day20150914socket2;

import java.io.BufferedReader;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.net.Socket;
import java.util.Scanner;

public class Client2 {
    //用於連線伺服器端的Socket
    private Socket socket;

    public Client2() throws Exception{
        try {
            System.out.println("正在連線服務端。。。");
            /*
             * 建立Socket物件，
             * 就會嘗試根據給定的地址與埠連線伺服器
             * 所以，若該物件建立成功，說明與伺服器端連線正常
             */
            //localhost:本機。連線其他計算機可寫IP
            socket = new Socket("localhost",8088);
            System.out.println("成功連線服務端。");
        } catch (Exception e) {
            throw e;
        }
    }
    /**
     * 客戶端啟動方法
     */
    public void start(){
        try{
            //建立並啟動執行緒，來接收伺服器端傳送過來的訊息
            Runnable runn = new GetServerInfoHandler();
            Thread t = new Thread(runn);
            t.start();
            /*
             * 可以通過Socket的getOutputStream()方法獲取一條輸出流
             * 用於將資訊傳送至伺服器
             */
            OutputStream out = socket.getOutputStream();
            /*
             *使用字元流指定編碼集將字串轉為位元組後，
             *再通過out傳送給伺服器 
             */
            OutputStreamWriter osr = new OutputStreamWriter(out,"utf-8");
            /*
             * 將字元流包裝為緩衝字元流
             * 就可以以行為單位寫出字串了。
             */
            PrintWriter pw = new PrintWriter(osr,true);//true，自動行重新整理
            //建立一個Scanner,用於接收使用者輸入的字串
            Scanner sc = new Scanner(System.in);
            //輸出歡迎語
            System.out.println("歡迎來到傳奇的聊天室");
            while(true){
                System.out.println("請輸入暱稱");
                String nickname = sc.nextLine();
                if(nickname.trim().length()>0){
                    pw.println(nickname);
                    break;
                }
                System.out.println("暱稱不能為空");
            }
            while(true){
                String str = sc.nextLine();
                pw.println(str);
                //pw.flush();//PrintWriter自動行重新整理就不要此句了
            }
        }catch(Exception e){
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        try {
            Client2 client = new Client2();
            client.start();
        } catch (Exception e) {
            e.printStackTrace();
            System.out.println("客戶端初始化失敗");
        }
    }
    /**
     * 該執行緒的作用是迴圈接收伺服器端傳送過來的資訊，
     * 並輸出到控制檯
     */
    class GetServerInfoHandler implements Runnable{

        @Override
        public void run() {
            try{
                //通過socket獲取輸入流
                InputStream in = socket.getInputStream();
                //將位元組輸入流轉為字元輸入流，指定編碼集
                InputStreamReader isr = new InputStreamReader(in,"utf-8");
                //將字元流轉為緩衝字元輸入流，這樣就可以以行為單位來讀取字串了
                BufferedReader br = new BufferedReader(isr);
                String message = null;
                //迴圈讀取服務端傳送過來的每個字串
                while((message=br.readLine())!=null){
                    //將服務端傳送的字串輸出到控制檯
                    System.out.println(message);
                }
            }catch(Exception e){

            }
        }
    }
}

socket，執行緒池（TCP通訊）

Server 1 package day20150914socket; import java.io.BufferedReader; import java.io.IOException; import java.io.InputStream; impo

併發新特性—Executor框架與執行緒池（含程式碼）

Executor框架簡介在Java 5之後，併發程式設計引入了一堆新的啟動、排程和管理執行緒的API。Executor框架便是Java 5中引入的，其內部使用了執行緒池機制，它在java.util.cocurrent 包下，通過該框架來控制執行緒的啟動、執行

Linux雜談: 實現一種簡單實用的執行緒池（C語言）

基本功能 1. 實現一個執行緒的佇列，佇列中的執行緒啟動後不再釋放； 2. 沒有任務執行時，執行緒處於pending狀態，等待喚醒，不佔cpu； 3. 當有任務需要執行時，從執行緒佇列中取出一個執行緒執行任務； 4. 任務執行完成後執行緒再次進入pending狀態，等待喚醒；擴充套件功能 1.

如何實現自己的執行緒池（不看後悔，一看必懂）

首先，在服務啟動的時候，我們可以啟動好幾個執行緒，並用一個容器(如執行緒池)來管理這些執行緒。當請求到來時，可以從池中取一個執行緒出來，執行任務(通常是對請求的響應)，當任務結束後，再將這個執行緒放入池中備用；如果請求到來而池中沒有空閒的執行緒，該請求需要排隊等候。最後，當服務關閉時銷燬該池即可

java中常見的執行緒池（不看後悔，一看必懂）

Executor介面表示執行緒池,它的execute(Runnable task)方法用來執行Runnable型別的任務,ExecutorService是Executor的子介面,聲明瞭管理執行緒池的一些方法 Java.util.concurrent.Executors類包含了一些靜態

執行緒（十一）兩種傳統傳統方式建立：（thread、Runnable），執行緒池方式ExcutorServicePool

傳統方式建立執行緒： 1、繼承Thread類，重寫run方法 2、實現Runnable介面，覆蓋介面中的run方法，然後將介面實現扔給Thread run方法探祕： Thread原始碼中的run方法，如下： @Override public void run

JAVA基礎24-多執行緒（四）【讀寫鎖，阻塞佇列，執行緒池】

一、讀寫鎖使用步驟二、阻塞佇列 (BlockingQueue) 提供執行緒安全的佇列訪問方式；當阻塞佇列進行插入資料時，若佇列滿，則執行緒阻塞，直到佇列非滿的時候當阻塞佇列取資料時，若佇列為空，則執行緒阻塞直到佇列非空時候。

（四）java 執行緒，執行緒池的使用

為什麼要使用執行緒池？建立執行緒是簡單的，但啟動後的執行緒猶如脫繮野馬，難於管理，特別是多執行緒使用場景，執行緒之間的互相競爭，可能使 cpu 花費更多時間在各個執行緒之間切換，而且執行緒結束後的回收由垃圾回收控制，你不知道工作結束的執行緒還會存活多久，是否持有著什麼資源。而

當問起執行緒池（Java中的ThreadPoolExecutor類），你應該知道的基礎知識點

執行緒池執行緒池是一種多執行緒處理形式，處理過程中將任務新增到佇列，然後在建立執行緒後自動啟動這些任務。執行緒池執行緒都是後臺執行緒。每個執行緒都使用預設的堆疊大小，以預設的優先順序執行，並處於多執行緒單元中。如果某個執行緒在託管程式碼中空閒（如正在等待某個事件）,則執行緒池將插入另一個輔助執

Android面試題總結（四）執行緒，多執行緒，執行緒池

1.開啟執行緒的三中方式？https://blog.csdn.net/longshengguoji/article/details/41126119（轉）https://blog.csdn.net/u012973218/article/details/51280044（轉）2

Python併發程式設計（十一）：程序池，執行緒池，協程

目錄注意二、執行緒池協程的本質注意 1、不能無限的開程序和執行緒，最常用的就是開程序池，開執行緒池。 2、其中回撥函式非常重要，回撥函式其實可以作為一種程式設計思想，函數語言程式設

java併發學習--執行緒池（一）

關於java中的執行緒池，我一開始覺得就是為了避免頻繁的建立和銷燬執行緒吧，先建立一定量的執行緒，然後再進行復用。但是要具體說一下如何做到的，自己又說不出一個一二三來了，這大概就是自己的學習習慣流於表面，不經常深入的結果吧。所以這裡決定系統的學習一下執行緒池的相關知識。自己稍微總結了一下，

java執行緒池（有返回值和無返回值）

無返回值： package ThreadPool2; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; public class test { public stat

day 34 GIL鎖，執行緒佇列，執行緒池及執行緒池回撥函式

一 . GIL鎖　　GIL鎖是python程式碼轉直譯器程式碼的一個鎖　　　　雖然我們加鎖的原因是因為要保護安全性從而降低了效率，但是加鎖也會出現安全性的問題！　　　　二 . 執行緒佇列　　import queue 　　三種佇列形式

python執行緒池（threadpool）模組使用筆記

https://www.cnblogs.com/xiaozi/p/6182990.html 一、安裝與簡介 pip install threadpool pool = ThreadPool(poolsize) requests = make

java 多執行緒，執行緒池

如果執行緒數量<=核心執行緒數量，那麼直接啟動一個核心執行緒來執行任務，不會放入佇列中。如果執行緒數量>核心執行緒數，但<=最大執行緒數，並且任務佇列是LinkedBlockingDeque的時候，超過核心執行緒數量的任務會放在任務佇列中排隊。如果執行緒數量>核心執行緒數，

java執行緒池（newCachedThreadPool）的使用

import java.util.concurrent.*; /** * java執行緒池的使用 * 這個【可快取執行緒池】，沒看出來有什麼用呢。。。 */ public class Exe

10.執行緒和執行緒池的區別，執行緒池有哪些，什麼情況下使用

一：執行緒和執行緒池的區別（1）new Thread 的弊端 a. 每次new Thread時，新建物件效能差。 b. 執行緒缺乏統一管理，可能無限制新建執行緒，相互之間競爭，可能佔用過多系統資源導致宕機或oom。 c. 缺乏更多功能

11.執行緒的狀態，執行緒池的構造方式，執行緒池的特性

一：執行緒的狀態（1）初始狀態實現Runnable介面和繼承Thread可以得到一個執行緒類，new一個例項出來，執行緒就進入了初始狀態。（2）就緒狀態 1）就緒狀態只是說你資格執行，排程程式沒有挑選到你，你就永遠是就緒狀態。

深入理解Java多執行緒--執行緒池（ThreadPool）

在java多執行緒開發中，我們需要使用執行緒的時候一般是建立一個Thread物件，然後呼叫start（）方法去執行執行緒操作。這樣做沒有什麼問題，但是如果我們有很多工需要多個執行緒來非同步執行的時候，在我們建立了很多執行緒的情況下，會造成很大的效能方面的問題。 1.大量的執行緒的建立和銷燬，

socket，執行緒池（TCP通訊）

相關推薦