Java中的Lock与synchronized

时间  2019-11-24
标签 java lock synchronized 栏目 Java 繁體版
原文   原文链接

并发编程学习笔记之Lock与synchronizedjava

1、什么是可重入锁面试

Lcok在Java中是一个接口，通常在面试问题中问到的多是ReentrantLock与synchronized的区别。ReentrantLock是Lock的一个实现类，字面意思的话就是可重入锁，那么什么是可重入锁呢。编程

可重入锁是锁的一个相关概念，并非特指咱们的ReentrantLock，而是若是一个锁具有可重入性，那咱们就说这是一个可重入锁。ReentrantLock和synchronized都是可重入锁。至于什么是可重入性，这里举个简单的例子，如今在一个类里咱们有两个方法（代码以下），一个叫作去北京，一个叫作买票，那咱们在去北京的方法里能够直接调用买票方法，假如两个方法全都用synchronized修饰的话，在执行去北京的方法，线程获取了对象的锁，接着执行买票方法，若是synchronized不具有可重入性，那么线程已经有这个对象的锁了，如今又来申请，就会致使线程永远等待没法获取到锁。而synchronized和ReentrantLock都是可重入锁，就不会出现上述的问题。并发

 1 class Trip {
 2     public synchronized void goToBeiJing() {
 3         // 去北京  
 4         buyATicket();
 5     }
 6      
 7     public synchronized void buyATicket() {
 8         // 买票
 9     }
10 }

2、Lock与synchronized的不一样jvm

两者都是可重入锁，那么为何要有两个呢？既然存在，那么就必定是有意义的。synchronized是Java中的一个关键字，而Lock是Java1.5后在java.util.concurrent.locks包下提供的一种实现同步的方法，那么显然的，synchronized必定是有什么作不到的或者缺陷，才致使了Lock的诞生。性能

1.synchronized的缺点学习

1）当一个代码块被synchronized修饰的时候，一个线程获取到了锁，而且执行代码块，那么其余的线程须要等待正在使用的线程释放掉这个锁，那么释放锁的方法只有两种，一种是代码执行完毕自动释放，一种是发生异常之后jvm会让线程去释放锁。那么若是这个正在执行的线程遇到什么问题，好比等待IO或者调用sleep方法等等被阻塞了，没法释放锁，而这时候其余线程只能一直等待，将会特别影响效率。那么有没有一种办法让其余线程没必要一直傻乎乎的等在这里吗？spa

2）当一个文件，同时被多个线程操做时，读操做和写操做会发生冲突，写操做和写操做会发生冲突，而读操做和读操做并不会冲突，可是若是咱们用synchronized的话，会致使一个线程在读的时候，其余线程想要读的话只能等待，那么有什么办法能不锁读操做吗？线程

3）在使用synchronized时，咱们没法得知线程是否成功获取到锁，那么有什么办法能知道是否获取到锁吗？code

2.java.util.concurrent.locks包

1）Lock

Lock是一个接口，源码以下

1 public interface Lock {
2     void lock();
3     void lockInterruptibly() throws InterruptedException;
4     boolean tryLock();
5     boolean tryLock(long time, TimeUnit unit) throws InterruptedException;
6     void unlock();
7     Condition newCondition();
8 }

ReentrantLock是Lock的一个实现类（另外两个实现类是ReentrantReadWriteLock类下的两个静态内部类：WriteLock和ReadLock），它的意思是可重入锁，可重入锁前面已经讲过了。ReentrantLock中提供了更多的一些方法。不过经常使用的就是Lock中的这些。

来看一下Lock接口这些方法的使用，lock()、tryLock()、tryLock(long time, TimeUnit unit)和lockInterruptibly()是用来获取锁的。unLock()方法是用来释放锁的。

这里有四个方法来获取锁，那么区别在哪里呢？

lock()使咱们平时用的最多的，最用是用来获取锁，若是锁已经被其余线程获取，那么就等待。可是采用Lock必需要主动释放锁，因此咱们通常在try{}catch{}块中处理而后在finally中释放锁，举个例子：

1 lock.lock();
2 try{
3     // 处理
4 }catch(Exception ex){
5     // 捕获异常
6 }finally{
7     // 释放锁
8     lock.unlock();   
9 }

 tryLock()是一个boolean类型的方法，当调用这个方法的时候，线程会去尝试获取锁，若是获取到的话会返回true，若是获取不到返回false，也就是说这个方法会立马返回一个结果，线程不会等待。

tryLock(long time, TimeUnit unit)是上面tryLock()方法的一个重载方法，加了两个参数，给定了等待的时间，若是在规定时间拿到锁返回true，若是拿不到返回false。这两个方法的通常用法和Lock相似。

 1 if (lock.tryLock()) {
 2     try{
 3         // 处理    
 4     }catch(Exception ex){
 5         // 捕获异常
 6     }finally{
 7         // 释放锁
 8         lock.unlock();   
 9     }
10 }

lockInterruptibly()就比较特殊了，它表示可被中断的，意思就是，当尝试获取锁的时候，若是获取不到的话就会等待，可是，在等待的过程当中它是能够响应中断的，也就是中断线程的等待过程。使用形式的话同样用try catch处理，就不贴代码了。

2）ReadWriteLock

ReadWriteLock也是一个接口，这个接口中只有两个方法，源码以下：

1 public interface ReadWriteLock {
2     Lock readLock();
3  
4     Lock writeLock();
5 }

这个接口的从字面就能看出来他的用途，读锁和写锁，这时候是否是想起了前面我写到的synchronized的第二条。

ReentrantReadWriteLock是ReadWriteLock的一个实现类，最经常使用到的也是获取读锁和获取写锁。下面看例子：

首先是使用synchronized的：

 1 public class Main {  
 2     public static void main(String[] args)  {
 3         final Main m = new Main();
 4        
 5         new Thread(){
 6             public void run() {
 7                 m.read(Thread.currentThread());
 8             };
 9         }.start();
10          
11         new Thread(){
12             public void run() {
13                 m.read(Thread.currentThread());
14             };
15         }.start(); 
16     }  
17      
18     public synchronized void read(Thread thread) {
19         long startTime = System.currentTimeMillis();
20         while(System.currentTimeMillis() - startTime <= 1) {
21             System.out.println(thread.getName()+"线程在进行读操做");
22         }
23         System.out.println(thread.getName()+"线程完成读操做");
24     }
25 }

这段代码的执行结果是在一个线程打印出完成读操做后，另外一条线程才会开始进行读操做。

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线程完成读操做

 

下面看若是用ReadWriteLock：

 1 public class Main {  
 2     public static void main(String[] args)  {
 3         private ReentrantReadWriteLock readWriteLock = new ReentrantReadWriteLock();
 4         final Main m = new Main();
 5        
 6         new Thread(){
 7             public void run() {
 8                 m.read(Thread.currentThread());
 9             };
10         }.start();
11          
12         new Thread(){
13             public void run() {
14                 m.read(Thread.currentThread());
15             };
16         }.start(); 
17     }  
18      
19     public void read(Thread thread) {
20         readWriteLock.readLock().lock();
21         try {
22         long startTime = System.currentTimeMillis();
23             while(System.currentTimeMillis() - startTime <= 1) {
24                 System.out.println(thread.getName()+"线程在进行读操做");
25             }
26             System.out.println(thread.getName()+"线程完成读操做");
27     } finally {
28         readWriteLock.unlock();
29         }
30     }
31 }

只是把以前的synchronized换成了ReadWriteLock，可是输出结果倒是两个线程在一块儿进行读操做

Thread-0线程在进行读操做
Thread-0线程在进行读操做
Thread-1线程在进行读操做
Thread-0线程在进行读操做
Thread-1线程在进行读操做
Thread-0线程在进行读操做
Thread-1线程在进行读操做
Thread-1线程在进行读操做
Thread-1线程在进行读操做
Thread-1线程在进行读操做
Thread-1线程在进行读操做
Thread-0线程在进行读操做
Thread-0线程在进行读操做
Thread-0线程在进行读操做
Thread-1线程在进行读操做
Thread-1线程在进行读操做
Thread-1线程在进行读操做
Thread-1线程在进行读操做
Thread-1线程在进行读操做
Thread-1线程在进行读操做
Thread-1线程在进行读操做
Thread-0线程在进行读操做
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线程完成读操做

这个结果能够看到两个线程同时进行读操做，效率大大的提高了。可是要注意的是，若是一个线程获取了读锁，那么另外的线程想要获取写锁则须要等待释放；而若是一个线程已经获取了写锁，则另外的线程想获取读锁或写锁都须要等待写锁被释放。

3、总结

总结一下两者：

1.synchronized是Java的关键字，是内置特性，而Lock是一个接口，能够用它来实现同步。

2.synchronized同步的时候，其中一条线程用完会自动释放锁，而Lock须要手动释放，若是不手动释放，可能会形成死锁。

3.使用synchronized若是其中一个线程不释放锁，那么其余须要获取锁的线程会一直等待下去，知道使用完释放或者出现异常，而Lock可使用能够响应中断的锁或者使用规定等待时间的锁

4.synchronized没法得知是否获取到锁，而Lcok能够作到。

5.用ReadWriteLock能够提升多个线程进行读操做的效率。

因此综上所述，在两种锁的选择上，当线程对于资源的竞争不激烈的时候，效率差不太多，可是当大量线程同时竞争的时候，Lock的性能会远高于synchronized。

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程