备战2022春招-java-day12

心潮的滴滴

已于 2022-02-18 13:25:29 修改

阅读量335

点赞数

分类专栏：并发 java 文章标签： java java-ee 开发语言

于 2022-02-16 16:46:58 首次发布

本文链接：https://blog.csdn.net/qq_42582773/article/details/122965678

版权

java 同时被 2 个专栏收录

69 篇文章 3 订阅

订阅专栏

并发

9 篇文章 0 订阅

订阅专栏

本文深入探讨了Java并发编程中的可重入锁（ReentrantLock）、隐式锁（synchronized）和显式锁的实现机制，并通过示例代码展示了它们的工作原理。同时，文章还介绍了LockSupport工具类，它是线程等待唤醒机制的加强版，用于阻塞和唤醒线程的操作。通过对LockSupport的park()和unpark()方法的使用，展示了如何控制线程的执行流程。

摘要由CSDN通过智能技术生成

                    
                        
                    
                    java 
可重入锁？
 又名递归锁。是指在同一个线程在外层方法获取锁的时候，再进入该线程的内层方法会自动获取锁（前提，锁对象是同一个对象），不会因为之前已经获取过还没释放而阻塞。（优点是可一定程度上避免死锁） 
  隐式锁（即synchronized关键字使用的锁）。
 ①同步代码块
 public class ReEnterLockDemo {

    static Object objectLock = new Object();

    public static void m1() {
        new Thread(() -> {
            synchronized (objectLock) {
                System.out.println(Thread.currentThread().getName() + "\t" + "外层调用");
                synchronized (objectLock) {
                    System.out.println(Thread.currentThread().getName() + "\t" + "中层调用");
                    synchronized (objectLock) {
                        System.out.println(Thread.currentThread().getName() + "\t" + "内层调用");
                    }
                }
            }
        }).start();
    }

    public static void main(String[] args) {
        m1();
    }
}
 ②同步方法public class ReEnterLockDemo2 {

    public static synchronized void m1() {
        System.out.println(Thread.currentThread().getName() + "外层调用");
        m2();
    }

    public static synchronized void m2() {
        System.out.println(Thread.currentThread().getName() + "中层调用");
        m3();
    }

    public static synchronized void m3() {
        System.out.println(Thread.currentThread().getName() + "内层调用");
    }

    public static void main(String[] args) {
        m1();
    }
}
 
  实现机理。
显式锁（即Lock）。lock和unlock必须要匹配，否则会出问题,例如，其它的线程无法获得锁，一直在等待
 public static void main(String[] args) {
    Lock lock = new ReentrantLock();

    new Thread(() -> {
        lock.lock();
        lock.lock();
        try {
            System.out.println(Thread.currentThread().getName() + "\t----外层调用");
            lock.lock();
            try {
                System.out.println(Thread.currentThread().getName() + "\t----中层调用");
            } finally {
                lock.unlock();
                lock.unlock();
            }
        } finally {
            lock.unlock();
        }
    }, "t1").start();

    new Thread(() -> {
        lock.lock();
        try {
            System.out.println(Thread.currentThread().getName() + "\t----开始调用");
        } finally {
            lock.unlock();
        }
    }, "t2").start();

}
 以上这样，两个线程t1和t2都获得锁，但是如果我们在t1线程中去掉一个unlock，导致加锁和减锁次数不匹配，那么t2线程会死锁。public static void main(String[] args) {
    Lock lock = new ReentrantLock();

    new Thread(() -> {
        lock.lock();
        lock.lock();
        try {
            System.out.println(Thread.currentThread().getName() + "\t----外层调用");
            lock.lock();
            try {
                System.out.println(Thread.currentThread().getName() + "\t----中层调用");
            } finally {
                lock.unlock();
            }
        } finally {
            lock.unlock();
        }
    }, "t1").start();

    new Thread(() -> {
        lock.lock();
        try {
            System.out.println(Thread.currentThread().getName() + "\t----开始调用");
        } finally {
            lock.unlock();
        }
    }, "t2").start();

}
 
LockSupport? 
  是什么？线程等待唤醒机制（wait/notify）的改良加强版。LockSupport类使用了一种名为Permit（许可）的概念来做到阻塞和唤醒线程的功能，每个线程都有一个许可（permit），permit只有两个值1和0，默认是0。可以把许可看成是一种（0，1）信号量（Semaphore），但与Semaphore不同的是，许可的累加上限是1。
能干嘛？ 
    park(): 阻塞线程（等待）
unpark(): 解除阻塞线程（唤醒）。
线程阻塞需要消耗凭证（permit），这个凭证最多只有1个
当调用park方法时 
      如果有凭证，则会直接消耗掉这个凭证然后正常退出；
如果无凭证，就必须阻塞等待凭证可用；
 
而unpark则相反，它会增加一个凭证，但凭证最多只能有1个，累加无效
 
去哪下？
怎么玩？
 public class LockSupportDemo {
    public static void main(String[] args) throws InterruptedException {
        Thread a = new Thread(() -> {
            System.out.println(Thread.currentThread().getName() + "\t-----come in");
            LockSupport.park(); // a线程阻塞，等待被唤醒
            System.out.println(Thread.currentThread().getName() + "\t-----被唤醒");
        }, "a");
        a.start();

        TimeUnit.SECONDS.sleep(3L);

        Thread b = new Thread(() -> {
            LockSupport.unpark(a);// 唤醒阻塞的线程a，调用多次unpark（）不能解除
            System.out.println(Thread.currentThread().getName() + "\t-----通知了");
        }, "b");
        b.start();
    }
}
 运行结果：
 

                