【Java难点】多线程-高级

悲观锁和乐观锁

悲观锁

synchronized关键字和Lock的实现类都是悲观锁。

它很悲观，认为自己在使用数据的时候一定有别的线程来修改数据，因此在获取数据的时候会一不做二不休的先加锁，确保数据不会被别的线程修改。

适合写操作多的场景，先加锁可以保证写操作时数据正确。

实例：

image-20240428003636339

乐观锁

它很乐观，认为自己在使用数据时不会有别的线程修改数据或资源，所以不会添加锁。

在Java中是通过使用无锁编程来实现，只是在更新数据的时候去判断，之前有没有别的线程更新了这个数据。如果这个数据没有被更新，当前线程将自己修改的数据成功写入。如果这个数据己经被其它线程更新，则根据不同的实现方式执行不同的操作，比如放弃修改、重试抢锁等等。

乐观锁的实现方式：

  • 采用Version版本号机制

  • 采用CAS算法实现

    实例：

image-20240428003707495

锁案例演示

案例1
import java.util.concurrent.TimeUnit;public class JUC04 {public static void main(String[] args) {Phone phone = new Phone();new Thread(()->{phone.sendEmail();},"a").start();new Thread(()->{phone.sendSMS();},"b").start();try {TimeUnit.SECONDS.sleep(1);} catch (InterruptedException e) {e.printStackTrace();}}
}/*** 资源类*/
class Phone{public synchronized void sendEmail(){System.out.println("--------sendEmail");}public synchronized void sendSMS(){System.out.println("--------sendSMS");}
}

请问先打印邮件还是短信？

image-20240428005339903

案例2
import java.util.concurrent.TimeUnit;public class JUC04 {public static void main(String[] args) {Phone phone = new Phone();new Thread(()->{phone.sendEmail();},"a").start();new Thread(()->{phone.sendSMS();},"b").start();try {TimeUnit.SECONDS.sleep(1);} catch (InterruptedException e) {e.printStackTrace();}}
}/*** 资源类*/
class Phone{public synchronized void sendEmail(){try {TimeUnit.SECONDS.sleep(3);} catch (InterruptedException e) {e.printStackTrace();}System.out.println("--------sendEmail");}public synchronized void sendSMS(){System.out.println("--------sendSMS");}
}

请问先打印邮件还是短信？

image-20240428005646180

案例3
import java.util.concurrent.TimeUnit;public class JUC04 {public static void main(String[] args) {Phone phone = new Phone();new Thread(()->{phone.sendEmail();},"a").start();new Thread(()->{phone.hello();},"b").start();try {TimeUnit.SECONDS.sleep(1);} catch (InterruptedException e) {e.printStackTrace();}}
}/*** 资源类*/
class Phone{public synchronized void sendEmail(){try {TimeUnit.SECONDS.sleep(3);} catch (InterruptedException e) {e.printStackTrace();}System.out.println("--------sendEmail");}public void hello(){System.out.println("--------hello");}
}

请问先打印邮件还是hello？

image-20240428010005046

案例4
import java.util.concurrent.TimeUnit;public class JUC04 {public static void main(String[] args) {Phone phone = new Phone();Phone phone2 = new Phone();new Thread(()->{phone.sendEmail();},"a").start();new Thread(()->{phone2.sendSMS();},"b").start();try {TimeUnit.SECONDS.sleep(1);} catch (InterruptedException e) {e.printStackTrace();}}
}/*** 资源类*/
class Phone{public synchronized void sendEmail(){try {TimeUnit.SECONDS.sleep(3);} catch (InterruptedException e) {e.printStackTrace();}System.out.println("--------sendEmail");}public synchronized void sendSMS(){System.out.println("--------sendSMS");}
}

有两部手机，请问先打印邮件还是短信？

image-20240428010211612

案例5
import java.util.concurrent.TimeUnit;public class JUC04 {public static void main(String[] args) {Phone phone = new Phone();new Thread(()->{phone.sendEmail();},"a").start();new Thread(()->{phone.sendSMS();},"b").start();try {TimeUnit.SECONDS.sleep(1);} catch (InterruptedException e) {e.printStackTrace();}}
}/*** 资源类*/
class Phone{public static synchronized void sendEmail(){try {TimeUnit.SECONDS.sleep(3);} catch (InterruptedException e) {e.printStackTrace();}System.out.println("--------sendEmail");}public static synchronized void sendSMS(){System.out.println("--------sendSMS");}
}

有两个静态同步方法，有一部手机，请问先打印邮件还是短信？

image-20240428010526197

案例6
import java.util.concurrent.TimeUnit;public class JUC04 {public static void main(String[] args) {Phone phone = new Phone();Phone phone2 = new Phone();new Thread(()->{phone.sendEmail();},"a").start();new Thread(()->{phone2.sendSMS();},"b").start();try {TimeUnit.SECONDS.sleep(1);} catch (InterruptedException e) {e.printStackTrace();}}
}/*** 资源类*/
class Phone{public static synchronized void sendEmail(){try {TimeUnit.SECONDS.sleep(3);} catch (InterruptedException e) {e.printStackTrace();}System.out.println("--------sendEmail");}public static synchronized void sendSMS(){System.out.println("--------sendSMS");}
}

有两个静态同步方法，有两部手机，请问先打印邮件还是短信？

image-20240428010724241

案例7
 import java.util.concurrent.TimeUnit;public class JUC04 {public static void main(String[] args) {Phone phone = new Phone();new Thread(()->{phone.sendEmail();},"a").start();new Thread(()->{phone.sendSMS();},"b").start();try {TimeUnit.SECONDS.sleep(1);} catch (InterruptedException e) {e.printStackTrace();}}
}/*** 资源类*/
class Phone{public static synchronized void sendEmail(){try {TimeUnit.SECONDS.sleep(3);} catch (InterruptedException e) {e.printStackTrace();}  System.out.println("--------sendEmail");}public static void sendSMS(){System.out.println("--------sendSMS");}
}

有一个静态同步方法，一个普通静态方法，有一部手机，请问先打印邮件还是短信？

image-20240428011114157

案例8
import java.util.concurrent.TimeUnit;public class JUC04 {public static void main(String[] args) {Phone phone = new Phone();Phone phone2 = new Phone();new Thread(()->{phone.sendEmail();},"a").start();new Thread(()->{phone2.sendSMS();},"b").start();try {TimeUnit.SECONDS.sleep(1);} catch (InterruptedException e) {e.printStackTrace();}}
}/*** 资源类*/
class Phone{public static synchronized void sendEmail(){try {TimeUnit.SECONDS.sleep(3);} catch (InterruptedException e) {e.printStackTrace();}System.out.println("--------sendEmail");}public static void sendSMS(){System.out.println("--------sendSMS");}
}

有一个静态同步方法，一个普通静态方法，有两部手机，请问先打印邮件还是短信？

image-20240428011251980

笔记总结

案例1和案例2：

一个对象里面如果有多个synchronized方法，某一个时刻内，只要一个线程去调用其中的一个synchronized方法了，其它的线程都只能等待，换句话说，某一个时刻内，只能有唯一的一个线程去访问这些synchronized方法，锁的是当前对象this，被锁定后，其它的线程都不能进入到当前对象的其它的 synchronized方法。

案例3和案例4：

普通方法和同步锁无关，换成两个对象后，不是同一把锁了

案例5和案例6：

对于普通同步方法，锁的是当前实例对象，通常指this，具体的一部手机，所有的普通同步方法用的都是同一把锁->实例对象本身；

对于静态同步方法，锁的是当前类的class 对象，如Phone.class；

对于同步代码块，锁的是 synchronized 扩号内的对象。

案例7和案例8：

当一个线程试图访问同步代码块时，它首先必须得到锁，正常退出或抛出异常时必须释放锁。

所有的普通同步方法用的都是同一把锁-实例对象本身，就是new出来的具体实例对象本身，本类this
也就是说如果一个实例对象的普通同步方法获取锁后，该实例对象的其他普通同步方法必须等待获取锁的方法释放锁后才能再次获取锁。

所有的静态同步方法用的也是同一把锁-类对象（类名.class）本身，具体实例对象this 和类对象本身，这两把锁是两个不同的对象，所以静态同步方法与普通同步方法之间是不会有竞态条件的，但是一但一个静态同步方法获取锁后，其他的静态同步方法都必须等待该方法释放锁后才能获取锁。

synchronized字节码分析

synchronized代码块
public class JUC05 {Object o=new Object();public void m1(){synchronized (o){System.out.println("----hello synchronized code block");}}public static void main(String[] args) {}
}

运行main方法，会在src的同级目录下生成一个target目录，进入target下的classes目录，找到JUC05.class，右键->打开于->终端，在终端中输入javap -c JUC05 ，对 JUC05.class进行反编译，得到如下信息：

image-20240428230628261

synchronized代码块使用的是monitorenter和monitorexit指令来持有锁和释放锁。

问： 一定是1个monitorenter对应2个monitorexit吗？

答： 一般情况下，1个monitorenter对应2个monitorexit，但是也存在极端的情况，1个monitorenter对应1个monitorexit

image-20240428230221143

synchronized同步方法

public class JUC05 {public synchronized void m2(){System.out.println("----hello synchronized m2");}public static void main(String[] args) {}
}

运行main方法，会在src的同级目录下生成一个target目录，进入target下的classes目录，找到JUC05.class，右键->打开于->终端，在终端中输入javap -v JUC05 ，对 JUC05.class进行反编译，得到如下信息：

image-20240428231242956

调用指令将会检查方法的ACC_SYNCHRONIZED访问标志是否被设置。如果设置了，执行线程会先持有montor锁， 然后再执行方法，最后在方法完成(无论是正常完成还是非正常完成)时释放monitor

synchronized静态同步方法

public class JUC05 {public synchronized void m2(){System.out.println("----hello synchronized m2");}public static synchronized void m3(){System.out.println("----hello static synchronized m3");}public static void main(String[] args) {}
}

运行main方法，会在src的同级目录下生成一个target目录，进入target下的classes目录，找到JUC05.class，右键->打开于->终端，在终端中输入javap -v JUC05 ，对 JUC05.class进行反编译，得到如下信息：

image-20240428231557432

ACC_STATIC, ACC_SYNCHRONIZED访问标识来区分该方法是否静态同步方法

synchronized底层原语分析

问： 为什么任何一个对象都可以成为一个锁？

答：

公平锁和非公平锁

公平锁

image-20240428235631627

image-20240429002250063

非公平锁

image-20240428235654107

image-20240429002237433

问： 为什么会有公平锁和非公平锁的设计？为什么默认非公平？

答：

  1. 恢复挂起的线程到真正锁的获取还是有时间差的，从开发人员来看这个时间微乎其微，但是从CPU的角度来看，这个时间差存在的还是很明显的。所以非公平锁能更充分的利用CPU 的时间片，尽量减少 CPU 空闲状态时间。

  2. 使用多线程很重要的考量点是线程切换的开销，当采用非公平锁时，当1个线程请求锁获取同步状态，然后释放同步状态，所以刚释放锁的线程在此刻再次获取同步状态的概率就变得非常大，所以就减少了线程的开销。

问： 什么时候用非公平锁，什么时候用公平锁？

答：如果为了更高的吞吐量，很显然非公平锁是比较合适的，因为节省很多线程切换时间，吞吐量自然就上去了；否则那就用公平锁，大家公平使用。

可重入锁（递归锁）

定义

可：可以；重：再次；入：进入；锁：同步锁。

image-20240429220921948

image-20240429001200863

重入锁的种类

隐式锁

synchronized关键字使用的锁就是隐式锁，默认是可重入锁。

  • 同步块实例
public class JUC05 {public static void main(String[] args) {final Object object=new Object();new Thread(()->{synchronized (object){System.out.println(Thread.currentThread().getName()+"\t --------外层调用");synchronized (object){System.out.println(Thread.currentThread().getName()+"\t --------中层调用");synchronized (object){System.out.println(Thread.currentThread().getName()+"\t --------内层调用");}}}},"t1").start();}
}

image-20240429221547347

  • 同步方法实例
public class JUC05 {public synchronized void m1(){System.out.println(Thread.currentThread().getName() + "\t --------come in");m2();System.out.println(Thread.currentThread().getName() + "\t --------end");}public synchronized void m2(){System.out.println(Thread.currentThread().getName() + "\t --------come in");m3();}public synchronized void m3(){System.out.println(Thread.currentThread().getName() + "\t --------come in");}public static void main(String[] args) {JUC05 juc05 = new JUC05();new Thread(() -> {juc05.m1();}, "t1").start();}
}

image-20240429222226712

synchronized的重入的实现原理：

image-20240429223205523

显示锁

Lock就是显示锁，需要手动上锁和释放锁，且Lock是可重入锁。如ReentrantLock。

import java.util.concurrent.locks.ReentrantLock;public class JUC05 {public static void main(String[] args) {ReentrantLock lock = new ReentrantLock();new Thread(()->{lock.lock();try{System.out.println(Thread.currentThread().getName() + "\t --------come in外层调用");lock.lock();try{System.out.println(Thread.currentThread().getName() + "\t --------come in内层调用");}finally {lock.unlock();}}finally {lock.unlock();}},"t1").start();}
}

image-20240429223806232

死锁及排查

死锁实例
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.ReentrantLock;public class JUC05 {public static void main(String[] args) {final Object objectA=new Object();final Object objectB=new Object();new Thread(()->{synchronized (objectA){System.out.println(Thread.currentThread().getName()+"\t 自己持有A锁，希望获得B锁");try {TimeUnit.SECONDS.sleep(1);} catch (InterruptedException e) {e.printStackTrace();}synchronized (objectB){System.out.println(Thread.currentThread().getName()+"\t 成功获得B锁");}}},"A").start();new Thread(()->{synchronized (objectB){System.out.println(Thread.currentThread().getName()+"\t 自己持有B锁，希望获得A锁");try {TimeUnit.SECONDS.sleep(1);} catch (InterruptedException e) {e.printStackTrace();}synchronized (objectA){System.out.println(Thread.currentThread().getName()+"\t 成功获得A锁");}}},"B").start();}
}

image-20240429225257004

排查死锁
  • 命令行的方式
  1. jps -l 列出JVM当前进程的信息

image-20240429225830293

  1. jstack 51282列出JVM中进程号为51282的栈信息

image-20240429230138475

  • 图像化界面的方式
  1. 命令行输入jconsole

image-20240429230323586

image-20240429230355996

image-20240429230547796

线程中断机制

什么是中断机制？

image-20240506224240131

中断的三大方法
  • public void interrupt()

实例方法，仅仅是设置线程的中断状态为true，发起协商，而不会立刻停止线程。

源码：

image-20240507222729949

image-20240507222745976

注意：

当对一个线程，调用 interrupt() 时：

  1. 如果线程处于正常活动状态，那么会将该线程的中断标志设置为 true，仅此而己。被设置中断标志的线程将继续正常运行，不受影响。所以，interrupt() 并不能真正的中断线程，需要被调用的线程自己进行配合才行。
  2. 如果线程处于被阻塞状态(例如处于sleep, wait, join等状态)，在别的线程中调用当前线程对象的interrupt()方法，那么线程将立即退出被阻塞状态，并且该线程的中断状态将被清除(置为false)，并且抛出一个InterruptedException异常，需要在异常处理中再次调用interrupt()方法，防止发生程序不能中断的现象。
  3. 当线程运行结束后，不管 该线程之前的中断标志是什么，调用isInterrupted()方法，都会返回false。
  • public boolean isInterrupted()

实例方法，Thread.isInterrupted()判断当前线程是否被中断（通过检查中断标志位）

源码：

image-20240507223636212

  • public static boolean interrupted()

静态方法，判断线程是否被中断并清除当前中断状态。这个方法做了两件事：

  1. 返回当前线程的中断状态，测试当前线程是否已被中断；
  2. 将当前线程的中断状态清零并重新设为false，清除线程的中断状态。如果连续两次调用此方法，则第二次调用将返回false，因为连续调用两次的结果可能不一样。

源码对比：

image-20240507232620407

如何中断一个运行中的线程？
  1. 通过一个volatile变量实现
import java.util.concurrent.TimeUnit;public class JUC06 {static volatile boolean isStop=false;public static void main(String[] args) {new Thread(()->{while(true){if(isStop){System.out.println(Thread.currentThread().getName()+"\t isStop被修改为true，程序停止");break;}System.out.println("----------hello");}},"t1").start();try {TimeUnit.MILLISECONDS.sleep(20);} catch (InterruptedException e) {e.printStackTrace();}new Thread(()->{isStop=true;},"t2").start();}
}
  1. 通过AtomicBoolean实现
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicBoolean;public class JUC06 {static AtomicBoolean atomicBoolean = new AtomicBoolean(false);public static void main(String[] args) {new Thread(()->{while(true){if(atomicBoolean.get()){System.out.println(Thread.currentThread().getName()+"\t atomicBoolean被修改为true，程序停止");break;}System.out.println("----------hello atomicBoolean");}},"t1").start();try {TimeUnit.MILLISECONDS.sleep(20);} catch (InterruptedException e) {e.printStackTrace();}new Thread(()->{atomicBoolean.set(true);},"t2").start();}
}
  1. 通过Thread类自带的终端api实例方法实现
import java.util.concurrent.TimeUnit;public class JUC06 {public static void main(String[] args) {Thread t1 = new Thread(() -> {while (true) {if (Thread.currentThread().isInterrupted()) {System.out.println(Thread.currentThread().getName() + "\t 中断标志位被修改为true，程序停止");break;}System.out.println("----------hello interrupt api");}}, "t1");t1.start();try {TimeUnit.MILLISECONDS.sleep(20);} catch (InterruptedException e) {e.printStackTrace();}//t2同t1发出协商，将t1的中断标志位设为true,希塑t1停下来new Thread(()->{t1.interrupt();},"t2").start();}
}

LockSupport

定义

image-20240508224429837

常用方法
  • public static void unpark(Thread thread)

会给thread线程发放许可证permit，会自动唤醒park阻塞的线程，即之前阻塞中的LockSupport.park()方法会立即取下阻塞。

  • public static void park()

如果当前线程没有许可证permit，则调用park方法会使该线程阻塞，直到别的线程给当前线程发放许可证permit，park方法才会被唤醒。park方法会消耗一张许可证

线程阻塞和唤醒的方式
  1. 使用Object中的wait()方法让线程等待，使用Object中的notify()方法唤醒线程
import java.util.concurrent.TimeUnit;public class JUC07 {public static void main(String[] args) {Object objectLock = new Object();new Thread(()->{synchronized (objectLock){System.out.println(Thread.currentThread().getName()+"\t -----come in");try {objectLock.wait(); //wait方法会释放锁objectLock} catch (InterruptedException e) {e.printStackTrace();}System.out.println(Thread.currentThread().getName()+"\t -----被唤醒了");}},"t1").start();try {TimeUnit.SECONDS.sleep(1);} catch (InterruptedException e) {e.printStackTrace();}new Thread(()->{synchronized (objectLock){objectLock.notify();System.out.println(Thread.currentThread().getName()+"\t -----发出通知");}},"t2").start();}
}

image-20240508214252890

注意：

  • wait方法和notify方法必须在synchronized中调用，否则会报错：

image-20240508214236494

  • 将notify方法放在wait方法前面，将无法唤醒
  1. 使用JUC包中Condition的await()方法让线程等待，使用signal()方法唤醒线程
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;public class JUC07 {public static void main(String[] args) {Lock lock = new ReentrantLock();Condition condition = lock.newCondition();new Thread(()->{lock.lock();try {System.out.println(Thread.currentThread().getName()+"\t -----come in");condition.await();//await方法会释放锁lockSystem.out.println(Thread.currentThread().getName()+"\t -----被唤醒");} catch (InterruptedException e) {e.printStackTrace();}finally {lock.unlock();}},"t1").start();try {TimeUnit.SECONDS.sleep(1);} catch (InterruptedException e) {e.printStackTrace();}new Thread(()->{lock.lock();try {condition.signal();System.out.println(Thread.currentThread().getName()+"\t -----发出通知");}finally {lock.unlock();}},"t2").start();}
}

image-20240508215558578

注意：

  • await方法和signal方法必须在持有锁后调用，否则会报错
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;public class JUC07 {public static void main(String[] args) {Lock lock = new ReentrantLock();Condition condition = lock.newCondition();new Thread(()->{
//            lock.lock();try {System.out.println(Thread.currentThread().getName()+"\t -----come in");condition.await();System.out.println(Thread.currentThread().getName()+"\t -----被唤醒");} catch (InterruptedException e) {e.printStackTrace();}finally {
//                lock.unlock();}},"t1").start();try {TimeUnit.SECONDS.sleep(1);} catch (InterruptedException e) {e.printStackTrace();}new Thread(()->{
//            lock.lock();try {condition.signal();System.out.println(Thread.currentThread().getName()+"\t -----发出通知");}finally {
//                lock.unlock();}},"t2").start();}
}

image-20240508215443707

  • 将signal方法放在await方法前面，将无法唤醒

image-20240508215909946

总结

上述两种方式存在如下限制，

  • wait和notify、await和signal必须要在线程获得锁后调用，即必须在锁块(synchronized或lock)中

  • 必须要先等待，后唤醒，线程才能够被唤醒。

所以引出了第三种方式（LockSupport类中的park等待和unpark唤醒）。

  1. LockSupport类可以阻塞当前线程以及唤醒指定被阻塞的线程
  • LockSupport类阻塞和唤醒线程不需要在锁块(synchronized或lock)中：
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.LockSupport;public class JUC07 {public static void main(String[] args) {Thread t1 = new Thread(()->{System.out.println(Thread.currentThread().getName()+"\t -----come in");LockSupport.park();System.out.println(Thread.currentThread().getName()+"\t -----被唤醒了");},"t1");t1.start();try {TimeUnit.SECONDS.sleep(1);} catch (InterruptedException e) {e.printStackTrace();}new Thread(()->{LockSupport.unpark(t1);//为t1线程发放许可证System.out.println(Thread.currentThread().getName()+"\t -----发出通知");},"t2").start();}
}

image-20240508221738371

  • LockSupport类阻塞和唤醒线程不需要先阻塞再唤醒，可以提前唤醒（提前给线程发放许可证）
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.LockSupport;public class JUC07 {public static void main(String[] args) {Thread t1 = new Thread(()->{try {TimeUnit.SECONDS.sleep(3);} catch (InterruptedException e) {e.printStackTrace();}System.out.println(Thread.currentThread().getName()+"\t -----come in"+System.currentTimeMillis());LockSupport.park();System.out.println(Thread.currentThread().getName()+"\t -----被唤醒了"+System.currentTimeMillis());},"t1");t1.start();new Thread(()->{LockSupport.unpark(t1); //为t1线程发放许可证System.out.println(Thread.currentThread().getName()+"\t -----发出通知");},"t2").start();}
}

image-20240508222827180

sleep方法3秒后醒来，执行park无效，没有阻塞效果，解释如下：先执行了unpark(t1)导致上面的park方法形同虚设无效，时间一样。类似高速公路的ETC，提前买好了通行证unpark，到闸机处直接抬起栏杆放行了，没有park拦截了。

注意

  • 一个线程最多拥有一张许可证
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.LockSupport;public class JUC07 {public static void main(String[] args) {Thread t1 = new Thread(()->{try {TimeUnit.SECONDS.sleep(3);} catch (InterruptedException e) {e.printStackTrace();}System.out.println(Thread.currentThread().getName()+"\t -----come in"+System.currentTimeMillis());LockSupport.park(); //消费一张许可证LockSupport.park(); //只为t1线程发放了一张许可证，再次消费许可证时，会阻塞在这里System.out.println(Thread.currentThread().getName()+"\t -----被唤醒了"+System.currentTimeMillis());},"t1");t1.start();new Thread(()->{LockSupport.unpark(t1); //为t1线程发放许可证。t1的许可证数量为1LockSupport.unpark(t1); //再次为t1线程发放许可证，但是一个线程只允许拥有一张许可证，所以t1的许可证数量还是1System.out.println(Thread.currentThread().getName()+"\t -----发出通知");},"t2").start();}
}

image-20240508223920718

面试题
  • 为什么可以突破wait/notify的原有调用顺序？

因为unpark发放了一个凭证，之后再调用park方法，就可以名正言顺的消费凭证，故不会阻塞。先发放了凭证，后续可以畅通无阻。

  • 为什么唤醒两次后阻塞两次，但最终结果还会阻塞线程？

因为凭证的数量最多为1，连续调用两次unpark和调用一次unpark效果一样，只会增加一个凭证；而调用两次 park却需要消费两个凭证，证不够，不能放行。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mzph.cn/bicheng/10733.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

TypeScript学习日志-第二十四天（webpack构建ts+vue3）

TypeScript学习日志-第二十四天（webpack构建ts+vue3）

webpack构建tsvue3 一、构建项目目录 如图： shim.d.ts 这个文件用于让ts识别.vue后缀的 后续会说 并且给 tsconfig.json 增加配置项 "include": ["src/**/*"] 二、基础构建 安装依赖 安装如下依赖： npm install webpack -D …
阅读更多...
ACC-UNet: A Completely Convolutional UNet Model for the 2020s

ACC-UNet: A Completely Convolutional UNet Model for the 2020s

文章目录 ACC-UNet: A Completely Convolutional UNet Model for the 2020s摘要方法实验结果 ACC-UNet: A Completely Convolutional UNet Model for the 2020s 摘要 这十年以来，计算机视觉领域引入了 Vision Transformer，标志着广泛的计算机视觉发生了…
阅读更多...
基于SpringBoot+Vue社区老人健康信息管理系统

基于SpringBoot+Vue社区老人健康信息管理系统

摘 要 如今社会上各行各业，都喜欢用自己行业的专属软件工作，互联网发展到这个时候，人们已经发现离不开了互联网。新技术的产生，往往能解决一些老技术的弊端问题。因为传统社区老人健康信息管理系统信息管理难度大，容错…
阅读更多...
JETBRAINS IDES 分享一个2099通用试用码！IDEA 2024 版 ，支持一键升级

JETBRAINS IDES 分享一个2099通用试用码！IDEA 2024 版 ，支持一键升级

文章目录 废话不多说上教程：（动画教程 图文教程）一、动画教程激活 与 升级（至最新版本） 二、图文教程 （推荐）Stage 1.下载安装 toolbox-app（全家桶管理工具）Stage 2 : 下…
阅读更多...
vs2019 STL库里 判断函数类型的模板 is_function_v 与 is_const_v

vs2019 STL库里 判断函数类型的模板 is_function_v 与 is_const_v

（1）源代码如下： 经简单代码测试后，得出 vs2019 的 c 编译器 和 其 STL 库的观点与设计：is_const_v 用来判断类型 T 内是否含有 const 修饰符，含有 const 则返回真。但若 T 是含有 const 的引用类型&#xf…
阅读更多...
链表与顺序表的比较

链表与顺序表的比较

目录 1.链表与顺序表的区别 1.1 存储空间 1.2 插入删除 1.3 扩容 1.4 使用场景 1.5 缓存使用率 1.链表与顺序表的区别 1.1 存储空间 顺序表在物理上与逻辑上都是连续的 链表在逻辑上连续物理不一定连续 因此顺序表我们可以任意访问而链表不可以随机访问 链表每次访问都…
阅读更多...
什么是XXE漏洞，日常如何做好web安全，避免漏洞威胁

什么是XXE漏洞，日常如何做好web安全，避免漏洞威胁

随着网络技术的不断发展，网站安全问题日益受到人们的关注。当前随着技术发展，网站存在一些常见的可能被攻击者利用的漏洞，而在众多网站安全漏洞中，XXE（XML External Entity）漏洞是一个不容忽视的问题。今天…
阅读更多...
Sass深度解析：性能优化的秘密

Sass深度解析：性能优化的秘密

首先，这篇文章是基于笔尖AI写作进行文章创作的，喜欢的宝子，也可以去体验下，解放双手，上班直接摸鱼~ 按照惯例，先介绍下这款笔尖AI写作，宝子也可以直接下滑跳过看正文~ 笔尖Ai写作：…
阅读更多...
Mysql数据库的基础学习

Mysql数据库的基础学习

为什么使用数据库？ 1.持久化：将数据保存到可掉电式存储设备中以供使用。 数据库相关概念： DB:数据库（Databass）即存储数据的仓库，本质是一个文件系统，保存了一系列有组织的数据DBMS:数据库管…
阅读更多...
netstat命令详解

netstat命令详解

netstat网络连接分析工具 工具说明： netstat 是一款命令行工具，主要是用于列出系统上所有的网络套接字连接情况，包括 tcp, udp 以及 unix 套接字，另外它还能列出处于监听状态（即等待接入请求）的套接字。除…
阅读更多...
基于SpringBoot+Vue的法律咨询系统

基于SpringBoot+Vue的法律咨询系统

课题背景 二十一世纪互联网的出现，改变了几千年以来人们的生活，不仅仅是生活物资的丰富，还有精神层次的丰富。在互联网诞生之前，地域位置往往是人们思想上不可跨域的鸿沟，信息的传播速度极慢，信息处理的速…
阅读更多...
【算法-程序的灵魂#谭浩强配套】（适合专升本、考研）

【算法-程序的灵魂#谭浩强配套】（适合专升本、考研）

无偿分享学习资料，需要的小伙伴评论区或私信dd。。。 无偿分享学习资料，需要的小伙伴评论区或私信dd。。。 无偿分享学习资料，需要的小伙伴评论区或私信dd。。。 完整资料如下： 1.一个程序主要包括以下两方面信息：程…
阅读更多...
Pikachu 靶场 RCE 通关解析

Pikachu 靶场 RCE 通关解析

前言 Pikachu靶场是一种常见的网络安全训练平台，用于模拟真实世界中的网络攻击和防御场景。它提供了一系列的实验室环境，供安全专业人士、学生和爱好者练习和测试他们的技能。 Pikachu靶场的目的是帮助用户了解和掌握网络攻击的原理和技术，…
阅读更多...
DI-engine强化学习入门（七）如何自定义神经网络模型

DI-engine强化学习入门（七）如何自定义神经网络模型

在强化学习中,需要根据决策问题和策略选择合适的神经网络。DI-engine中,神经网络模型可以通过两种方式指定: 使用配置文件中的cfg.policy.model自动生成默认模型。这种方式下,可以在配置文件中指定神经网络的类型(MLP、CNN等)以及超参数(隐层大小、激活函数等),DI-engine会根据…
阅读更多...
RuvarOA协同办公平台 多处 SQL注入漏洞复现

RuvarOA协同办公平台 多处 SQL注入漏洞复现

0x01 产品简介 RuvarOA办公自动化系统是广州市璐华计算机科技有限公司采用组件技术和Web技术相结合，基于Windows平台，构建在大型关系数据库管理系统基础上的，以行政办公为核心，以集成融通业务办公为目标，将网络与无线通讯等信息技术完美结合在一起设计而成的新型办公自动…
阅读更多...
el-checkbox选中后的值为id，组件显示为label中文

el-checkbox选中后的值为id，组件显示为label中文

直接上代码 方法一 <el-checkbox v-for"item in list" :key"item.id" :label"item.id">{{中文}} </el-checkbox> 方法二 <el-checkbox-group class"flex_check" v-model"rkStatusList" v-for"item…
阅读更多...
续篇——源码部署LAMP环境上线项目——禅道项目

续篇——源码部署LAMP环境上线项目——禅道项目

上篇:LNMP环境部署WordPress——使用源码包安装方式部署环境-CSDN博客 目录 一.前提准备 1. 名词区别 2. 下载项目软件包 3. 上传项目源码到虚拟机并解压 二.安装Apache 1. 环境清理 2.关闭Nginx 3. 下载Apache 4. 下载APR组件 4.1 安装apr 4.2 安装apr-util组件 5…
阅读更多...
Kotlin: ‘return‘ is not allowed here

Kotlin: ‘return‘ is not allowed here

报错&#xff1a;以下函数的内部函数return语句报错 Kotlin: return is not allowed here fun testReturn(summary: (String) -> String): String {var msg summary("summary收到参数")println("test内部调用参数&#xff1a;>结果是 &#xff1a;${msg…
阅读更多...
数据分享—全国分省河流水系

数据分享—全国分省河流水系

河流水系数据是日常研究中必备的数据之一&#xff0c;本期推文主要分享全国分省份的水系和河流数据&#xff0c;梧桐君会不定期的更新数据&#xff0c;欢迎长期订阅。 数据预览 山东省河流水系 吉林省河流水系 四川省河流水系 数据获取方式 链接&#xff1a;https://pan.baidu.…
阅读更多...
永久免费的多域名通配符SSL证书申请流程

永久免费的多域名通配符SSL证书申请流程

如果拥有多个域名&#xff0c;且有部分域名拥有子域名&#xff0c;那么多域名通配符证书是非常合适的选择。预算有限或者前期测试可以考虑免费版本的&#xff0c;国产证书厂商JoySSL则提供免费的多域名通配符证书 。 具体流程如下 1创建管理账号 登录JoySSL官网&#xff0c;创…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023