序言
首先问自己一个问题,Java在支持多线程方面做了哪些努力?
第一,JVM屏蔽了各种平台差别,结合处理器层面,提供并发源语的支持,例如synchronized、volatile;
第二,JDK的编写者提供了并发工具包(java.util.concurrent),例如JUC锁实现线程同步的轻量方式;
第三,支持开发者对线程、线程池的状态管理,例如线程开启、休息、停止。
- 多线程的优点
- 多线程的目标
- 并发源语、JUC锁
- 使用例子 经验总结
1、多线程的优点
压榨处理器性能
首先,单核CPU通过时钟频率的缩短来提升性能已经到了瓶颈,主流厂商都已支持多核CPU,如果还是单线程程序的话,那就是只能使用一个CPU,存在资源浪费;
其次,即使面对单核CPU,线程存在挂起、阻塞的机制,而且学过操作系统的同学都知道,阻塞时候CPU可以被分配给其他线程使用,就比如你喝茶的同时不影响看报纸。
2、多线程的目标
安排合理的调度机制
在提升CPU使用率的同时,降低线程上下文切换的频率,这需要Doug Lea和诸位程序员的共同努力。
3、Java对多线程的支持、并发源语、JUC锁
我将顺序介绍以下知识点,
- 线程阻塞的含义、线程的状态切换
- 并发源语、并发工具包的使用
- JUC包底层原理探究
第一,线程阻塞是指线程挂起,广义上讲,“夯住”也算是挂起的一种。当前线程阻塞后,CPU才能分配时间片给下一个线程。而本质上有两种方式让线程阻塞,第一,自旋式获取状态;第二,使用等待、唤醒机制。第一种对于CPU很不友好,所以我们着重说第二种。等待在JAVA实现上是调用Object.wait()的方法和Unsafe.park()的两种方式,对应的都是Native方法实现,鉴于本人C++能力薄弱,暂时只研究到JNI层面。
线程的状态切换主流程图片:
特别注明:当线程被中断后,可从waiting、waiting_timeout、blocked直接到terminate,非主要流程,本图不再赘述
第二,并发源语和并发工具包,在Java1.5之前,只有synchronized和volatile两种并发源语,Java1.5以后,配合处理器支持CAS操作,诞生了JUC的工具包,以ReentranLock、Semaphore、CylicBarrier、阻塞队列(LinkedBlockQueue)为代表,下面详解使用流程
- volatile
特性 | 解释 |
---|---|
可见性 | 及时刷新到进程主存,置其他线程内存过期 |
禁止重排序 | 程序顺序、内存、处理器指令禁止重排序(lock cmpExange) |
原子性 | 不保证原子性,不能做有状态依赖的操作,比如计数 |
实现方式 | 处理器插入内存屏障 |
具体规则 | volatile写之前的任何操作,不会排到之后;volatile读之后的操作,不会排到之前 |
- Semaphore :信号量
特性 | 解释 |
---|---|
semaphore.acquire() | 尝试获取1个信号量,获取不到就阻塞 |
Semaphore.release() | 增加1个信号量 |
场景 | 控制多个线程在特定情况下的有序执行,比如红灯停,绿灯亮,红灯是一个信号量A ,绿灯是信号量B,两个线程同时执行时候,如果执行完A,减A信号量,给B一个信号量;执行完B,减B信号量,给A一个信号量 |
经验 | 可以使用信号量的地方,使用ReentranLock+condition+volatile变量也可以搞定 |
/**
*实现A线程打印0,B线程打印1,各循环40次
**/
public static void main(String[] args) {
Semaphore semaphoreA = new Semaphore(1);
Semaphore semaphoreB = new Semaphore(0);
Thread t1 = new Thread(new Runnable() {
@Override
public void run() {
for (int i = 0; i < 40; i++) {
try {
semaphoreA.acquire();
System.out.print("0");
semaphoreB.release();
} catch (Exception e) {
}
}
}
});
Thread t2 = new Thread(new Runnable() {
@Override
public void run() {
for (int i = 0; i < 40; i++) {
try {
semaphoreB.acquire();
System.out.print("1");
semaphoreA.release();
} catch (Exception e) {
}
}
}
});
t2.start();
t1.start();
}
- 队列:linkedBlockQueue
实现:使用reentranLock的两个condition实现生产者、消费者模式,若队列为空,阻塞消费者;队列已满,阻塞生产者
putLock.lockInterruptibly();
try {
// 每次检查队列满,则让线程在notFull处等待,加入等待队列
while (count.get() == capacity) {
notFull.await();
}
enqueue(node);
c = count.getAndIncrement();
if (c + 1 < capacity)
notFull.signal();
} finally {
putLock.unlock();
}
- CyclicBarrier:栅栏
cyclicBarrier.await():实现线程等待,计数到顶时候开始执行线程
优点是计数可自动恢复,这个也是区分countDownLatch的特性
// 1、实现的关键,让线程在trip处等待
/** The lock for guarding barrier entry */
private final ReentrantLock lock = new ReentrantLock();
/** Condition to wait on until tripped */
private final Condition trip = lock.newCondition();
// 2、当达到线程数量时候,index=0
int index = --count;
if (index == 0) { // tripped
boolean ranAction = false;
try {
final Runnable command = barrierCommand;
if (command != null)
command.run();
ranAction = true;
// 这里会将计数重置,开始下一轮
nextGeneration();
return 0;
} finally {
if (!ranAction)
breakBarrier();
}
}
// 唤醒阻塞在trip的线程,重置计数
private void nextGeneration() {
// signal completion of last generation
trip.signalAll();
// set up next generation
count = parties;
generation = new Generation();
}
第三,对于JUC底层的探究,JUC的实现依赖于AQS
特性 | 含义 |
---|---|
同步队列(CLH) | FIFO的双向链表 |
队列构建 | 线程尝试CAS更新状态值,更新成功,则代表获取到锁;更新失败则作为node加入同步队列的尾部 |
队列出队 | 每个结点做CAS自旋,当头结点释放锁之后;公平锁保证头结点的后续结点,通过CAS更新状态值,获取到锁;非公平锁是所有同步队列的结点均参与CAS更新状态值;若线程调用lock.await()时候,从同步队列头结点移除,加入等待队列 |
4、经验总结
伟大的读者一定是一个伟大的作者,提升知识水平,要努力做到以下要点,共勉:
- 多读大师的书
- 带着问题、思考、批判的看待
- 纸上得来总觉浅,绝知此事要躬行
参考资料推荐:
- 深入Java内存模型(程晓明)
- Java并发编程的艺术(方腾飞)
- The leaves fall where the root being(落叶归根)