Java并发编程4--线程间通信的实现方式

更多内容请看：Java并发编程学习笔记

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("结束线程唤醒");
    }
}