JAVA并发四（并发的部分应用）
2021/12/13 22:17:54
本文主要是介绍JAVA并发四（并发的部分应用），对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！
1.同步模式之保护性暂停
1.1.定义
即 Guarded Suspension，用在一个线程等待另一个线程的执行结果，要点：
有一个结果需要从一个线程传递到另一个线程，让他们关联同一个 GuardedObject
如果有结果不断从一个线程到另一个线程那么可以使用消息队列（见生产者/消费者）
JDK 中，join 的实现、Future 的实现，采用的就是此模式
因为要等待另一方的结果，因此归类到同步模式
1.2.举例
public class ProtectSyn {
public static void main(String[] args) {
String hello = "hello thread!";
Guarded guarded = new Guarded();
new Thread(()->{
System.out.println("想要得到结果");
synchronized (guarded) {
System.out.println("结果是："+guarded.getResponse());
}
System.out.println("得到结果");
}).start();
new Thread(()->{
System.out.println("设置结果");
synchronized (guarded) {
guarded.setResponse(hello);
}
}).start();
}
}
class Guarded {
/**
* 要返回的结果
*/
private Object response;
//优雅地使用wait/notify
public Object getResponse() {
//如果返回结果为空就一直等待，避免虚假唤醒
while(response == null) {
synchronized (this) {
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
return response;
}
public void setResponse(Object response) {
this.response = response;
synchronized (this) {
//唤醒休眠的线程
this.notifyAll();
}
}
@Override
public String toString() {
return "Guarded{" +
"response=" + response +
'}';
}
}
带超时判断的暂停：
public Object getResponse(long time) {
synchronized (this) {
//获取开始时间
long currentTime = System.currentTimeMillis();
//用于保存已经等待了的时间
long passedTime = 0;
while(response == null) {
//看经过的时间-开始时间是否超过了指定时间
long waitTime = time - passedTime;
if(waitTime <= 0) {
break;
}
try {
//等待剩余时间
this.wait(waitTime);
} catch (InterruptedException e) {
e.printStackTrace();
}
//获取当前时间
passedTime = System.currentTimeMillis()-currentTime
}
}
return response;
}
thread.join（）方法中就利用了带超时判断的保护性暂停
public final synchronized void join(long millis) throws InterruptedException {
long base = System.currentTimeMillis();
long now = 0L;
if (millis < 0L) {
throw new IllegalArgumentException("timeout value is negative");
} else {
if (millis == 0L) {
while(this.isAlive()) {
this.wait(0L);
}
} else {
while(this.isAlive()) {
long delay = millis - now;
if (delay <= 0L) {
break;
}
this.wait(delay);
now = System.currentTimeMillis() - base;
}
}
}
}
1.3 异步模式之生产者消费者模式：
要点
-
与前面的保护性暂停中的 GuardObject 不同，不需要产生结果和消费结果的线程一一对应
-
消费队列可以用来平衡生产和消费的线程资源
-
生产者仅负责产生结果数据，不关心数据该如何处理，而消费者专心处理结果数据
-
消息队列是有容量限制的，满时不会再加入数据，空时不会再消耗数据
-
JDK 中各种阻塞队列，采用的就是这种模式
“异步”的意思就是生产者产生消息之后消息没有被立刻消费，而“同步模式”中，消息在产生之后被立刻消费了。
简而言之，异步模式的生产者的消息被消息队列给消费了，消费队列消费了消息之后，又把消息转手给了消费者，消息队列充当了中间商的角色。
同步模式就是没有中间商赚差价，一对一直销。
2.park() 和 unpark()方法：
2.1 基本使用：
// 暂停当前线程 LockSupport.park(); // 恢复某个线程的运行 LockSupport.unpark;
2.2 原理
每个线程都有一个自己的Park对象，并且该对象_counter, _cond,__mutex组成
先调用park再调用unpark时
先调用park
线程运行时，会将Park对象中的_counter的值设为0；
调用park时，会先查看counter的值是否为0，如果为0，则将线程放入阻塞队列cond中
放入阻塞队列中后，会再次将counter设置为0
然后调用unpark
调用unpark方法后，会将counter的值设置为1
去唤醒阻塞队列cond中的线程
线程继续运行并将counter的值设为0
-
打个比喻线程就像一个旅人，Parker 就像他随身携带的背包，条件变量 _ cond就好比背包中的帐篷。_counter 就好比背包中的备用干粮（0 为耗尽，1 为充足）
-
调用 park 就是要看需不需要停下来歇息
-
如果备用干粮耗尽，那么钻进帐篷歇息
-
如果备用干粮充足，那么不需停留，继续前进
-
-
调用 unpark，就好比令干粮充足
-
如果这时线程还在帐篷，就唤醒让他继续前进
-
如果这时线程还在运行，那么下次他调用 park 时，仅是消耗掉备用干粮，不需停留继续前进
-
因为背包空间有限，多次调用 unpark 仅会补充一份备用干粮
-
-
3.线程中的状态转换
情况一：NEW –> RUNNABLE
当调用了t.start()方法时，由 NEW –> RUNNABLE
情况二： RUNNABLE <–> WAITING
当调用了t 线程用 synchronized(obj) 获取了对象锁后
调用 obj.wait() 方法时，t 线程从 RUNNABLE –> WAITING
调用 obj.notify() ， obj.notifyAll() ， t.interrupt() 时
竞争锁成功，t 线程从 WAITING –> RUNNABLE
竞争锁失败，t 线程从 WAITING –> BLOCKED
情况三：RUNNABLE <–> WAITING
当前线程调用 t.join() 方法时，当前线程从 RUNNABLE –> WAITING
注意是当前线程在t 线程对象的监视器上等待
t 线程运行结束，或调用了当前线程的 interrupt() 时，当前线程从 WAITING –> RUNNABLE
情况四： RUNNABLE <–> WAITING
当前线程调用 LockSupport.park() 方法会让当前线程从 RUNNABLE –> WAITING
调用 LockSupport.unpark(目标线程) 或调用了线程 的 interrupt() ，会让目标线程从 WAITING –>RUNNABLE
情况五： RUNNABLE <–> TIMED_WAITING
t 线程用 synchronized(obj) 获取了对象锁后
调用 obj.wait(long n) 方法时，t 线程从 RUNNABLE –> TIMED_WAITING
t 线程等待时间超过了 n 毫秒，或调用 obj.notify() ， obj.notifyAll() ， t.interrupt() 时
竞争锁成功，t 线程从 TIMED_WAITING –> RUNNABLE
竞争锁失败，t 线程从 TIMED_WAITING –> BLOCKED
情况六：RUNNABLE <–> TIMED_WAITING
当前线程调用 t.join(long n) 方法时，当前线程从 RUNNABLE –> TIMED_WAITING
注意是当前线程在t 线程对象的监视器上等待
当前线程等待时间超过了 n 毫秒，或t 线程运行结束，或调用了当前线程的 interrupt() 时，当前线程从TIMED_WAITING –> RUNNABLE
情况七：RUNNABLE <–> TIMED_WAITING
当前线程调用 Thread.sleep(long n) ，当前线程从 RUNNABLE –> TIMED_WAITING
当前线程等待时间超过了 n 毫秒，当前线程从 TIMED_WAITING –> RUNNABLE
情况八：RUNNABLE <–> TIMED_WAITING
当前线程调用 LockSupport.parkNanos(long nanos) 或 LockSupport.parkUntil(long millis) 时，当前线 程从 RUNNABLE –> TIMED_WAITING
调用 LockSupport.unpark(目标线程) 或调用了线程 的 interrupt() ，或是等待超时，会让目标线程从TIMED_WAITING–> RUNNABLE
情况九：RUNNABLE <–> BLOCKED
t 线程用 synchronized(obj) 获取了对象锁时如果竞争失败，从 RUNNABLE –> BLOCKED
持 obj 锁线程的同步代码块执行完毕，会唤醒该对象上所有 BLOCKED 的线程重新竞争，如果其中 t 线程竞争 成功，从 BLOCKED –> RUNNABLE ，其它失败的线程仍然 BLOCKED
情况十： RUNNABLE <–> TERMINATED
当前线程所有代码运行完毕，进入 TERMINATED
4.活跃性
因为某种原因，使得代码一直无法执行完毕，这样的现象叫做活跃性，活跃性相关的一系列问题都可以用ReentrantLock进行解决。
4.1死锁
一个线程需要同时获取多把锁，这时就容易发生死锁t1 线程获得A对象锁，接下来想获取B对象的锁；t2 线程获得B对象锁，接下来想获取A对象的锁例。
public class DeadLock {
public static void main(String[] args) {
Object o1 = new Object();
Object o2 = new Object();
new Thread(){
@Override
public void run(){
//拿o1的锁
synchronized (o1){
try {
//等待一段时间保证o1拿到锁不会立马释放。
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
//再去拿o2的锁 而此时o2的锁已经被另外一个线程持有。
synchronized (o2){
}
}
}
}.start();
new Thread(){
@Override
public void run(){
//拿o2的锁
synchronized (o2){
try {
//等待一段时间保证o2拿到锁不会立马释放。
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
//再去拿o1的锁 而此时o1的锁已经被另外一个线程持有。
synchronized (o1){
}
}
}
}.start();
}
}
发生死锁的必要条件
互斥条件
在一段时间内，一种资源只能被一个进程所使用
请求和保持条件
进程已经拥有了至少一种资源，同时又去申请其他资源。因为其他资源被别的进程所使用，该进程进入阻塞状态，并且不释放自己已有的资源
不可抢占条件
进程对已获得的资源在未使用完成前不能被强占，只能在进程使用完后自己释放
循环等待条件
发生死锁时，必然存在一个进程——资源的循环链。
4.2哲学家就餐问题(锁经典问题)
4.3活锁
活锁出现在两个线程互相改变对方的结束条件，后谁也无法结束。
避免活锁的方法： 在线程执行时，中途给予不同的间隔时间即可。
死锁与活锁的区别
死锁是因为线程互相持有对象想要的锁，并且都不释放，最后到时线程阻塞，停止运行的现象。
活锁是因为线程间修改了对方的结束条件，而导致代码一直在运行，却一直运行不完的现象。
4.4饥饿
某些线程因为优先级太低，导致一直无法获得资源的现象。
在使用顺序加锁时，可能会出现饥饿现象
5.ReentrantLock
java.util.concurrent.locks.ReentrantLock;
和synchronized相比具有的的特点
可中断
可以设置超时时间
可以设置为公平锁 (先到先得)
支持多个条件变量( 具有多个waitset)
与 synchronized 一样，都支持可重入。
// 获取锁
reentrantLock.lock();
try {
// 临界区
} finally {
// 释放锁
reentrantLock.unlock();
}
可重入
可重入是指同一个线程如果首次获得了这把锁，那么因为它是这把锁的拥有者，因此有权利再次获取这把锁如果是不可重入锁，那么第二次获得锁时，自己也会被锁挡住。
可打断
如果某个线程处于阻塞状态，可以调用其interrupt方法让其停止阻塞，获得锁失败
简而言之就是：处于阻塞状态的线程，被打断了就不用阻塞了，直接停止运行。
锁超时
使用lock.tryLock方法会返回获取锁是否成功。如果成功则返回true，反之则返回false。
并且tryLock方法可以指定等待时间，参数为：tryLock(long timeout, TimeUnit unit), 其中timeout为最长等待时间，TimeUnit为时间单位简而言之就是：获取失败了、获取超时了或者被打断了，不再阻塞，直接停止运行。
附：集合并发可能遇到的错误：
这篇关于JAVA并发四（并发的部分应用）的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！
- 2024-11-14后台交互资料入门指南
- 2024-11-14如何轻松创建项目环境：新手入门教程
- 2024-11-14如何抽离公共代码：初级开发者指南
- 2024-11-14Python编程入门指南
- 2024-11-14Python编程入门：如何获取参数
- 2024-11-14JWT 用户校验：简单教程与实践
- 2024-11-14Pre-commit 自动化测试入门指南
- 2024-11-14Python编程基础
- 2024-11-14Server Action入门教程：轻松掌握服务器操作
- 2024-11-14Server Component入门教程：轻松搭建服务器组件
