2. 程式人生 > >Java Thread系列（四）線程通信

Java Thread系列（四）線程通信

阿新 • • 發佈：2018-05-07
ice 集合 就是 int name 發出 max 執行 生產

Java Thread系列（四）線程通信

一、傳統通信

public static void main(String[] args) {
    //volatile實現兩個線程間數據可見性
    private volatile static List list = new ArrayList();

    Thread t1 = new Thread(new Runnable() { // (1)
        public void run() {
            try {
                for(int i = 0; i <10; i++){
                    list.add
 
(i);
                    System.out.println(Thread.currentThread().getName() + "線程添加第" + (i + 1) + "個元素..");
                    Thread.sleep(500);
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }, "t1");

    Thread t2 = new
 
 Thread(new Runnable() { // (2)
        public void run() {
            while(true){
                if(list.size() == 5){
                    //do something
                    throw new RuntimeException(Thread.currentThread().getName() + 
                        "線程接到通知 size = " + list.size() + " 線程停止.."
 
);
                }
            }
        }
    }, "t2");

    t1.start();
    t2.start();
}

  1. t1 線程不斷將生產的數據放入 list 集合中

  2. t2 線程開啟 while 循環監聽 t1 線程，雖然可以實現 list.size()==5 時實時通知 t2 線程，但太浪費性能，考慮用 await/notify 提高性能，程序執行結果如下：

t1線程添加第1個元素..
t1線程添加第2個元素..
t1線程添加第3個元素..
t1線程添加第4個元素..
t1線程添加第5個元素..
Exception in thread "t2" java.lang.RuntimeException: t2線程接到通知 size = 5 線程停止..
    at com.github.binarylei.thread._2_1conn.ListAdvice1$2.run(ListAdvice1.java:35)
    at java.lang.Thread.run(Thread.java:745)
t1線程添加第6個元素..
t1線程添加第7個元素..
t1線程添加第8個元素..
t1線程添加第9個元素..
t1線程添加第10個元素..

二、wait/notify 實現通信

/**
 * 使用wait/notify方法實現線程單挑通信(註意這兩個方法是Object類的方法)
 *   1. wait和notity必須配合synchronized關鍵字使用
 *   2. wait方法(關閉線程)釋放鎖，notify(喚醒線程)方法不釋放鎖
 * 缺點：通知不實時，使用CountDownLatch實現實時通知
 */
public static void main(String[] args) {
    private volatile static List list = new ArrayList();
    final Object lock = new Object();

    Thread t1 = new Thread(new Runnable() { // (1)
        public void run() {
            try {
                synchronized (lock) {
                    System.out.println("t1啟動..");
                    for(int i = 0; i <10; i++){
                        list.add(i);
                        System.out.println(Thread.currentThread().getName() + "線程添加第" + (i + 1) + "個元素..");
                        Thread.sleep(500);
                        if(list.size() == 5){
                            System.out.println("已經發出通知..");
                            lock.notify();
                        }
                    }
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }, "t1");

    Thread t2 = new Thread(new Runnable() { // (2)
        public void run() {
            synchronized (lock) {
                System.out.println("t2啟動..");
                if(list.size() != 5){
                    try {
                        lock.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                //do something
                throw new RuntimeException(Thread.currentThread().getName() + 
                    "線程接到通知 size = " + list.size() + " 線程停止..");
            }
        }
    }, "t2");
}

  1. t1 線程當 list.size()==5 時 lock.notify() 喚醒 t2 線程，註意 wait/notify 必須配合 synchronized 使用。

  2. t2 線程調用 lock.wait() 後處於一直阻塞狀態，直到 t1 線程調用 lock.notify() 喚醒該線程，倘若沒有線程喚醒 t2 線程，那麽 t2 線程就一直處於阻塞狀態。本例中若 t1 線程先啟動，那麽 t2 線程調用 lock.wait() 就永遠阻塞無法執行。程序執行結果如下：。

t2啟動..
t1啟動..
t1線程添加第1個元素..
t1線程添加第2個元素..
t1線程添加第3個元素..
t1線程添加第4個元素..
t1線程添加第5個元素..
已經發出通知..
t1線程添加第6個元素..
t1線程添加第7個元素..
t1線程添加第8個元素..
t1線程添加第9個元素..
t1線程添加第10個元素..
Exception in thread "t2" java.lang.RuntimeException: t2線程接到通知 size = 10 線程停止..
    at com.github.binarylei.thread._2_1conn.ListAdd2$2.run(ListAdd2.java:51)
    at java.lang.Thread.run(Thread.java:745)
  1. 由於 t1 線程 lock.notify() 後不會釋放鎖，t2 線程雖然被喚醒但不能獲取鎖，所以通知就不那麽實時，只有等 t1 線程執行完成釋放鎖後 t2 線程才能獲得鎖執行相應操作，解決方案：使用 CountDownLatch

三、CountDownLatch 實現實時通信


public static void main(String[] args) {
    private volatile static List list = new ArrayList();
    final CountDownLatch countDownLatch = new CountDownLatch(1); // (1)

    Thread t1 = new Thread(new Runnable() {
        public void run() {
            try {
                System.out.println("t1啟動..");
                for(int i = 0; i <10; i++){
                    list.add(i);
                    System.out.println(Thread.currentThread().getName() + "線程添加第" + (i + 1) + "個元素..");
                    Thread.sleep(500);
                    if(list.size() == 5){
                        System.out.println("已經發出通知..");
                        countDownLatch.countDown(); // (2)
                    }
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

        }
    }, "t1");

    Thread t2 = new Thread(new Runnable() {
        public void run() {
            System.out.println("t2啟動..");
            if(list.size() != 5){
                try {
                    countDownLatch.await(); // (3)
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            //do something
            throw new RuntimeException(Thread.currentThread().getName() + 
                "線程接到通知 size = " + list.size() + " 線程停止..");
        }
    }, "t2");

    t1.start();
    t2.start();
}

  1. CountDownLatch 同步工具類，允許一個或多個線程一直等待，直到其他線程的操作執行完後再執行，參數 1 表示需要等待的線程數量，具體來說就是參數為幾就必須調用幾次 countDownLatch.countDown()

  2. countDownLatch.countDown() 喚醒線程

  3. countDownLatch.await() 阻塞線程，程序執行結果如下：

t1啟動..
t1線程添加第1個元素..
t2啟動..
t1線程添加第2個元素..
t1線程添加第3個元素..
t1線程添加第4個元素..
t1線程添加第5個元素..
已經發出通知..
Exception in thread "t2" java.lang.RuntimeException: t2線程接到通知 size = 5 線程停止..
t1線程添加第6個元素..
    at com.github.binarylei.thread._2_1conn.ListAdd3$2.run(ListAdd3.java:47)
    at java.lang.Thread.run(Thread.java:745)
t1線程添加第7個元素..
t1線程添加第8個元素..
t1線程添加第9個元素..
t1線程添加第10個元素..

四、ThreadLocal

ThreadLocal 是線程局部變量，是一種多線程間並發訪問變量的無鎖解決方案。

ThreadLocal 和 synchronized 比較？

  1. 與 synchronized 等加鎖的方式不同，ThreadLocal 完全不提供鎖，而使用以空間換時間的手段，為每個線程提供變量的獨立副本，以保障線程安全。

  2. 從性能上說，ThreadLocal 不具有絕對的優勢，在並發不是很高的時候，加鎖的性能會更好，但作為一套無鎖的解決方案，在高並發量或者競爭激烈的場景，使用 ThreadLocal 可以在一定程度上減少鎖競爭。

public static void main(String[] args) throws InterruptedException {
    final ThreadLocal<String> th = new ThreadLocal<String>();

    Thread t1 = new Thread(new Runnable() {
        public void run() {
            th.set("張三");
            System.out.println(th.get()); // => "張三"
        }
    }, "t1");
    
    Thread t2 = new Thread(new Runnable() {
        public void run() {
            try {
                Thread.sleep(1000);
                th.set("李四");
                System.out.println(th.get()); // => "李四"
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }, "t2");
    
    t1.start(); //t1:張三
    t2.start(); //t2:李四
}

五、自定義同步類窗口-Queue

Java 提供了一些同步類容器，它們是 線程安全 的，如 Vector、HashTable 等。這些同步類容器是由 Collections.synchronizedMap 等工廠方法去創建實現的，底層使用 synchronized 關鍵字，每次只有一個線程訪問容器。下面實現一個自己的同步類窗口。

import java.util.LinkedList;

public class MyQueue {   
    private LinkedList list = new LinkedList();
    private int max = 5;
    private int min = 1;
    private Object lock = new Object();

    public void put(Object obj) {  // (1)
        synchronized (lock) {
            while (list.size() == max) {
                try {
                    lock.wait();
                } catch (InterruptedException e) {
                    ;
                }
            }
            list.add(obj);
            lock.notify();
            System.out.println("put元素：" + obj);
        }
    }

    public Object take() {  // (2)
        Object obj;
        synchronized (lock) {
            while (list.size() == min) {
                try {
                    lock.wait();
                } catch (InterruptedException e) {
                    ;
                }
            }
            obj = list.removeFirst();
            lock.notify();
            System.out.println("take元素：" + obj);
        }
        return obj;
    }
}

測試

public static void main(String[] args) {
    final MyQueue myQueue = new MyQueue();
    myQueue.put("a");
    myQueue.put("b");
    myQueue.put("c");
    myQueue.put("d");
    myQueue.put("e");

    new Thread(new Runnable() {
        @Override
        public void run() {
            myQueue.put("f");
            myQueue.put("g");
            myQueue.put("h");
            myQueue.put("i");
        }
    }).start();

    new Thread(new Runnable() {
        @Override
        public void run() {
            myQueue.take();
            myQueue.take();
            myQueue.take();
        }
    }).start();
}

每天用心記錄一點點。內容也許不重要，但習慣很重要！

Java Thread系列（四）線程通信

相關推薦

Java Thread系列（四）線程通信

ice 集合 就是 int name 發出 max 執行 生產 Java Thread系列（四）線程通信 一、傳統通信 public static void main(String[] args) { //volatile實現兩個線程間數據可見性 priva

Java Thread系列（二）線程狀態

做的 tor throws 前臺 bject 線程休眠 enume 死鎖 做出 Java Thread系列（二）線程狀態 一、線程的五種狀態 新建狀態（New）：新創建了一個線程對象，尚未啟動。 就緒狀態（Runnable）：也叫可運行狀態。線程對象創建後，其他線程調用

Java Thread系列（一）線程創建

nds list www imp tor 所有 clas HR dex Java Thread系列（一）線程創建 Java 中創建線程主要有三種方式：繼承 Thread、實現 Runnable 接口、使用 ExecutorService、Callable、Future 實現

Java Thread系列（三）線程安全

AI 資源 習慣 get string tar rup end 就是 Java Thread系列（三）線程安全 一、什麽是線程安全 線程安全概念：當多個線程訪問某一個類(對象或方法)時，這個類始終都能表現出正確的行為，那麽這個類(對象或方法)就是線程安全的。 線程安全來

java中的線程問題是（四）——線程同步問題

代碼 線程同步 tac int java 檢查 cnblogs 速度 機制 多線程的並發，給我們編程帶來很多好處，完成更多更有效率的程序。但是也給我們帶來線程安全問題。 解決問題的關鍵就是要保證容易出問題的代碼的原子性，所謂原子性就是指：當a線程在執

java基礎回顧（五）線程詳解以及synchronized關鍵字

dom com stack 相互 ++ 關於 而是 。。 str 本文將從線程的使用方式、源碼、synchronized關鍵字的使用方式和陷阱以及一些例子展開java線程和synchronized關鍵字的內容。 一、線程的概念 線程就是程序中單獨順序的流控制。線程本 身不能

Java並發（一）——線程安全的容器（上）

med ole 復雜 出隊 表示 就是 nsh 附加 構造方法 Java中線程安全的容器主要包括兩類： Vector、Hashtable，以及封裝器類Collections.synchronizedList和Collections.synchronizedMap； Jav

Java Thread系列（十）Future 模式

業務 throw 而且 代碼 ack void rri 是不是 決定 Java Thread系列（十）Future 模式 Future 模式適合在處理很耗時的業務邏輯時進行使用，可以有效的減少系統的響應時間，提高系統的吞吐量。 一、Future 模式核心思想 如下的請求

Java Thread系列（五）synchronized

執行 java 釋放 lock java t 操作 bject 線程 出現 Java Thread系列（五）synchronized synchronized鎖重入 關鍵字 synchronized 擁有鎖重入的功能，也就是在使用 synchronized 時，當線程等到

Java Thread系列（九）Master-Worker模式

線程 支持 需要 列表 deque 開啟 exc oid src Java Thread系列（九）Master-Worker模式 Master-Worker模式是常用的並行設計模式. 一、Master-Worker 模式核心思想 Master-Worker 系統由兩個角

Java面試題（五）線程及集合補充

每一個 場景 nds 試題 個數 安全 應用程序 -- 服務器 1,一個進程就是一個應用程序。一個線程就是一個進程中運行的最小單元。 一個進程可以包括多線程。 餐館(進程)。 主線程。 服務員(線程) 服務員(線程) 服務員(線程) 服務員(線程) 加塞，讓步，守護，

java爬蟲系列（四）——動態網頁爬蟲升級版

我之前推薦過大家使用seimiagent+seimicrawler，但是經過我多次試驗，在爬取任務過多，比如執行緒數超過幾十的時候，seimiagent會經常崩潰，當然這也和啟動seimiagent的伺服器有關。 鑑於seimiagent的效能

Java並發（五）線程池使用番外-分析RejectedExecutionException異常

讓我 seconds ride 產生 程序 i++ 接下來 異常 override 目錄 　　一、入門示例 　　二、異常場景1 　　三、異常場景2 　　四、解決方法 之前在使用線程池的時候，出現了 java.util.concurrent.RejectedE

Java並發（六）線程池監控

可用性 completed 越來越大 keep incr 構造 日誌 開發 task 目錄 　　一、線程池監控參數 　　二、線程池監控類 　　三、註意事項 在上一篇博文中，我們介紹了線程池的基本原理和使用方法。了解了基本概念之後，我們可以使用 Executor

C# 多線程系列（四）

委托 mat 一個 方法 () 允許 pub tel bsp Parallel類 Parallel類定義了for、foreach和invoke的靜態方法。Parallel類使用多個任務，因此使用多個線程來完成這個作業。 Parallel.For Parallel.Fo

Java 多線程詳解（三）------線程的同步

alt 來看 監聽 介紹 創建進程 java 多線程 system ima 關鍵字 Java 多線程詳解（一）------概念的引入：http://www.cnblogs.com/ysocean/p/6882988.html Java 多線程詳解（二）------如何創建進

Java多線程（二） —— 線程安全、線程同步、線程間通信（含面試題集）

err 線程等待 共同點 -c java多線 能夠 空間 而不是 不一致 一、線程安全 多個線程在執行同一段代碼的時候，每次的執行結果和單線程執行的結果都是一樣的，不存在執行結果的二義性，就可以稱作是線程安全的。 講到線程安全問題，其實是指多線程環境下對共享資源的訪問可能會

java多線程（2） 線程同步

setname 我們 可能 pac 對象 try 資源 spl main 我們對線程訪問同一份資源的多個線程之間，來進行協調的這個東西，就是線程同步。 例子1：模擬了多個線程操作同一份資源，可能帶來的問題： package com.cy.thread; publ

Java多線程（十）——線程優先級和守護線程

運行 範圍 .get ++ 都是 his strong start get 一、線程優先級的介紹 java 中的線程優先級的範圍是1～10，默認的優先級是5。“高優先級線程”會優先於“低優先級線程”執行。

Java並發編程實踐讀書筆記（5） 線程池的使用

設計 java並發編程 指定 數據交換 什麽 讀書 body 發展 ima Executor與Task的耦合性 1，除非線程池很非常大，否則一個Task不要依賴同一個線程服務中的另外一個Task，因為這樣容易造成死鎖； 2，線程的執行是並行的，所以在設計Task的時候要考慮