Synchronized与Lock有什么区别？-优快云博客

本文链接：https://blog.youkuaiyun.com/NotRepent/article/details/125033087

本文详细比较了Java中的Synchronized与ReentrantLock两种锁机制的区别，包括它们的使用方式、等待中断特性、加锁公平性及Condition支持等方面。

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

1.原始构成

Synchronized是关键字属于JVM层面

monitorenter(底层通过monitor对象来完成，其实wait/notify等方法也依赖于monitor对象只有在同步块或方法中才能调用wait/notify 等方法 monitorexit

Lock是JUC下API层面下的锁

package com.concurrent;

import java.util.concurrent.locks.ReentrantLock;

/**
 * synchronized 与 ReentrantLock() 区别
 */
public class SyncAndReentrantLockDemo {

    public static void main(String[] args) {

        synchronized (new Object()){

        }

        new ReentrantLock();
    }
}

//javap 后的结果

Compiled from "SyncAndReentrantLockDemo.java"
public class com.concurrent.SyncAndReentrantLockDemo {
  public com.concurrent.SyncAndReentrantLockDemo();
    Code:
       0: aload_0
       1: invokespecial #1                  // Method java/lang/Object."<init>":()V
       4: return

  public static void main(java.lang.String[]);
    Code:
       0: new           #2                  // class java/lang/Object
       3: dup
       4: invokespecial #1                  // Method java/lang/Object."<init>":()V
       7: dup
       8: astore_1
       9: monitorenter
      10: aload_1
      11: monitorexit
      12: goto          20
      15: astore_2
      16: aload_1
      17: monitorexit
      18: aload_2
      19: athrow
      20: new           #3                  // class java/util/concurrent/locks/ReentrantLock
      23: dup
      24: invokespecial #4                  // Method java/util/concurrent/locks/ReentrantLock."<init>":()V
      27: pop
      28: return
    Exception table:
       from    to  target type
          10    12    15   any
          15    18    15   any
}

2.使用方法

Synchronized不需要用户手动去释放锁，当synchronized代码执行完后系统会自动让线程对锁进行释放

ReentrantLock则需要手动去释放锁，如果没有主动去释放锁可能会出现死锁现象需要Lock,Unlock ,try - finally语句块完成

3.等待是否可中断

synchronized不可中断除非抛异常或者正常执行完成

ReentrantLock可以中断 1.设置超时方法 boolean tryLock(long time, TimeUnit unit)

2.void lockInterruptibly() throws InterruptedException; 放代码块中调用interrupt直接中断

4.加锁是否公平

Synchronized非公平锁

ReentrantLock两者都可以默认非公平锁，构造方法可传入boolean值 true为公平锁，false为非公平锁

5.绑定多个条件的Condition

Synchronized根本没有

ReentrantLock用来实现分组可以唤醒需要唤醒的线程组，可以精确唤醒，而不是像Synchronized那一要么随机唤醒一个线程，要么全部唤醒

package com.concurrent;

import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * synchronized 与 ReentrantLock() 区别
 */

/**
 * 多线程之间顺序调用 A--->B---->C---D
 * <p>
 * A打印5次，B打印10次，C15次
 */

class ShareReSource {

    private int number = 1; //A:1 B:2 C:3
    private Lock lock = new ReentrantLock();
    private Condition c1 = lock.newCondition();
    private Condition c2 = lock.newCondition();
    private Condition c3 = lock.newCondition();

    //1.判断
    public void print5() {
        lock.lock();
        try {
            while (number != 1) {
                c1.await();
            }
            for (int i = 1; i <= 5; i++) {
                System.out.println(Thread.currentThread().getName() + "\t" + i);
            }
            number = 2;
            c2.signal();

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }


    public void print10() {
        lock.lock();
        try {
            while (number != 2) {
                c2.await();
            }
            for (int i = 1; i <= 10; i++) {
                System.out.println(Thread.currentThread().getName() + "\t" + i);
            }
            number = 3;
            c3.signal();

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public void print15() {
        lock.lock();
        try {
            while (number != 3) {
                c3.await();
            }
            for (int i = 1; i <= 15; i++) {
                System.out.println(Thread.currentThread().getName() + "\t" + i);
            }
            number = 1;
            c1.signal();

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }


    //2.干活


    //3.通知


}

public class SyncAndReentrantLockDemo {

    public static void main(String[] args) {
        ShareReSource shareReSource = new ShareReSource();
        new Thread(() -> {
            for (int i = 1; i < 5; i++) {
                shareReSource.print5();
            }

        }, "A").start();
        new Thread(() -> {
            for (int i = 1; i < 10; i++) {
                shareReSource.print10();
            }

        }, "B").start();

        new Thread(() -> {
            for (int i = 1; i < 15; i++) {
                shareReSource.print15();
            }

        }, "C").start();

    }
}

输出：

A   1
A   2
A   3
A   4
A   5
B   1
B   2
B   3
B   4
B   5
B   6
B   7
B   8
B   9
B   10
C   1
C   2
C   3
C   4
C   5
C   6
C   7
C   8
C   9
C   10
C   11
C   12
C   13
C   14
C   15
A   1
A   2
A   3
A   4
A   5
B   1
B   2
B   3
B   4
B   5
B   6
B   7
B   8
B   9
B   10
C   1
C   2
C   3
C   4
C   5
C   6
C   7
C   8
C   9
C   10
C   11
C   12
C   13
C   14
C   15
A   1
A   2
A   3
A   4
A   5
B   1
B   2
B   3
B   4
B   5
B   6
B   7
B   8
B   9
B   10
C   1
C   2
C   3
C   4
C   5
C   6
C   7
C   8
C   9
C   10
C   11
C   12
C   13
C   14
C   15
A   1
A   2
A   3
A   4
A   5
B   1
B   2
B   3
B   4
B   5
B   6
B   7
B   8
B   9
B   10
C   1
C   2
C   3
C   4
C   5
C   6
C   7
C   8
C   9
C   10
C   11
C   12
C   13
C   14
C   15