Java中的Lock与synchronized的区别

末蓝、 2022-11-19 05:27 153阅读 0赞

##### Java中的Lock与synchronized的区别 #####

先弄清一个问题：

一、什么是可重入锁？

可重入锁就是说某个线程已经获得某个锁，可以再次获取锁而不会出现死锁。

看一个synchronized的例子：

package com.pipi.juc;
    
    public class WhatReentrant { 
        public static void main(String[] args) { 
    
            new Thread(new Runnable() { 
                @Override
                public void run() { 
                    synchronized (this) { 
                        System.out.println("第1次获取锁，这个锁是：" + this);
                        int index = 1;
                        while (true) { 
                            synchronized (this) { 
                                System.out.println("第" + (++index) + "次获取锁，这个锁是：" + this);
                            }
                            if (index == 8) { 
                                break;  // 跳出死循环
                            }
                        }
                    }
                }
            }, "t1").start();
    
        }
    }

运行结果：

第1次获取锁，这个锁是：com.pipi.juc.WhatReentrant$1@54005b14
    第2次获取锁，这个锁是：com.pipi.juc.WhatReentrant$1@54005b14
    第3次获取锁，这个锁是：com.pipi.juc.WhatReentrant$1@54005b14
    第4次获取锁，这个锁是：com.pipi.juc.WhatReentrant$1@54005b14
    第5次获取锁，这个锁是：com.pipi.juc.WhatReentrant$1@54005b14
    第6次获取锁，这个锁是：com.pipi.juc.WhatReentrant$1@54005b14
    第7次获取锁，这个锁是：com.pipi.juc.WhatReentrant$1@54005b14
    第8次获取锁，这个锁是：com.pipi.juc.WhatReentrant$1@54005b14
    
    Process finished with exit code 0

我们发现程序正常运行，说明 synchronized 就是可重入锁。

--------------------

我们再看个例子：

package com.pipi.juc;
    
    import java.util.Random;
    import java.util.concurrent.TimeUnit;
    import java.util.concurrent.locks.Lock;
    import java.util.concurrent.locks.ReentrantLock;
    
    public class WhatReentrant { 
        public static void main(String[] args) { 
            final Lock lock = new ReentrantLock();  // 声明锁对象
    
            new Thread(() -> { 
            	lock.lock();  // 第一次锁
                try { 
                    System.out.println("第1次获取锁，这个锁是：" + lock);
    
                    int index = 1;
                    while (true) { 
                        lock.lock();  // 循环内多次获得锁
                        try { 
                            System.out.println("第" + (++index) + "次获取锁，这个锁是：" + lock);
                            try {  TimeUnit.MILLISECONDS.sleep(new Random().nextInt(200)); } catch (InterruptedException e) {  e.printStackTrace(); }
                            if (index == 8) break;  // 跳出循环
                        } finally { 
                            lock.unlock();  // 每循环1次，解锁1次
                        }
                    }
                } finally { 
                    lock.unlock();  // 对应第1次上锁，释放掉
                }
            }, "t1").start();
    
        }
    }

第1次获取锁，这个锁是：java.util.concurrent.locks.ReentrantLock@5103fb35[Locked by thread t1]
    第2次获取锁，这个锁是：java.util.concurrent.locks.ReentrantLock@5103fb35[Locked by thread t1]
    第3次获取锁，这个锁是：java.util.concurrent.locks.ReentrantLock@5103fb35[Locked by thread t1]
    第4次获取锁，这个锁是：java.util.concurrent.locks.ReentrantLock@5103fb35[Locked by thread t1]
    第5次获取锁，这个锁是：java.util.concurrent.locks.ReentrantLock@5103fb35[Locked by thread t1]
    第6次获取锁，这个锁是：java.util.concurrent.locks.ReentrantLock@5103fb35[Locked by thread t1]
    第7次获取锁，这个锁是：java.util.concurrent.locks.ReentrantLock@5103fb35[Locked by thread t1]
    第8次获取锁，这个锁是：java.util.concurrent.locks.ReentrantLock@5103fb35[Locked by thread t1]
    
    Process finished with exit code 0

我们发现程序也正常运行，说明 ReentrantLock 也是可重入锁。

我们得出第一个结论：  
Lock是一个接口，synchronized是java中的一个关键字。  
Lock 和 synchronized都是可重入锁。

--------------------

2、Lock要我们手动写代码释放锁，synchronized是线程执行完自动释放锁。

我们让Lock上锁2次，释放锁1次，让另一个线程再去调用：

package com.pipi.juc;
    
    import java.util.concurrent.TimeUnit;
    import java.util.concurrent.locks.Lock;
    import java.util.concurrent.locks.ReentrantLock;
    
    public class WhatReentrant { 
        public static void main(String[] args) { 
    
            final Lock lock = new ReentrantLock();
    
            new Thread(() -> { 
                lock.lock();
                lock.lock();  // 锁了2次
                try { 
                    try {  TimeUnit.SECONDS.sleep(2); } catch (InterruptedException e) {  e.printStackTrace(); }
                    System.out.println("lock()两次，unlock()一次");
                } finally { 
                    lock.unlock();  // 这里释放1次锁
                }
            }, "t1").start();
    
            new Thread(() -> { 
                lock.lock();  // 另外的线程，获取锁
                try { 
                    System.out.println("我这句话能输出吗？");
                } finally { 
                    lock.unlock();
                }
            }, "t2").start();
    
        }
    }

运行结果，我们发现第二个线程的打印一直处于阻塞等待状态。  
我们unlock()两次，再次运行，发现程序正常输出。

所以，我们得出第二个结论：  
Lock需要程序员手动释放锁，不然可能出现死锁情况。

--------------------

3、我们再看下Lock接口的源码：

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

方法解释：

*  lock()是我们平时用的最多的，最用是用来获取锁，如果锁已经被其他线程获取，那么就等待。
 *  tryLock()是一个boolean类型的方法，当调用这个方法的时候，线程会去尝试获取锁，如果获取到的话会返回true，如果获取不到返回false，也就是说这个方法会立马返回一个结果，线程不会等待。
 *  tryLock(long time, TimeUnit unit)是上面tryLock()方法的一个重载方法，加了两个参数，给定了等待的时间，如果在规定时间拿到锁返回true，如果拿不到返回false。
 *  lockInterruptibly()就比较特殊了，它表示可被中断的，意思就是，当尝试获取锁的时候，如果获取不到的话就会等待，但是，在等待的过程中它是可以响应中断的，也就是中断线程的等待过程。
 *  unlock()，释放锁。
 *  newCondition()，返回Condition对象，用于线程之间的通信，Condition的await()，signalAll()方法，相当于Object的wait()，notifyAll()方法。

--------------------

结论：

synchronized是Java中的一个关键字，而Lock是Java1.5后在java.util.concurrent.locks包下提供的一种实现同步的方法，那么显然的，synchronized一定是有什么做不到的或者缺陷，才导致了Lock的诞生。

synchronized是关键字，Lock是接口，二者均可实现线程同步；

Lock 和 synchronized都是可重入锁；

synchronized执行完自动释放锁，Lock需要程序员手动释放锁，不然可能出现死锁情况；

使用synchronized线程不释放锁，其他线程会一直等待下去，直到使用完释放或者出现异常，而Lock可以使用可以响应中断的锁或者使用规定等待时间的锁；

synchronized无法得知是否获取到锁，而Lcok可以做到。

所以综上所述：Lock的性能会远高于synchronized。

--------------------