[Java学习笔记]并发编程——Lock的使用

最新推荐文章于 2023-10-28 11:29:35 发布
最新推荐文章于 2023-10-28 11:29:35 发布
阅读量309 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： Java基础 文章标签： JavaSE
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/weixin_42627594/article/details/96175959
本文对比分析了Java中Synchronized与Lock两种线程同步机制的特点与应用场景，详细介绍了Lock的各种方法及其优缺点。

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

Synchronized\Lock的比较

初学Java多线程编程我们发现除了关键字Synchronized以外，还有各种各样的Lock类型，那么我们就会想：既然已经有了Synchronized这个关键字帮助我们实现线程同步，管理资源的有序和谐访问，那么Lock又有什么存在的必要呢？

为此我们需要了解Synchronized的缺陷：

  • 我们知道在Synchronized同步机制下，获取锁的线程释放锁只会有两种情况：
    1）获取锁的线程执行完了该代码块，然后线程释放对锁的占有；
    2）线程执行发生异常，此时JVM会让线程自动释放锁。
    那么如果这个获取锁的线程由于要等待IO或者其他原因（比如调用sleep方法）被阻塞了，但是又没有释放锁，其他线程便只能干巴巴地等待，这样一来效率低下
    比如我们在Synchronized同步下多个线程读取同一个文件，那么每个线程只能等另个线程读完了才有机会读取，而不使用同步机制，在线程异步下写的操作必然会发生读写混乱
  • 采用synchronized不需要用户去手动释放锁，当synchronized方法或者synchronized代码块执行完之后，系统会自动让线程释放对锁的占用；而Lock则必须要用户去手动释放锁，如果没有主动释放锁，就有可能导致出现死锁现象
  • Lock不是Java语言内置的，synchronized是Java语言的关键字，因此是内置特性。Lock是一个类，通过这个类可以实现同步访问，用户可以自由释放锁、查询锁的状态；

Lock接口

Lock，通过查看Lock的源码可知，Lock是一个接口：

它包括3种获取锁的方法lock、tryLock、lockInterruptibly

public interface Lock {
    void lock();
    void lockInterruptibly() throws InterruptedException;
    boolean tryLock();
    boolean tryLock(long time, TimeUnit unit) throws InterruptedException;
    void unlock();
    Condition newCondition();
}

lock()方法:

  • 首先lock()方法是平常使用得最多的一个方法，就是用来获取锁。如果锁已被其他线程获取，则进行等待。
    由于在前面讲到如果采用Lock，必须主动去释放锁，并且在发生异常时，不会自动释放锁。因此一般来说，使用Lock必须借助try{}catch{}块中进行，Lock.lock()方法推荐放在try外（介于在获取出现异常的情况下不直接释放锁）并且将释放锁的操作放在finally块中进行，以保证锁一定被被释放，防止死锁的发生。通常使用Lock来进行同步的话，是以下面这种形式去使用的：

Lock的正确使用：

public class Test {
	Lock lock = new ReentrantLock();   
    public static void main(String[] args)  {
        final Test test = new Test();
         
        new Thread(){
            public void run() {
                test.insert(Thread.currentThread());
            };
        }.start();
         
        new Thread(){
            public void run() {
                test.insert(Thread.currentThread());
            };
        }.start();
    }  
     
    public void insert(Thread thread) {
        lock.lock();
        try {
            System.out.println(thread.getName()+"得到了锁");
            for(int i=0;i<50;i++) {
            }
        } catch (Exception e) {
            // TODO: handle exception
        }finally {
            System.out.println(thread.getName()+"释放了锁");
            lock.unlock();
        }
    }
}

结果：
Thread-0得到了锁
Thread-1得到了锁
Thread-0释放了锁
Thread-1释放了锁

tryLock()方法:

  • tryLock(): 是有返回值的，它表示用来尝试获取锁，如果获取成功，则返回true，如果获取失败（即锁已被其他线程获取），则返回false，也就说这个方法无论如何都会立即返回。在拿不到锁时不会一直在那等待。
    tryLock(long time, TimeUnit unit)方法和tryLock()方法是类似的，只不过区别在于这个方法在拿不到锁时会等待一定的时间，在时间期限之内如果还拿不到锁，就返回false。如果如果一开始拿到锁或者在等待期间内拿到了锁，则返回true。
public class Test {
    private ArrayList<Integer> arrayList = new ArrayList<Integer>();
    private Lock lock = new ReentrantLock();    //注意这个地方
    public static void main(String[] args)  {
        final Test test = new Test();
         
        new Thread(){
            public void run() {
                test.insert(Thread.currentThread());
            };
        }.start();
         
        new Thread(){
            public void run() {
                test.insert(Thread.currentThread());
            };
        }.start();
    }  
     
    public void insert(Thread thread) {
        if(lock.tryLock()) {
            try {
                System.out.println(thread.getName()+"得到了锁");
                for(int i=0;i<5;i++) {
                    arrayList.add(i);
                }
            } catch (Exception e) {
                // TODO: handle exception
            }finally {
                System.out.println(thread.getName()+"释放了锁");
                lock.unlock();
            }
        } else {
            System.out.println(thread.getName()+"获取锁失败");
        }
    }
}

输出结果：
Thread-0得到了锁
Thread-1获取锁失败
Thread-0释放了锁

lockInterruptibly()方法
-一般的情况下一个线程获取到了锁，其他线程虽然被等待阻塞，但这个等待状态是不允许被清除的，lockInterruptibly()方法比较特殊，当通过这个方法去获取锁时，锁被其他线程占用，该线程正在等待获取锁，则这个线程能够响应中断，即允许中断的等待状态。也就使说，当两个线程同时通过lock.lockInterruptibly()想获取某个锁时，若此时线程A获取到了锁，而线程B是通过lockInterruptibly()等待获取锁，那么此时对线程B调用threadB.interrupt()方法可以中断线程B的等待过程。

  • 由于lockInterruptibly()的声明中抛出了异常，所以lock.lockInterruptibly()必须放在try块中或者在调用lockInterruptibly()的方法外声明抛出InterruptedException。

我们先看看传统的lock方法获取后能不能中断等待线程呢？

public class Test {
    private Lock lock = new ReentrantLock();   
    public static void main(String[] args)  {
        Test test = new Test();
        MyThread thread1 = new MyThread(test);
        MyThread thread2 = new MyThread(test);
        thread1.start();
        thread2.start();
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        thread2.interrupt();
    }  
     
    public void insert(Thread thread) throws InterruptedException{
        lock.lock();   
        try {  
            System.out.println(thread.getName()+"得到了锁");
            long startTime = System.currentTimeMillis();
            while(true) {
                if(System.currentTimeMillis() - startTime >= 5000)
                    break;
            }
        }
        finally {
            System.out.println(Thread.currentThread().getName()+"执行finally");
            lock.unlock();
            System.out.println(thread.getName()+"释放了锁");
        }  
    }
}
 
class MyThread extends Thread {
    private Test test = null;
    public MyThread(Test test) {
        this.test = test;
    }
    @Override
    public void run() {
        try {
            test.insert(Thread.currentThread());
        } catch (InterruptedException e) {
            System.out.println(Thread.currentThread().getName()+"被中断");
        }
    }
}

显然我们从运行结果就能发现：Thread2并没有被成功中断

Thread-0得到了锁
Thread-0执行finally
Thread-0释放了锁
Thread-1得到了锁
Thread-1执行finally
Thread-1释放了锁

public class Test {
    private Lock lock = new ReentrantLock();   
    public static void main(String[] args)  {
        Test test = new Test();
        MyThread thread1 = new MyThread(test);
        MyThread thread2 = new MyThread(test);
        thread1.start();
        thread2.start();
         
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        thread2.interrupt();
    }  
     
    public void insert(Thread thread) throws InterruptedException{
        lock.lockInterruptibly();   //注意，如果需要正确中断等待锁的线程，必须将获取锁放在外面，然后将InterruptedException抛出
        try {  
            System.out.println(thread.getName()+"得到了锁");
            long startTime = System.currentTimeMillis();
            while(true) {
                if(System.currentTimeMillis() - startTime >= 5000)
                    break;
            }
        }
        finally {
            System.out.println(Thread.currentThread().getName()+"执行finally");
            lock.unlock();
            System.out.println(thread.getName()+"释放了锁");
        }  
    }
}
 
class MyThread extends Thread {
    private Test test = null;
    public MyThread(Test test) {
        this.test = test;
    }
    @Override
    public void run() {
         
        try {
            test.insert(Thread.currentThread());
        } catch (InterruptedException e) {
            System.out.println(Thread.currentThread().getName()+"被中断");
        }
    }
}

我们发现通过lockInterruptibly()方法，确实能允许此时等待的线程Thread2被中断

Thread-0得到了锁
Thread-1被中断
Thread-0执行finally
Thread-0释放了锁

ReadWriteLock

ReadWriteLock也是一个接口，在它里面只定义了两个方法：

public interface ReadWriteLock {
    /**
     * Returns the lock used for reading.
     */
    Lock readLock();
 
    /**
     * Returns the lock used for writing.
     */
    Lock writeLock();
}

一个用来获取读锁，一个用来获取写锁。也就是说将文件的读写操作分开，分成2个锁来分配给线程，从而使得多个线程可以同时进行读操作

我们先来看看传统synchronized下多线程同时读的情况

public class Test {
    //private ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();
     
    public static void main(String[] args)  {
        final Test test = new Test();
         
        new Thread(){
            public void run() {
                test.get(Thread.currentThread());
            };
        }.start();
         
        new Thread(){
            public void run() {
                test.get(Thread.currentThread());
            };
        }.start();
         
    }  
     
    public synchronized void get(Thread thread) {
        long start = System.currentTimeMillis();
        while(System.currentTimeMillis() - start <= 1) {
            System.out.println(thread.getName()+"正在进行读操作");
        }
        System.out.println(thread.getName()+"读操作完毕");
    }
}

这段程序的输出结果会是，直到thread1执行完读操作之后，才会打印thread2执行读操作的信息。

Thread-0正在进行读操作
Thread-0正在进行读操作
Thread-0正在进行读操作
Thread-0正在进行读操作
Thread-0正在进行读操作
Thread-0正在进行读操作
Thread-0正在进行读操作
Thread-0正在进行读操作
Thread-0正在进行读操作
Thread-0正在进行读操作
Thread-0正在进行读操作
Thread-0正在进行读操作
Thread-0正在进行读操作
Thread-0正在进行读操作
Thread-0正在进行读操作
Thread-0正在进行读操作
Thread-0正在进行读操作
Thread-0正在进行读操作
Thread-0正在进行读操作
Thread-0正在进行读操作
Thread-0正在进行读操作
Thread-0正在进行读操作
Thread-0正在进行读操作
Thread-0正在进行读操作
Thread-0正在进行读操作
Thread-0正在进行读操作
Thread-0正在进行读操作
Thread-0正在进行读操作
Thread-0读操作完毕
Thread-1正在进行读操作
Thread-1正在进行读操作
Thread-1正在进行读操作
Thread-1正在进行读操作
Thread-1正在进行读操作
Thread-1正在进行读操作
Thread-1正在进行读操作
Thread-1正在进行读操作
Thread-1正在进行读操作
Thread-1正在进行读操作
Thread-1正在进行读操作
Thread-1正在进行读操作
Thread-1正在进行读操作
Thread-1正在进行读操作
Thread-1正在进行读操作
Thread-1正在进行读操作
Thread-1正在进行读操作
Thread-1正在进行读操作
Thread-1正在进行读操作
Thread-1正在进行读操作
Thread-1正在进行读操作
Thread-1正在进行读操作
Thread-1正在进行读操作
Thread-1正在进行读操作
Thread-1正在进行读操作
Thread-1正在进行读操作
Thread-1正在进行读操作
Thread-1正在进行读操作
Thread-1正在进行读操作
Thread-1正在进行读操作
Thread-1正在进行读操作
Thread-1正在进行读操作
Thread-1正在进行读操作
Thread-1正在进行读操作
Thread-1正在进行读操作
Thread-1正在进行读操作
Thread-1正在进行读操作
Thread-1正在进行读操作
Thread-1正在进行读操作
Thread-1正在进行读操作
Thread-1正在进行读操作
Thread-1正在进行读操作
Thread-1正在进行读操作
Thread-1读操作完毕

改成用读写锁进行多线程读取的话：

public class Test {
    private ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();
     
    public static void main(String[] args)  {
        final Test test = new Test();
         
        new Thread(){
            public void run() {
                test.get(Thread.currentThread());
            };
        }.start();
         
        new Thread(){
            public void run() {
                test.get(Thread.currentThread());
            };
        }.start();
         
    }  
     
    public void get(Thread thread) {
        rwl.readLock().lock();
        try {
            long start = System.currentTimeMillis();
             
            while(System.currentTimeMillis() - start <= 1) {
                System.out.println(thread.getName()+"正在进行读操作");
            }
            System.out.println(thread.getName()+"读操作完毕");
        } finally {
            rwl.readLock().unlock();
        }
    }
}

Thread-0正在进行读操作
Thread-0正在进行读操作
Thread-1正在进行读操作
Thread-0正在进行读操作
Thread-1正在进行读操作
Thread-0正在进行读操作
Thread-1正在进行读操作
Thread-1正在进行读操作
Thread-1正在进行读操作
Thread-1正在进行读操作
Thread-1正在进行读操作
Thread-1正在进行读操作
Thread-0正在进行读操作
Thread-0正在进行读操作
Thread-0正在进行读操作
Thread-0正在进行读操作
Thread-1正在进行读操作
Thread-1正在进行读操作
Thread-1正在进行读操作
Thread-1正在进行读操作
Thread-0正在进行读操作
Thread-1正在进行读操作
Thread-1正在进行读操作
Thread-0正在进行读操作
Thread-1正在进行读操作
Thread-1正在进行读操作
Thread-0正在进行读操作
Thread-1正在进行读操作
Thread-1正在进行读操作
Thread-1正在进行读操作
Thread-0正在进行读操作
Thread-1正在进行读操作
Thread-1正在进行读操作
Thread-0正在进行读操作
Thread-1正在进行读操作
Thread-0正在进行读操作
Thread-1正在进行读操作
Thread-0正在进行读操作
Thread-1正在进行读操作
Thread-0正在进行读操作
Thread-1正在进行读操作
Thread-0正在进行读操作
Thread-1正在进行读操作
Thread-0正在进行读操作
Thread-1正在进行读操作
Thread-0正在进行读操作
Thread-1正在进行读操作
Thread-0读操作完毕
Thread-1读操作完毕

说明thread1和thread2在同时进行读操作。

这样就大大提升了读操作的效率。

不过要注意的是，如果有一个线程已经占用了读锁，则此时其他线程如果要申请写锁，则申请写锁的线程会一直等待释放读锁。

如果有一个线程已经占用了写锁，则此时其他线程如果申请写锁或者读锁，则申请的线程会一直等待释放写锁。

Java学习笔记——并发编程（一）
l903445981的博客
07-27 412
建议学习Java并发编程前，先学习一下jvm，便于有更深刻的理解。本篇笔记主要讲述了共享存在的问题以及解决方法(阻塞式和非阻塞式)，接着讲述了阻塞式中synchronized关键字，最后讲述了线程安全分析。...
Java学习笔记——并发编程（三）
l903445981的博客
07-29 1003
obj.wait()让进入object监视器的线程到waitSet等待obj.notify()在object上正在waitSet等待的线程中挑一个唤醒obj.notifyAll()让object上正在waitSet等待的对象全部唤醒它们都是线程之间协作的手段，都属于Object对象的方法。必须获得此对象的锁，才能调用这几个方法。log.debug("执行....");try{//让线程在obj上一直等待下去}catch(InterruptedExceptione){...
TestLock
qq_30443907的博客
12-08 207
package com.fan.juc; import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; /** * 一：用于解决多线程安全问题的方式： * * synchronized：隐试锁 * * 1 同步代码块 * * 2 同步方法 * * j...
Lock接口中lock方法应该放在try-catch-finally外部
m0_51556396的博客
02-05 1101
Lock接口中lock方法与unlock方法在try-catch-finally代码块中位置的区别。
所有锁的unlock要放到try{}finally{}里，不然发生异常返回就丢了unlock了
weixin_30381317的博客
02-28 1756
所有锁的unlock要放到try{}finally{}里，不然发生异常返回就丢了unlock了 转载于:https://www.cnblogs.com/MyLifeMyWay/p/8484378.html
lock锁
m0_48273471的博客
04-01 2865
1. lock 基本用法 lock.lock(); try { } finally { lock.unlock() } 或者 try { lock.lock(); } finally { lock.unlock() } public class ThreadLock1 { public static void main(String[] args) { //1. 创建锁对象 Lock lock = new Reent...
22-08-27 西安 JUC（01）synchronized、Lock锁、LockSupport、死锁问题排查
m0_56799642的博客
08-28 483
同步成员方法，锁的是调用方法的对象。 同步静态方法，锁的是类模板对象，即当前类的Class对象。 同步方法块，锁的是小括号里的对象 ReentrantLock特点: 可重入的、可公平可不公平，可响应中断的，悲观的排他的锁，需要手动控制锁的添加、释放。使用灵活 代码层面的锁 ..............................
Java并发学习笔记（二）——Synchronized关键字与ReetrantLock同步锁
12-20
【Java并发学习笔记（二）——Synchronized关键字与ReentrantLock同步锁】 在Java多线程编程中，确保线程安全是非常重要的。Synchronized关键字和ReentrantLock是两种常见的同步机制，它们都用于保证线程的原子性、...
《Java核心技术》学习笔记——第12章 并发
a602389093的博客
12-23 617
版权声明：本文为博主ExcelMann的原创文章，未经博主允许不得转载。 第12章 并发 作者：ExcelMann，转载需注明。 第12章内容目录： 什么是线程 线程属性 线程安全的集合 异步计算 线程状态 同步 任务和线程池 进程 ...
基于《狂神说Java》JUC并发编程--学习笔记
wudidahuanggua的博客
06-15 1058
本笔记仅做学习与复习使用，不存在刻意抄袭。给各位学友强烈推荐《遇见狂神说》他的整套Java学习路线使我获益匪浅！！!点击跳转至遇见狂神说哔哩哔哩首页如果你也是狂神的小迷弟，可以加我好友一起探讨学习。 ...
为什么Lock方法在try语句外
weixin_49648855的博客
10-07 630
【代码】为什么Lock方法在try语句外。
【JUC】lock()方法为什么要放在try语句之前
最新发布
weixin_46956020的博客
10-28 610
不推荐，原因在于加锁操作可能会抛出异常，如果加锁操作在try块之前，那么出现异常时try-finally块不会执行，程序直接因为异常而中断执行；如果加锁操作在try块中，由于已经执行到了try块，那么finally在try中出现异常时仍然会执行，此时try中的加锁操作出现异常，finally依然会执行解锁操作，而此时并没有获取到锁，执行解锁操作会抛出另外一个异常，虽然都是抛出异常结束，但是。所以，加锁之后直接执行try块，不要执行predo操作。为何加锁操作需要在try之前，能否在try块中执行呢？
Java并发编程-Lock
aikuangchou2298的博客
03-11 258
一.synchronized的缺陷 synchronized是java中的一个关键字，也就是说是Java语言内置的特性。那么为什么会出现Lock呢？ 在上面一篇文章中，我们了解到如果一个代码块被synchronized修饰了，当一个线程获取了对应的锁，并执行该代码块时，其他线程便只能一直等待，等待获取锁的线程释放锁，而这里获取锁的线程释放锁只会有两种情况： 1）获取锁的线程执行完了...
分布式锁的相关知识
qq_44849756的博客
04-19 556
在redis中setnx方法：当且仅当key不存在时，set一个key为val的字符串，返回1；若key存在，则什么都不做，返回0。 synchronized是JDK形式的锁，在分布式环境下不能达到加锁的目的。此时，就需要考虑分布式锁，分布式锁主要应用于在分布式环境下，对高并发任务的处理，通过分布式锁实现并发任务串行化，从而解决加锁的目的。 其中，在构建分布式锁时，需要注意一下问题： 1.使用try...catch释放锁防止业务代码抛异常 2.使用超时时间防止系统宕机，从而保证原子性。 3.当出现
JAVA并发编程--4 理解Lock
拽着尾巴的鱼儿的博客
10-15 780
理解Lock
解决线程安全问题的方式三：Lock锁，以及为啥要放在try--finally结构中
weixin_52938172的博客
08-14 3667
今天学习了解决线程安全问题的方式三：Lock锁，我自己有以下几个疑问： 为啥锁和解锁操作要放在try--finally结构中？ 为啥锁操作lock()不能放在thy内部？ 这是正常步骤 // 1.创建锁对象 private ReentrantLock lock = new ReentrantLock(); // 2.在同步代码块前调用锁定方法lock(),获得锁 lock.lock(); try{ // 同步代码块 }finally{ //
Lock.lock()为什么在try之前执行？
E_N_T_J的博客
05-06 5855
Java类库中提供了几种用于替代synchronized的锁，比如ReentrantLock、ReentrantReadWriteLock等，使用该锁时加锁与解锁的操作必须在代码中指定执行，通常会以如下方式使用： ReentrantLock lock = new ReentrantLock(); lock.lock(); // 加锁 try{ // do something }fina...
锁与死锁
学习小窝
12-06 1222
Java多线程 进程与线程 Java线程 线程状态的切换 同步与锁 生产者与消费者模型 文章目录Java多线程前言一、Lock是什么？二、锁的demo三、读写锁Demo总结 前言 之前我们了解过同步关键字synchronized来解决多线程共享数据的问题，在JDK1.5之后Java提供了更便捷的接口Lock来解决多线程同步问题 一、Lock是什么？ Lock是一个接口,存在下图的实现类 下面简单介绍下Lock接口的方法 lock()： 获取锁 如果锁没有其他线程获取，则获取锁立即返回，将锁的保持
Lock锁及获取锁的四种方法
热门推荐
是小D吖！的博客
11-07 2万+
Lock锁
Java JDK 6学习笔记——面向初学者的完整指南
这份“Java JDK 6学习笔记——ppt简体版”可以作为初学者的参考手册，不仅涵盖了基本概念和应用，还提供了实用的开发技巧和工具介绍，对于希望掌握Java JDK 6的初学者来说是一个不可多得的学习资源。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值