Java併發編程4--線程間通信的實現方式

Volatile 內存共享

基於 volatile 關鍵字來實現線程間相互通信是使用共享內存的思想，上一章有過介紹，想具體瞭解的碼友可以去看一下，Java併發編程3–認識Volatile和JMM

public class VolatileThread implements Runnable {

	private static volatile Boolean flag = true;

	@Override
	public void run() {
		while (flag) {
			System.out.println(Thread.currentThread().getName() + " - 執行");
		}
		System.out.println("線程結束");
	}

	public static void main(String[] args) {
		Thread volatileThread = new Thread(new VolatileThread());
		volatileThread.start();
		try {
			Thread.sleep(5);
			flag = false;
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}
}

wait/notify 等待

看個案例，比較經典的，兩個線程，一個線程打印1-25，另一個線程打印字母A~Z，打印順序爲1A2B…25Z，要求使用線程間的通信。
這是利用wait/notify 最基本的線程通信，threadFlag是打印數字還是字母的標識，

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class MethodOne {
    
	static class ThreadToGo {
		boolean threadFlag = true;
    }
	
    public static void main(String args[]) throws Exception {
    	
    	final ThreadToGo threadToGo = new ThreadToGo();
    	List<String> list = new ArrayList<>();
    	
    	List<String> listSZ =  Arrays.asList("1","2","3","4","5","6");
    	List<String> listZM =  Arrays.asList("A","B","C","D","E","F");
        Thread thread1 = new Thread(()->{
        	synchronized (threadToGo) {
				for (int i = 0; i < listZM.size(); i++) {
					if(threadToGo.threadFlag == true){
						try {
							threadToGo.wait();
						} catch (InterruptedException e) { 
						}
					}
					threadToGo.threadFlag = true;
					list.add(listZM.get(i));
					threadToGo.notify();
				}
			}
        });
        
        Thread thread2 = new Thread(()->{
        	synchronized (threadToGo) {
				for (int i = 0; i < listSZ.size(); i++) {
					if(threadToGo.threadFlag != true){
						try {
							threadToGo.wait();
						} catch (InterruptedException e) {
						}
					}
					threadToGo.threadFlag = false;
					list.add(listSZ.get(i));
					threadToGo.notify();
				}
			}
        });
        thread1.start();
        thread2.start();
        Thread.sleep(3000);
        System.out.println(list.toString());
    }
}

使用JUC工具類CountDownLatch

CountDownLatch是一個同步工具類，用來協調多個線程之間的同步，或者說起到線程之間的通信（而不是用作互斥的作用）。
CountDownLatch典型用法：

• 1、某一線程在開始運行前等待n個線程執行完畢。將CountDownLatch的計數器初始化爲new CountDownLatch(n)，每當一個任務線程執行完畢，就將計數器減1 countdownLatch.countDown()，當計數器的值變爲0時，在CountDownLatch上await()的線程就會被喚醒。一個典型應用場景就是啓動一個服務時，主線程需要等待多個組件加載完畢，之後再繼續執行。
• 2、實現多個線程開始執行任務的最大並行性。注意是並行性，不是併發，強調的是多個線程在某一時刻同時開始執行。類似於賽跑，將多個線程放到起點，等待發令槍響，然後同時開跑。做法是初始化一個共享的CountDownLatch(1)，將其計算器初始化爲1，多個線程在開始執行任務前首先countdownlatch.await()，當主線程調用countDown()時，計數器變爲0，多個線程同時被喚醒。

注意： CountDownLatch是一次性的，計算器的值只能在構造方法中初始化一次，之後沒有任何機制再次對其設置值，當CountDownLatch使用完畢後，它不能再次被使用。所以在線程通信中使用比較侷限。

使用 ReentrantLock 結合 Condition

打印1A2B…25Z的案例用Condition實現，

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;

public class MethodOne {
    
	static class ThreadToGo {
		boolean threadFlag = true;
    }
	
    public static void main(String args[]) throws Exception {
    	
    	final ThreadToGo threadToGo = new ThreadToGo();
    	List<String> list = new ArrayList<>();
	    ReentrantLock lock = new ReentrantLock();
        Condition condition = lock.newCondition();
    	
    	List<String> listSZ =  Arrays.asList("1","2","3","4","5","6");
    	List<String> listZM =  Arrays.asList("A","B","C","D","E","F");
        Thread thread1 = new Thread(()->{
        	
        	lock.lock();
			for (int i = 0; i < listZM.size(); i++) {
				if(threadToGo.threadFlag == true){
					try {
						condition.await();
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
				}
				threadToGo.threadFlag = true;
				list.add(listZM.get(i));
				condition.signal();
			}
			lock.unlock();
        });
        
        Thread thread2 = new Thread(()->{
        	lock.lock();
			for (int i = 0; i < listSZ.size(); i++) {
				if(threadToGo.threadFlag != true){
					try {
						condition.await();
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
				}
				threadToGo.threadFlag = false;
				list.add(listSZ.get(i));
				condition.signal();
			}
			lock.unlock();
        });
        thread1.start();
        thread2.start();
        Thread.sleep(3000);
        System.out.println(list.toString());
    }
}

基本LockSupport實現線程間的阻塞和喚醒

LockSupport 是一種非常靈活的實現線程間阻塞和喚醒的工具，使用它不用關注是等待線程先進行還是喚醒線程先運行，但是得知道線程的名字。

• LockSupport.park()：可以用來阻塞當前線程,park是停車的意思，把運行的線程比作行駛的車輛，線程阻塞則相當於汽車停車，相當直觀。
• LockSupport.park(Object blocker),指定線程阻塞的對象blocker，該對象主要用來排查問題。
• LockSupport.unpark(Thread thread)用來喚醒線程，因爲需要線程作參數，所以可以指定線程進行喚醒。

public class LockSupportTest {

    public static void main(String[] args) {
        Thread parkThread = new Thread(()->{
             System.out.println("開始線程阻塞");
             LockSupport.park();
             System.out.println("結束線程阻塞");
        });
        parkThread.start();
        System.out.println("開始線程喚醒");
        LockSupport.unpark(parkThread);
        System.out.println("結束線程喚醒");
    }
}