文章目录
- Volatile 内存共享
- wait/notify 等待
- 使用JUC工具类CountDownLatch
- 使用 ReentrantLock 结合 Condition
- 基本LockSupport实现线程间的阻塞和唤醒
Volatile 内存共享
基于 volatile 关键字来实现线程间相互通信是使用共享内存的思想
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("结束线程唤醒");
}
}