java锁：对比下Synchronized和Reentrant Lock的异同

拼搏现实的明天。 2024-02-20 12:17 36阅读 0赞

ReentrantLock是Lock的实现类，是一个互斥的同步锁。  
从功能角度，ReentrantLock比Synchronized的同步操作更精细（因为可以像普通对象一样使用），甚至实现Synchronized没有的高级功能，  
如：  
1.等待可中断：当持有锁的线程长期不释放锁的时候，正在等待的线程可以选择放弃等待，对处理执行时间非常长的同步块很有用。带超时的获取锁尝试：在指定的时间范围内获取锁，如果时间到了仍然无法获取则返回。  
2.可以判断是否有线程在排队等待获取锁。  
3.可以响应中断请求：与Synchronized不同，当获取到锁的线程被中断时，能够响应中断，中断异常将会被抛出，同时锁会被释放。  
4.可以实现公平锁。从锁释放角度，Synchronized在JVM层面上实现的，不但可以通过一些监控工具监控Synchronized的锁定，而且在代码执行出现异常时，JVM会自动释放锁定；  
但是使用Lock则不行，Lock是通过代码实现的，要保证锁定一定会被释放，就必须将unLock()放到finally\{\}中。  
从性能角度，Synchronized早期实现比较低效，对比ReentrantLock，大多数场景性能都相差较大。  
但是在Java6中对其进行了非常多的改进，在竞争不激烈时，Synchronized的性能要优于ReetrantLock；  
在高竞争情况下，Synchronized的性能会下降几十倍，但是ReetrantLock的性能能维持常态。

## 代码演示 ##

Synchronized 和 Reentrant Lock 是两种常见的线程同步机制，它们有一些异同之处。下面是它们的异同对比及相应的代码演示：

1.  获取锁的方式和释放锁的方式：
    
     *  Synchronized：使用关键字 synchronized，通过进入 synchronized 代码块或方法来获取锁，当退出 synchronized 代码块或方法时，会自动释放锁。
     *  Reentrant Lock：使用 `lock()` 方法来获取锁，使用 `unlock()` 方法来释放锁，需要显式地调用这两个方法来控制锁的获取和释放。

下面是使用 Synchronized 的示例代码：

public class SynchronizedExample {
        
        private int count = 0;
    
        public synchronized void increment() {
        
            count++;
        }
    
        public int getCount() {
        
            return count;
        }
    }

下面是使用 Reentrant Lock 的示例代码：

import java.util.concurrent.locks.Lock;
    import java.util.concurrent.locks.ReentrantLock;
    
    public class ReentrantLockExample {
        
        private int count = 0;
        private Lock lock = new ReentrantLock();
    
        public void increment() {
        
            lock.lock();
            try {
        
                count++;
            } finally {
        
                lock.unlock();
            }
        }
    
        public int getCount() {
        
            return count;
        }
    }

1.  可重入性（Reentrancy）：
    
     *  Synchronized：支持可重入性，线程可以多次获取同一个锁，而不会发生死锁。
     *  Reentrant Lock：同样支持可重入性，线程可以多次获取同一个锁，而不会发生死锁。

下面是可重入性的示例代码：

public class ReentrantExample {
        
        private synchronized void method1() {
        
            System.out.println("Inside method1");
            method2();
        }
    
        private synchronized void method2() {
        
            System.out.println("Inside method2");
        }
    
        public static void main(String[] args) {
        
            ReentrantExample example = new ReentrantExample();
            example.method1();
        }
    }

在上述代码中，通过 synchronized 关键字修饰的方法 `method1()` 和 `method2()` 都是可重入的。当 `method1()` 调用 `method2()` 时，由于两个方法都是 synchronized 的，所以线程可以多次获取同一个锁，不会发生死锁。

总结：

*  Synchronized 和 Reentrant Lock 都可以实现线程同步的效果，但使用方式和语法有所不同。
 *  Synchronized 是关键字，更简单易用，但功能相对有限。
 *  Reentrant Lock 是一个类，提供了更多的功能和灵活性，需要显式地调用 lock() 和 unlock() 方法来控制锁的获取和释放。
 *  两者都支持可重入性，允许线程多次获取同一个锁，避免死锁的发生。