閱讀646 返回首頁    go 阿裏雲 go 技術社區[雲棲]

java多線程總結一：線程的兩種創建方式及優劣比較

https://blog.csdn.net/touch_2011/article/details/6891026


1、通過實現Runnable接口線程創建

(1).定義一個類實現Runnable接口，重寫接口中的run()方法。在run()方法中加入具體的任務代碼或處理邏輯。

(2).創建Runnable接口實現類的對象。

(3).創建一個Thread類的對象，需要封裝前麵Runnable接口實現類的對象。（接口可以實現多繼承）

(4).調用Thread對象的start()方法，啟動線程

示例代碼：

[java] view plaincopy
  1. <span style="font-size:16px;">package demo.thread;  
  2.   
  3. public class TreadDemo1 implements Runnable {  
  4.     private int countDown = 10;  
  5.     @Override  
  6.     // 在run方法中定義任務  
  7.     public void run() {  
  8.         while (countDown-- > 0) {  
  9.             System.out.println("#" + Thread.currentThread().getName() + "("  
  10.                     + countDown + ")");  
  11.         }  
  12.     }  
  13.   
  14.     public static void main(String[] args) {  
  15.         // Runnable中run方法是一個空方法，並不會產生任何線程行為，必須顯式地將一個任務附著到線程上  
  16.         TreadDemo1 tt=new TreadDemo1();  
  17.         new Thread(tt).start();  
  18.         new Thread(tt).start();  
  19.         System.out.println("火箭發射前倒計時：");  
  20.     }  
  21. }  
  22. </span>  


運行結果：

火箭發射前倒計時：
#Thread-1(8)
#Thread-1(7)
#Thread-1(6)
#Thread-1(5)
#Thread-1(4)
#Thread-1(3)
#Thread-1(2)
#Thread-1(1)
#Thread-1(0)
#Thread-0(9)

2、通過繼承Thread類創建線程

(1).首先定義一個類去繼承Thread父類，重寫父類中的run()方法。在run()方法中加入具體的任務代碼或處理邏輯。
(2).直接創建一個ThreadDemo2類的對象，也可以利用多態性，變量聲明為父類的類型。

(3).調用start方法，線程t啟動，隱含的調用run()方法。

示例代碼：

[java] view plaincopy
  1. <span style="font-size:16px;">package demo.thread;  
  2.   
  3. public class ThreadDemo2 extends Thread {  
  4.     private int countDown = 10;  
  5.   
  6.     @Override  
  7.     // 在run方法中定義任務  
  8.     public void run() {  
  9.         while (countDown-- > 0) {  
  10.             System.out.println("#" + this.getName() + "(" + countDown + ")");  
  11.         }  
  12.     }  
  13.   
  14.     public static void main(String[] args) {  
  15.         new ThreadDemo2().start();  
  16.         new ThreadDemo2().start();  
  17.         // 由於start方法迅速返回，所以main線程可以執行其他的操作,此時有兩個獨立的線程在並發運行  
  18.         System.out.println("火箭發射前倒計時：");  
  19.     }  
  20. }  
  21. </span>  


運行結果：

#Thread-0(9)
#Thread-0(8)
#Thread-0(7)
#Thread-0(6)
#Thread-0(5)
#Thread-0(4)
#Thread-0(3)
#Thread-0(2)
#Thread-0(1)
#Thread-0(0)
火箭發射前倒計時：
#Thread-1(9)
#Thread-1(8)
#Thread-1(7)
#Thread-1(6)
#Thread-1(5)
#Thread-1(4)
#Thread-1(3)
#Thread-1(2)
#Thread-1(1)
#Thread-1(0)
3、兩種方式的比較

首先分析兩種方式的輸出結果，同樣是創建了兩個線程，為什麼結果不一樣呢？

使用實現Runnable接口方式創建線程可以共享同一個目標對象（TreadDemo1 tt=new TreadDemo1();），實現了多個相同線程處理同一份資源。

然後再看一段來自JDK的解釋：

Runnable 接口應該由那些打算通過某一線程執行其實例的類來實現。類必須定義一個稱為run 的無參數方法。

設計該接口的目的是為希望在活動時執行代碼的對象提供一個公共協議。例如，Thread 類實現了Runnable。激活的意思是說某個線程已啟動並且尚未停止。

此外，Runnable 為非 Thread 子類的類提供了一種激活方式。通過實例化某個Thread 實例並將自身作為運行目標，就可以運行實現 Runnable 的類而無需創建 Thread 的子類。大多數情況下，如果隻想重寫run() 方法，而不重寫其他 Thread 方法，那麼應使用 Runnable 接口。這很重要，因為除非程序員打算修改或增強類的基本行為，否則不應為該類創建子類。

 

采用繼承Thread類方式：
（1）優點：編寫簡單，如果需要訪問當前線程，無需使用Thread.currentThread()方法，直接使用this，即可獲得當前線程。
（2）缺點：因為線程類已經繼承了Thread類，所以不能再繼承其他的父類。
采用實現Runnable接口方式：
（1）優點：線程類隻是實現了Runable接口，還可以繼承其他的類。在這種方式下，可以多個線程共享同一個目標對象，所以非常適合多個相同線程來處理同一份資源的情況，從而可以將CPU代碼和數據分開，形成清晰的模型，較好地體現了麵向對象的思想。
（2）缺點：編程稍微複雜，如果需要訪問當前線程，必須使用Thread.currentThread()方法。



https://blog.csdn.net/touch_2011/article/details/6891708


所謂的後台線程，是指在程序運行的時候在後台提供一種通用服務的線程，並且這種線程並不屬於程序中不可或缺的部分。因此當所有的非後台線程結束時，程序也就終止了，同時會殺死所有後台線程。反過來說，隻要有任何非後台線程(用戶線程)還在運行，程序就不會終止。後台線程在不執行finally子句的情況下就會終止其run方法。後台線程創建的子線程也是後台線程。

下麵是一個後台線程的示例：

[java] view plaincopy
  1. <span style="font-size:16px;">package demo.thread;  
  2.   
  3. import java.util.concurrent.TimeUnit;  
  4.   
  5. public class DaemonDemo implements Runnable {  
  6.     @Override  
  7.     public void run() {  
  8.         try {  
  9.             while (true) {  
  10.                 Thread.sleep(1000);  
  11.                 System.out.println("#" + Thread.currentThread().getName());  
  12.             }  
  13.         } catch (InterruptedException e) {  
  14.             e.printStackTrace();  
  15.         } finally {// 後台線程不執行finally子句  
  16.             System.out.println("finally ");  
  17.         }  
  18.     }  
  19.   
  20.     public static void main(String[] args) {  
  21.         for (int i = 0; i < 10; i++) {  
  22.             Thread daemon = new Thread(new DaemonDemo());  
  23.             // 必須在start之前設置為後台線程  
  24.             daemon.setDaemon(true);  
  25.             daemon.start();  
  26.         }  
  27.         System.out.println("All daemons started");  
  28.         try {  
  29.             TimeUnit.MILLISECONDS.sleep(1000);  
  30.         } catch (InterruptedException e) {  
  31.             // TODO Auto-generated catch block  
  32.             e.printStackTrace();  
  33.         }  
  34.     }  
  35. }  
  36. </span>  


 

運行結果：

All daemons started
#Thread-2
#Thread-3
#Thread-1
#Thread-0
#Thread-9
#Thread-6
#Thread-8
#Thread-5
#Thread-7
#Thread-4

分析：從結果可以看出，十個子線程並沒有無線循環的打印，而是在主線程(main())退出後，JVM強製關閉所有後台線程。而不會有任何希望出現的確認形式，如finally子句不執行。



https://blog.csdn.net/touch_2011/article/details/6914210

這是一個來自《java編程思想上的示例》

[java] view plaincopy
  1. package demo.thread;  
  2.   
  3. /** 
  4.  *sleep()是靜態方法，是屬於類的，作用是讓當前線程阻塞  
  5.  *join()是使線程同步，如在某個線程裏調用t.join()表示t線程執行完再執行當前線程 
  6.  *interrupt()給線程設定一個標誌表示該線程已被中斷，但在異常捕獲時將清理這個標誌 
  7.  *所以在catch子句中，該標誌為false  
  8.  */  
  9. public class SleepJoinDemo {  
  10.     public static void main(String[] args) {  
  11.         Sleeper sleep1 = new Sleeper("sleep1", 1500);  
  12.         Sleeper sleep2 = new Sleeper("sleep2", 1500);  
  13.         Joiner join1 = new Joiner("join1", sleep1);  
  14.         Joiner join2 = new Joiner("join2", sleep1);  
  15.         sleep2.interrupt();  
  16.     }  
  17. }  
  18.   
  19. class Sleeper extends Thread {  
  20.     // 可以傳參設定睡眠時間  
  21.     private int sleepTime;  
  22.   
  23.     public Sleeper(String name, int sleepTime) {  
  24.         super(name);  
  25.         this.sleepTime = sleepTime;  
  26.         start();// 在構造方法中啟動  
  27.     }  
  28.   
  29.     @Override  
  30.     public void run() {  
  31.         try {  
  32.             sleep(sleepTime);  
  33.         } catch (InterruptedException e) {  
  34.             System.out.println(getName() + " was interrupted.\n"  
  35.                     + "isInterrupted():" + isInterrupted());  
  36.             return;  
  37.         }  
  38.         System.out.println(getName() + " has awakened");  
  39.     }  
  40. }  
  41.   
  42. class Joiner extends Thread {  
  43.     private Sleeper sleeper;  
  44.   
  45.     public Joiner(String name, Sleeper sleeper) {  
  46.         super(name);  
  47.         this.sleeper = sleeper;  
  48.         start();  
  49.     }  
  50.   
  51.     public void run() {  
  52.         try {  
  53.             sleeper.join();//合並，異步變同步  
  54.         } catch (InterruptedException e) {  
  55.             System.out.println("interrupted");  
  56.         }  
  57.         System.out.println(getName() + " join completed");  
  58.     }  
  59. }  

https://blog.csdn.net/touch_2011/article/details/6914294


1、synchronized保證同步

先看一個生成偶數的類

[java] view plaincopy
  1. <span style="font-size:16px;">package demo.thread;  
  2.   
  3. /** 
  4.  *這是一個int生成器的抽象類 
  5.  *  
  6.  */  
  7. public abstract class IntGenerator {  
  8.       
  9.     private volatile boolean canceled = false;  
  10.   
  11.     public abstract int next();  
  12.   
  13.     public void cancel() {  
  14.         canceled = true;  
  15.     }  
  16.   
  17.     public boolean isCanceled() {  
  18.         return canceled;  
  19.     }  
  20. }  
  21. </span>  


 

[java] view plaincopy
  1. <span style="font-size:16px;">/* 
  2.  * 產生偶數 
  3.  */  
  4. class EvenGenerator extends IntGenerator {  
  5.     private int currentEvenValue = 0;  
  6.     String s = "";  
  7.   
  8.     @Override  
  9.     public int next() {  
  10.         <span style="color:#ff0000;">synchronized </span>(s) {  
  11.             ++currentEvenValue;  
  12.             ++currentEvenValue;  
  13.             return currentEvenValue;  
  14.         }  
  15.     }  
  16.   
  17. //  //這樣也可以  
  18. //  public <span >synchronized </span>int next() {  
  19. //          ++currentEvenValue;  
  20. //          ++currentEvenValue;  
  21. //          return currentEvenValue;  
  22. //  }  
  23. }</span>  


注意到在產生偶數是要加同步鎖，否則可能線程1剛好執行了一句++currentEvenValue;操作，就被線程2搶去了cpu，此時線程2執行return currentEvenValue;這時返回的就是一個奇數。加synchronized 就是兩個線程同時隻能一個線程執行synchronized 塊的代碼。

測試代碼：

[java] view plaincopy
  1. <span style="font-size:16px;">package demo.thread;  
  2.   
  3. import java.util.concurrent.ExecutorService;  
  4. import java.util.concurrent.Executors;  
  5.   
  6. /* 
  7.  * 消費數字 
  8.  */  
  9. public class EvenChecker implements Runnable {  
  10.       
  11.     private IntGenerator generator;  
  12.     private final int id;  
  13.   
  14.     public EvenChecker(IntGenerator g, int ident) {  
  15.         generator = g;  
  16.         id = ident;  
  17.     }  
  18.   
  19.     public void run() {  
  20.         while (!generator.isCanceled()) {  
  21.             int val = generator.next();  
  22.             if (val % 2 != 0) {//如果不是偶數  
  23.                 System.out.println(val + " not enen!");  
  24.                 generator.cancel();  
  25.             }  
  26.         }  
  27.     }  
  28.   
  29.     public static void test(IntGenerator gp, int count) {  
  30.         ExecutorService exec = Executors.newCachedThreadPool();  
  31.         for (int i = 0; i < count; i++)  
  32.             exec.execute(new EvenChecker(gp, i));  
  33.         exec.shutdown();  
  34.     }  
  35.   
  36.     public static void test(IntGenerator gp) {  
  37.         test(gp, 10);  
  38.     }  
  39.   
  40.     public static void main(String[] args) {  
  41.         test(new EvenGenerator());  
  42.     }  
  43. }</span>  


分析：如果產生偶數的類未加synchronized，那麼測試程序將會出現奇數導致退出程序。

 

2、volatile表示原子性，可見性。

      對於多個線程之間共享的變量，每個線程都有自己的一份拷貝，當線程1改變變量值時，其他線程並不馬上知道該變量值改變了，volatile就保證了變量值對各個線程可見，一個線程改變該值，馬上其他線程中該值也改變。原子性表明操作不可中斷，如基本變量賦值。

     代碼示例：

[java] view plaincopy
  1. <span style="font-size:16px;">package demo.thread;  
  2.   
  3. public class VolatileDemo implements Runnable {  
  4.       
  5.     private volatile int i = 0;//volatile設置可見性  
  6.   
  7.     public synchronized  int getValue() {  
  8.         return i;  
  9.     }  
  10.   
  11.     private synchronized void enenIncrement() {  
  12.         i++;  
  13.         i++;  
  14.     }  
  15.   
  16.     @Override  
  17.     public void run() {  
  18.         while (true)  
  19.             enenIncrement();  
  20.     }  
  21.   
  22.     public static void main(String[] args) {  
  23.         VolatileDemo at = new VolatileDemo();  
  24.         new Thread(at).start();  
  25.         while (true) {  
  26.             int val = at.getValue();  
  27.             if (val % 2 != 0) {//出現奇數，退出程序  
  28.                 System.out.println(val+" is not enen!");  
  29.                 System.exit(0);  
  30.             }  
  31.         }  
  32.   
  33.     }  
  34. }  
  35. </span>  


注意i++操作並不是原子行操作，getValue() 方法也要加synchronized 。



https://blog.csdn.net/touch_2011/article/details/6914468

1、線程池簡介：
    多線程技術主要解決處理器單元內多個線程執行的問題，它可以顯著減少處理器單元的閑置時間，增加處理器單元的吞吐能力。    
    假設一個服務器完成一項任務所需時間為：T1 創建線程時間，T2 在線程中執行任務的時間，T3 銷毀線程時間。

    如果：T1 + T3 遠大於 T2，則可以采用線程池，以提高服務器性能。
                一個線程池包括以下四個基本組成部分：
                1、線程池管理器（ThreadPool）：用於創建並管理線程池，包括 創建線程池，銷毀線程池，添加新任務；
                2、工作線程（PoolWorker）：線程池中線程，在沒有任務時處於等待狀態，可以循環的執行任務；
                3、任務接口（Task）：每個任務必須實現的接口，以供工作線程調度任務的執行，它主要規定了任務的入口，任務執行完後的收尾工作，任務的執行狀態等；
                4、任務隊列（taskQueue）：用於存放沒有處理的任務。提供一種緩衝機製。
                
    線程池技術正是關注如何縮短或調整T1,T3時間的技術，從而提高服務器程序性能的。它把T1，T3分別安排在服務器程序的啟動和結束的時間段或者一些空閑的時間段，這樣在服務器程序處理客戶請求時，不會有T1，T3的開銷了。
    線程池不僅調整T1,T3產生的時間段，而且它還顯著減少了創建線程的數目，看一個例子：
    假設一個服務器一天要處理50000個請求，並且每個請求需要一個單獨的線程完成。在線程池中，線程數一般是固定的，所以產生線程總數不會超過線程池中線程的數目，而如果服務器不利用線程池來處理這些請求則線程總數為50000。一般線程池大小是遠小於50000。所以利用線程池的服務器程序不會為了創建50000而在處理請求時浪費時間，從而提高效率。

    代碼實現中並沒有實現任務接口，而是把Runnable對象加入到線程池管理器（ThreadPool），然後剩下的事情就由線程池管理器（ThreadPool）來完成了

 

[java] view plaincopy
  1. package mine.util.thread;  
  2.   
  3. import java.util.LinkedList;  
  4. import java.util.List;  
  5.   
  6. /** 
  7.  * 線程池類，線程管理器：創建線程，執行任務，銷毀線程，獲取線程基本信息 
  8.  */  
  9. public final class ThreadPool {  
  10.     // 線程池中默認線程的個數為5  
  11.     private static int worker_num = 5;  
  12.     // 工作線程  
  13.     private WorkThread[] workThrads;  
  14.     // 未處理的任務  
  15.     private static volatile int finished_task = 0;  
  16.     // 任務隊列，作為一個緩衝,List線程不安全  
  17.     private List<Runnable> taskQueue = new LinkedList<Runnable>();  
  18.     private static ThreadPool threadPool;  
  19.   
  20.     // 創建具有默認線程個數的線程池  
  21.     private ThreadPool() {  
  22.         this(5);  
  23.     }  
  24.   
  25.     // 創建線程池,worker_num為線程池中工作線程的個數  
  26.     private ThreadPool(int worker_num) {  
  27.         ThreadPool.worker_num = worker_num;  
  28.         workThrads = new WorkThread[worker_num];  
  29.         for (int i = 0; i < worker_num; i++) {  
  30.             workThrads[i] = new WorkThread();  
  31.             workThrads[i].start();// 開啟線程池中的線程  
  32.         }  
  33.     }  
  34.   
  35.     // 單態模式，獲得一個默認線程個數的線程池  
  36.     public static ThreadPool getThreadPool() {  
  37.         return getThreadPool(ThreadPool.worker_num);  
  38.     }  
  39.   
  40.     // 單態模式，獲得一個指定線程個數的線程池,worker_num(>0)為線程池中工作線程的個數  
  41.     // worker_num<=0創建默認的工作線程個數  
  42.     public static ThreadPool getThreadPool(int worker_num1) {  
  43.         if (worker_num1 <= 0)  
  44.             worker_num1 = ThreadPool.worker_num;  
  45.         if (threadPool == null)  
  46.             threadPool = new ThreadPool(worker_num1);  
  47.         return threadPool;  
  48.     }  
  49.   
  50.     // 執行任務,其實隻是把任務加入任務隊列，什麼時候執行有線程池管理器覺定  
  51.     public void execute(Runnable task) {  
  52.         synchronized (taskQueue) {  
  53.             taskQueue.add(task);  
  54.             taskQueue.notify();  
  55.         }  
  56.     }  
  57.   
  58.     // 批量執行任務,其實隻是把任務加入任務隊列，什麼時候執行有線程池管理器覺定  
  59.     public void execute(Runnable[] task) {  
  60.         synchronized (taskQueue) {  
  61.             for (Runnable t : task)  
  62.                 taskQueue.add(t);  
  63.             taskQueue.notify();  
  64.         }  
  65.     }  
  66.   
  67.     // 批量執行任務,其實隻是把任務加入任務隊列，什麼時候執行有線程池管理器覺定  
  68.     public void execute(List<Runnable> task) {  
  69.         synchronized (taskQueue) {  
  70.             for (Runnable t : task)  
  71.                 taskQueue.add(t);  
  72.             taskQueue.notify();  
  73.         }  
  74.     }  
  75.   
  76.     // 銷毀線程池,該方法保證在所有任務都完成的情況下才銷毀所有線程，否則等待任務完成才銷毀  
  77.     public void destroy() {  
  78.         while (!taskQueue.isEmpty()) {// 如果還有任務沒執行完成，就先睡會吧  
  79.             try {  
  80.                 Thread.sleep(10);  
  81.             } catch (InterruptedException e) {  
  82.                 e.printStackTrace();  
  83.             }  
  84.         }  
  85.         // 工作線程停止工作，且置為null  
  86.         for (int i = 0; i < worker_num; i++) {  
  87.             workThrads[i].stopWorker();  
  88.             workThrads[i] = null;  
  89.         }  
  90.         threadPool=null;  
  91.         taskQueue.clear();// 清空任務隊列  
  92.     }  
  93.   
  94.     // 返回工作線程的個數  
  95.     public int getWorkThreadNumber() {  
  96.         return worker_num;  
  97.     }  
  98.   
  99.     // 返回已完成任務的個數,這裏的已完成是隻出了任務隊列的任務個數，可能該任務並沒有實際執行完成  
  100.     public int getFinishedTasknumber() {  
  101.         return finished_task;  
  102.     }  
  103.   
  104.     // 返回任務隊列的長度，即還沒處理的任務個數  
  105.     public int getWaitTasknumber() {  
  106.         return taskQueue.size();  
  107.     }  
  108.   
  109.     // 覆蓋toString方法，返回線程池信息：工作線程個數和已完成任務個數  
  110.     @Override  
  111.     public String toString() {  
  112.         return "WorkThread number:" + worker_num + "  finished task number:"  
  113.                 + finished_task + "  wait task number:" + getWaitTasknumber();  
  114.     }  
  115.   
  116.     /** 
  117.      * 內部類，工作線程 
  118.      */  
  119.     private class WorkThread extends Thread {  
  120.         // 該工作線程是否有效，用於結束該工作線程  
  121.         private boolean isRunning = true;  
  122.   
  123.         /* 
  124.          * 關鍵所在啊，如果任務隊列不空，則取出任務執行，若任務隊列空，則等待 
  125.          */  
  126.         @Override  
  127.         public void run() {  
  128.             Runnable r = null;  
  129.             while (isRunning) {// 注意，若線程無效則自然結束run方法，該線程就沒用了  
  130.                 synchronized (taskQueue) {  
  131.                     while (isRunning && taskQueue.isEmpty()) {// 隊列為空  
  132.                         try {  
  133.                             taskQueue.wait(20);  
  134.                         } catch (InterruptedException e) {  
  135.                             e.printStackTrace();  
  136.                         }  
  137.                     }  
  138.                     if (!taskQueue.isEmpty())  
  139.                         r = taskQueue.remove(0);// 取出任務  
  140.                 }  
  141.                 if (r != null) {  
  142.                     r.run();// 執行任務  
  143.                 }  
  144.                 finished_task++;  
  145.                 r = null;  
  146.             }  
  147.         }  
  148.   
  149.         // 停止工作，讓該線程自然執行完run方法，自然結束  
  150.         public void stopWorker() {  
  151.             isRunning = false;  
  152.         }  
  153.     }  
  154. }  

 

測試代碼：

[java] view plaincopy
  1. package mine.util.thread;  
  2.   
  3. //測試線程池  
  4. public class TestThreadPool {  
  5.     public static void main(String[] args) {  
  6.         // 創建3個線程的線程池  
  7.         ThreadPool t = ThreadPool.getThreadPool(3);  
  8.         t.execute(new Runnable[] { new Task(), new Task(), new Task() });  
  9.         t.execute(new Runnable[] { new Task(), new Task(), new Task() });  
  10.         System.out.println(t);  
  11.         t.destroy();// 所有線程都執行完成才destory  
  12.         System.out.println(t);  
  13.     }  
  14.   
  15.     // 任務類  
  16.     static class Task implements Runnable {  
  17.         private static volatile int i = 1;  
  18.   
  19.         @Override  
  20.         public void run() {// 執行任務  
  21.             System.out.println("任務 " + (i++) + " 完成");  
  22.         }  
  23.     }  
  24. }  


 

運行結果：

WorkThread number:3  finished task number:0  wait task number:6
任務 1 完成
任務 2 完成
任務 3 完成
任務 4 完成
任務 5 完成
任務 6 完成
WorkThread number:3  finished task number:6  wait task number:0

分析：由於並沒有任務接口，傳入的可以是自定義的任何任務，所以線程池並不能準確的判斷該任務是否真正的已經完成（真正完成該任務是這個任務的run方法執行完畢），隻能知道該任務已經出了任務隊列，正在執行或者已經完成。

2、java類庫中提供的線程池簡介：

     java提供的線程池更加強大，相信理解線程池的工作原理，看類庫中的線程池就不會感到陌生了。

其他具體內容查看jdk幫助或看jdk源代碼吧。。。

參考文章：https://hi.baidu.com/obullxl/blog/item/ee50ad1ba8e8ff1f8718bf66.html


最後更新：2017-04-03 19:13:18

  上一篇：go 微軟密謀恢複Windows開始按鈕：引開發者質疑
  下一篇：go Socket用法，簡單模擬一對一聊天