Synchronized 和 Lock 区别

最新推荐文章于 2025-06-01 00:10:45 发布

原创最新推荐文章于 2025-06-01 00:10:45 发布 · 194 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#多线程 #java #并发编程

juc并发专栏收录该内容

12 篇文章

订阅专栏

本文深入探讨了Java中的两种并发控制机制：Synchronized关键字与Lock接口。详细对比了它们在锁的获取与释放、线程通信、响应中断及效率上的差异，为开发者选择合适的并发控制手段提供了指导。

Synchronized

Synchronized是java内置的关键字，可修饰同步代码块或同步方法，确保了多个线程在同一时刻只能有一个线程处于 同步代码块或同步方法中，它的优点是确保了线程安全，java许多类的许多方法都使用了Synchronized关键字，比如StringBuffer，但这个关键字有很多缺陷：

如果一个代码块被synchronized修饰了，当一个线程获取了对应的锁，并执行该代码块时，其他线程便只能一直等待，直到释放锁，故而造成了效率低下的问题
如果多个线程都只是进行读操作，所以当一个线程在进行读操作时，其他线程只能等待无法进行读操作

Lock

在java SE 5之前，防止多个线程同时访问同一资源的措施就是使用Synchronized关键字实现的，前面我们谈到，用这种方式会有许多缺陷，这时候java推出了Lock锁，位于java.util.concurrent.locks包下，是一个接口，只有一个实现类：ReentrantLock，看一下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()和unlock()是我们用的最多的方法，在用这些方法前需要注意的是，与Synchronized自动释放锁和加锁的方式不同，lock需要手动上锁和解锁，给大家简单的介绍一下使用方法：

Lock lock = new ReentrantLock();
lock.lock();
try{
    //处理任务
}catch(Exception ex){
     
}finally{
    lock.unlock();   //释放锁
}

这是规范的lock加锁方式，还有一个方法：tryLock()，它最大的特点是有boolean类型的返回值，可以用它来判断当前线程是否获得锁：

Lock lock = ReentrantLock();
if(lock.tryLock()) {
     try{
         //处理任务
     }catch(Exception ex){
         
     }finally{
         lock.unlock();   //释放锁
     } 
}else {
    //如果不能获取锁，则直接做其他事情
}

二者区别：

wait()，notify()，notifyAll()这三个线程通信方法只能用于Synchronized修饰的同步代码块或同步方法中
synchronized在执行完相应的同步代码块以后，自动释放锁，lock需要手动上锁和解锁
synchronized在发生异常时，会自动释放线程占有的锁，因此不会导致死锁现象发生；而Lock在发生异常时，如果没有主动通过unLock()去释放锁，则很可能造成死锁现象，因此使用Lock时需要在finally块中释放锁；
Lock可以让等待锁的线程响应中断，而synchronized却不行，使用synchronized时，等待的线程会一直等待下去，不能够响应中断(文章末尾会解释)；
通过Lock可以知道有没有成功获取锁，而synchronized却无法办到。
Lock可以提高多个线程进行读操作的效率

线程响应中断

在Java中，synchronized就不是可中断锁，而Lock是可中断锁。如果某一线程A正在执行锁中的代码，另一线程B正在等待获取该锁，可能由于等待时间过长，线程B不想等待了，想先处理其他事情，我们可以让它中断自己或者在别的线程中中断它，这种就是可中断锁。那么lock是如何做到的呢：
lock接口的lockInterruptibly()方法能够中断等待获取锁的线程：

public class LockTest {
 
    private Lock lock = new ReentrantLock();
 
    public void doBussiness() {
        String name = Thread.currentThread().getName();
 
        try {
            System.out.println(name + " 开始获取锁");
            lock.lockInterruptibly();
            System.out.println(name + " 得到锁");
            System.out.println(name + " 开工干活");
            for (int i=0; i<5; i++) {
                Thread.sleep(1000);
                System.out.println(name + " : " + i);
            }
        } catch (InterruptedException e) {
            System.out.println(name + " 被中断");
            System.out.println(name + " 做些别的事情");
        } finally {
            try {
                lock.unlock();
                System.out.println(name + " 释放锁");
            } catch (Exception e) {
                System.out.println(name + " : 没有得到锁的线程运行结束");
            }
        }
    }
 
    public static void main(String[] args) throws InterruptedException {
 
        LockTest lockTest = new LockTest();
 
        Thread t0 = new Thread(
                new Runnable() {
                    public void run() {
                        lockTest.doBussiness();
                    }
                }
                );
 
        Thread t1 = new Thread(
                new Runnable() {
                    public void run() {
                        lockTest.doBussiness();
                    }
                }
                );
 
        // 启动线程t1
        t0.start();
        Thread.sleep(10);
        // 启动线程t2
        t1.start();
        Thread.sleep(100);
        // 线程t1没有得到锁，中断t1的等待
        t1.interrupt();
    }
}

输出结果：

Thread-0 开始获取锁
Thread-0 得到锁
Thread-0 开工干活
Thread-1 开始获取锁
Thread-1 被中断
Thread-1 做些别的事情
Thread-1 : 没有得到锁的线程运行结束
Thread-0 : 0
Thread-0 : 1
Thread-0 : 2
Thread-0 : 3
Thread-0 : 4
Thread-0 释放锁