【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方法会释放锁lock
                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-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的许可证数量为1
            LockSupport.unpark(t1); //再次为t1线程发放许可证，但是一个线程只允许拥有一张许可证，所以t1的许可证数量还是1
            System.out.println(Thread.currentThread().getName()+"\t -----发出通知");
        },"t2").start();
    }
}

image-20240508223920718

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

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

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

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

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

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

1057: 有向图的出度计算

1057: 有向图的出度计算

解法&#xff1a; #include<iostream> using namespace std; int arr[100][100]; int main() {int vertex, edge;cin >> vertex >> edge;int i, j;while (edge--) {cin >> i >> j;arr[i][j] 1;}for (int i 0; i < vertex; i) {int sum 0;…
阅读更多...
乡村振兴与乡村环境综合整治：加强农村环境保护，开展农村环境综合整治行动，提升乡村环境质量，打造生态宜居的美丽乡村

乡村振兴与乡村环境综合整治：加强农村环境保护，开展农村环境综合整治行动，提升乡村环境质量，打造生态宜居的美丽乡村

目录 一、引言 二、乡村振兴背景下的乡村环境现状 1、乡村环境面临的挑战 2、乡村环境问题的成因 三、加强农村环境保护的重要性 1、促进乡村振兴 2、保障生态安全 3、提升居民生活质量 四、开展农村环境综合整治行动的策略 1、制定科学规划 2、加大投入力度 3、强…
阅读更多...
在iPad中进行截图的两种方法，总有一种适合你

在iPad中进行截图的两种方法，总有一种适合你

在iPad上截屏就像在iPhone设备上同时按下两个按钮一样简单，或者你可以使用另一种屏幕方法。以下是操作方法。 什么是屏幕截图 屏幕截图是对设备屏幕上内容的直接捕捉。使用屏幕截图，你可以捕捉你所看到的内容，然后将其保存以备日后使用或与他人共享，而无需使用相机拍摄设…
阅读更多...
ICode国际青少年编程竞赛- Python-4级训练场-复杂嵌套for循环

ICode国际青少年编程竞赛- Python-4级训练场-复杂嵌套for循环

ICode国际青少年编程竞赛- Python-4级训练场-复杂嵌套for循环 1、 for i in range(4):Dev.step(i6)for j in range(3):Dev.turnLeft()Dev.step(2)2、 for i in range(4):Dev.step(i3)for j in range(4):Dev.step(2)Dev.turnRight()Dev.step(-i-3)Dev.turnRight()3、 for i …
阅读更多...
AI换脸原理(7)——人脸分割参考文献TernausNet: 源码解析

AI换脸原理(7)——人脸分割参考文献TernausNet: 源码解析

1、介绍 这篇论文相对来说比较简单，整体是通过使用预训练的权重来提高U-Net的性能，实现对UNet的改进。该方法也是DeepFaceLab官方使用的人脸分割方法。在介绍篇我们已经讲过了UNet的网络结构和设计，在进一步深入了解TernausNet之前，我们先简单回顾下UNet。 U-Net的主要结构…
阅读更多...
趣味软件-吃什么（Eat What）？

趣味软件-吃什么（Eat What）？

&#x1f354;&#x1f35c;&#x1f355; 你是否也有这样的日常烦恼&#xff1f; 每天的“世纪难题”——今天吃什么&#xff1f; &#x1f570;️ 饭点到了&#xff0c;脑袋空空&#xff0c;选择困难症大爆发&#xff01; &#x1f46b; 和女朋友约会&#xff0c;却不知道她的…
阅读更多...
nss刷题（2）

nss刷题（2）

1、[NSSCTF 2022 Spring Recruit]ezgame 打开题目是一个游戏界面 发现是有分数的&#xff0c;猜测分数达到某个之后可以获得flag&#xff0c;查看源码看一下 看到末尾显示分数超过65后显示flag 在js中找到了一个score,将他的值改为大于65的数后随意玩一次就可以得到flag同时&a…
阅读更多...
WHAT - CSS Animationtion 动画系列（二）

WHAT - CSS Animationtion 动画系列（二）

目录 一、循环波浪二、关键帧呼应三、关键帧顺接四、利用 transform-origin 做拉伸五、大元素可拆分多个小元素联动六、预留视觉缓冲七、随机感&#xff1a;动画周期设置八、抛物线&#xff1a;两个内外div实现x和y向量运动 今天我们主要学习动画实现要素。 一、循环波浪 利用…
阅读更多...
Nginx（简洁版）

Nginx（简洁版）

基本配置 worker_processes 1; //默认为1&#xff0c;表示开启一个业务进程 events //事件驱动模块&#xff08;&#xff09;{worker_connections 1024; //单个业务进程可接受连接数 } http{include mime.types; // 引入http mime类型&#xff08;在外部已经定义好&#xff0c…
阅读更多...
《视觉十四讲》例程运行记录（6）——运行ch9后端优化CeresBA和g2o求解BA的实践例程

《视觉十四讲》例程运行记录（6）——运行ch9后端优化CeresBA和g2o求解BA的实践例程

提示&#xff1a;文章写完后&#xff0c;目录可以自动生成&#xff0c;如何生成可参考右边的帮助文档 文章目录 一、运行ch9的例程代码1. MeshLab安装2. 编译例程代码前的修改3. 编译例程 一、运行ch9的例程代码 1. MeshLab安装 (1) 软件中心安装 搜索&#xff1a;MeshLab&am…
阅读更多...
HCIP的学习（14）

HCIP的学习（14）

过滤策略—filter-policy ​ 思科中&#xff1a;分发列表 ​ 过滤策略是只能够针对于路由信息进行筛选&#xff08;过滤&#xff09;的工具&#xff0c;而无法针对于LSA进行过滤。 在R4的出方向上配置过滤策略&#xff0c;使得R1不能学习到23.0.0.0/24路由信息1、抓取流量 […
阅读更多...
CSS学习笔记之基础教程（二）

CSS学习笔记之基础教程（二）

上节内容CSS学习笔记之基础教程&#xff08;一&#xff09; 6、边距 6.1 外边距&#xff1a;margin 6.1.1 外边距 marginmargin-topmargin-leftmargin-bottommargin-right <!DOCTYPE html> <html lang"en"> <head><meta charset"UTF-8…
阅读更多...
单链表经典算法LeetCode--203.移除链表元素（两种方法解）

单链表经典算法LeetCode--203.移除链表元素（两种方法解）

1.链接&#xff1a;. - 力扣&#xff08;LeetCode&#xff09;【点击即可跳转】 分析此题提供两种思路&#xff1a; 1.遍历原链表&#xff0c;将值为val的节点释放掉&#xff08;双指针法&#xff09; 定义一个pcur指针指向头节点&#xff0c;定义一个prev指针指向NULL 需要注…
阅读更多...
内存操作数及寻址方式

内存操作数及寻址方式

debug命令 debug命令&#xff0c;即DOS实用程序。DEBUG是一个DOS实用程序&#xff0c;是供程序员使用的程序调试工具&#xff0c;可以用它检查内存中任何地方的字节以及修改任何地方的字节。它可以用于逐指令执行某个程序以验证程序运行的正确性&#xff0c;也可以追踪执行过程…
阅读更多...
数据分享—全国分省河流水系

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

河流水系数据是日常研究中必备的数据之一&#xff0c;本期推文主要分享全国分省份的水系和河流数据&#xff0c;梧桐君会不定期的更新数据&#xff0c;欢迎长期订阅。 数据预览 山东省河流水系 吉林省河流水系 四川省河流水系 数据获取方式 链接&#xff1a;https://pan.baidu.…
阅读更多...
值得用来替代Vector的Java集合：ArrayBlockingQueue详解

值得用来替代Vector的Java集合：ArrayBlockingQueue详解

哈喽&#xff0c;各位小伙伴们&#xff0c;你们好呀&#xff0c;我是喵手。运营社区&#xff1a;C站/掘金/腾讯云&#xff1b;欢迎大家常来逛逛 今天我要给大家分享一些自己日常学习到的一些知识点&#xff0c;并以文字的形式跟大家一起交流&#xff0c;互相学习&#xff0c;一…
阅读更多...
C++ vs Rust vs Go 性能比较

C++ vs Rust vs Go 性能比较

本文对C、Rust和Go三种编程语言编写的gunzip程序进行了性能比较&#xff0c;通过基准测试试图尽可能公平的比较它们的性能。原文: Performance — C vs Rust vs Go 本文将通过一些基准测试&#xff0c;比较 C 和 Rust 以及 Go 编写的相同程序的性能。我们将尽最大努力将语言差异…
阅读更多...
十三、Redis哨兵模式--Sentinel

十三、Redis哨兵模式--Sentinel

上一篇介绍了Redis中的主从复制。我们知道Redis主从中一般只有主节点对外提供写操作&#xff0c;如果主节点发生故障&#xff0c;为了保证Redis的可用性&#xff0c;这时就要在可用的slave节点中&#xff0c;挑选一个作为主节点。这种切换操作如果是人为的操作&#xff0c;那么…
阅读更多...
5分钟了解下HDFS

5分钟了解下HDFS

随着大数据时代的到来&#xff0c;传统的数据存储和管理方式已经无法满足日益增长的数据处理需求。HDFS&#xff08;Hadoop Distributed File System&#xff09;作为Apache Hadoop项目的一部分&#xff0c;以其高度的容错性、可扩展性和高吞吐量&#xff0c;成为了处理大规模数…
阅读更多...
音视频开发6 音视频录制原理和播放原理

音视频开发6 音视频录制原理和播放原理

音视频录制原理 音视频播放原理
阅读更多...
最新文章

Copyright @ 2022~2023