JUC学习之Lock同步锁

最新推荐文章于 2023-06-28 15:43:15 发布

木木_亭

最新推荐文章于 2023-06-28 15:43:15 发布

阅读量330

点赞数

分类专栏： JUC 文章标签： JUC 同步锁 Lock 显式锁

本文链接：https://blog.youkuaiyun.com/dyt443733328/article/details/80001633

版权

JUC 专栏收录该内容

13 篇文章

订阅专栏

本文探讨了Java并发编程中解决线程安全的三种方式，重点介绍了JDK 1.5引入的Lock接口，作为synchronized的补充。Lock提供了更灵活的同步控制，但需要手动解锁，否则可能导致严重后果。文章通过代码示例对比了加锁与不加锁的运行结果，并总结了synchronized与Lock的主要区别，包括异常处理、响应中断、锁状态检测和性能差异。最后指出在实际应用中应根据需求选择合适的同步机制。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

本文为看视频学习笔记，若有错误请指正！

解决线程安全问题的方式一共有3种
1.同步代码块
2.同步方法
3.同步锁Lock

其中第1,2种方式是jdk1.5之前就已经提供了的，使用的时候我们需要加上synchronized关键字，是一个隐式锁，而同步锁Lock是jdk1.5的concurrent包提供的，是一个显示锁，需要通过lock（）方法上锁，必须通过unlock()释放锁，像这样

相较于synchronized关键字，lock是一种更加灵活的方式，但是使用lock也是有一定风险的，如果没有手动的unlock()释放锁，会造成很严重的后果。

用一段简单的代码来演示不加锁程序运行的结果和加了lock之后的结果

public class TestLock {

    public static void main (String[] args){
        Ticket ticket = new Ticket();
        new Thread(ticket,"1号窗口").start();
        new Thread(ticket,"2号窗口").start();
        new Thread(ticket,"3号窗口").start();
    }

}

class Ticket implements Runnable{

    private int ticket = 100;

    @Override
    public void run() {
        while(ticket>0){
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"售出一张票，余票为"+ --ticket);

        }
    }
}

运行结果：

像图中框出来的内容一样，不加锁的时候，会出现相同的余票，甚至会出现余票为-1的情况，下面对代码进行修改

public class TestLock {

    public static void main (String[] args){
        Ticket ticket = new Ticket();
        new Thread(ticket,"1号窗口").start();
        new Thread(ticket,"2号窗口").start();
        new Thread(ticket,"3号窗口").start();
    }

}

class Ticket implements Runnable{

    private int ticket = 100;

    private Lock lock = new ReentrantLock();

    @Override
    public void run() {
        while(true){
            lock.lock();
            try {
                if(ticket > 0){
                    try {
                        Thread.sleep(200);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName()+"售出一张票，余票为"+ --ticket);
                }
            }finally {
                lock.unlock();
            }
        }
    }
}

为了让lock.unlock()一定会执行，我写在了finally里面，运行的结果：

这样就没有出现上张图的情况了

通过百度，获取了synchronized和lock更加详细的区别：

1.Lock是一个接口，而synchronized是内置的语言实现，synchronized是在JVM层面上实现的，不但可以通过一些监控工具监控synchronized的锁定，而且在代码执行时出现异常，JVM会自动释放锁定，但是使用Lock则不行，lock是通过代码实现的，要保证锁定一定会被释放，就必须将 unLock()放到finally{} 中；

2.synchronized在发生异常时，会自动释放线程占有的锁，因此不会导致死锁现象发生；而Lock在发生异常时，如果没有主动通过unLock()去释放锁，则很可能造成死锁现象，因此使用Lock时需要在finally块中释放锁；

3.Lock可以让等待锁的线程响应中断，线程可以中断去干别的事务，而synchronized却不行，使用synchronized时，等待的线程会一直等待下去，不能够响应中断；

4.通过Lock可以知道有没有成功获取锁，而synchronized却无法办到。

5.Lock可以提高多个线程进行读操作的效率。

在性能上来说，如果竞争资源不激烈，两者的性能是差不多的，而当竞争资源非常激烈时（即有大量线程同时竞争），此时Lock的性能要远远优于synchronized。所以说，在具体使用时要根据适当情况选择。