Synchronized 使用与原理详解

1、简介

synchronized是JVM内置锁，基于Monitor机制实现，依赖底层操作系统的互斥原语Mutex（互斥量），它是一个重量级锁，性能较低。Monitor，直译为“监视器”，而操作系统领域一般翻译为“管程”。管程是指管理共享变量以及对共享变量操作的过程，让它们支持并发。

不同于ReentrantLock锁。synchronized关键字可以修饰方法，也可以修饰代码块。synchronized关键字修饰方法时可以修饰静态方法，也可以修饰非静态方法；同样，synchronized关键字修饰代码块时可以修饰对象，也可以修饰类。当然，synchronized修饰静态方法/类和非静态方法/对象时的作用范围是不同的。下面通过各种demo来详解synchronized的各种用法及注意事项。

synchronized 的局限性

不可中断：其他线程无法中断这个锁等待。
非公平锁: 唤醒的线程和新来的线程一起竞争，可能饥饿。
单一条件等待： 只能在一个条件上等待。

2、测试demo

1、synchronized类锁

这里所说的 synchronized类锁的作用范围是类级别的，不会因为同一个类的不同对象执行而失效。

结论： 1.1、 synchronized修饰同一个类的两个静态方法时互斥。

public class TestClassLock {
    public static void main(String[] args) throws Exception {
        new Thread(() -> {
            ClassLock.test1();
        }).start();

        new Thread(() -> {
            ClassLock.test2();
        }).start();
    }

}
class ClassLock {

    public synchronized static void test1(){
        System.out.println(new Date() + " " + Thread.currentThread().getName() + " begin...");
        try {
            TimeUnit.SECONDS.sleep(2);
        } catch (Exception e) {}
        System.out.println(new Date() + " " + Thread.currentThread().getName() + " end...");
    }
    // 【注意】public static void test2(){ 不会互斥，因为此时test2没有使用类锁。
    public synchronized static void test2(){
        System.out.println(new Date() + " " + Thread.currentThread().getName() + " begin...");
        try {
            TimeUnit.SECONDS.sleep(2);
        } catch (Exception e) {}
        System.out.println(new Date() + " " + Thread.currentThread().getName() + " end...");
    }
}

执行结果：

test2方法如果没有synchronized修饰的话，执行结果如下：

【结论】两个线程分别同时执行同一个类产生的不同对象的两个不同 synchronized static方法，类锁生效，虽然是不同对象，因为两个线程使用的是同一个类锁。反过来，假如test2方法没有synchronized修饰的话，只有test1方法有被synchronized修饰，此时两个方法也不会互斥，一个有锁，一个没有锁，自然不会互斥。

结论：1.2、 synchronized分别修饰同一个类的静态方法和代码块中使用类锁时互斥

public class Test2ClassLock {

    public static void main(String[] args) throws Exception {
        new Thread(() -> {
            ClassLock2.test1();
        }).start();

        new Thread(() -> {
            ClassLock2.test2();
        }).start();
    }

}
class ClassLock2 {
    public synchronized static void test1(){
        System.out.println(new Date() + " " + Thread.currentThread().getName() + " begin...");
        try {
            TimeUnit.SECONDS.sleep(2);
        } catch (Exception e) {}
        System.out.println(new Date() + " " + Thread.currentThread().getName() + " end...");
    }

    public static void test2(){
        // 【注意】synchronized (OtherClass.class)不会互斥
        synchronized (ClassLock2.class) {
            System.out.println(new Date() + " " + Thread.currentThread().getName() + " begin...");
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (Exception e) {}
            System.out.println(new Date() + " " + Thread.currentThread().getName() + " end...");
        }
    }
}

执行结果：

【结论】两个线程同时分别执行一个被synchronized修饰static方法，一个有synchnized(该类)代码块的static方法，锁生效，虽然是不同对象，因为两个线程使用的同一个类锁。反过来，如果是修饰的不同类，因为类锁不同，肯定不会互斥，比如将test2方法的synchronized (ClassLock2.class)这句代码改成synchronized (OtherClass.class),此时不会互斥。

结论：1.3、 synchronized分别修饰同一个静态对象时互斥

public class Test3ClassLock {


    public static void main(String[] args) throws Exception {
        new Thread(() -> {
            ClassLock3.test1();
        }).start();

        new Thread(() -> {
            ClassLock4.test2();
        }).start();
    }
}
class ClassLock3 {
    public static void test1(){
        // 【1】synchronized (StaticLock.staticLock1) {
        synchronized (StaticLock.staticLock1) {
            System.out.println(new Date() + " " + Thread.currentThread().getName() + " begin...");
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (Exception e) {}
            System.out.println(new Date() + " " + Thread.currentThread().getName() + " end...");
        }
    }
}


class ClassLock4 {
    public static void test2() {
        // 【2】synchronized (StaticLock.staticLock2) {
        synchronized (StaticLock.staticLock1) {
            System.out.println(new Date() + " " + Thread.currentThread().getName() + " begin...");
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (Exception e) {}
            System.out.println(new Date() + " " + Thread.currentThread().getName() + " end...");
        }
    }
}

class StaticLock {
    public static final Object staticLock1 = new Object();
    public static final Object staticLock2 = new Object();
}

【结论】synchronized分别修饰同一个类的静态对象时互斥,反过来，如果是修饰不同的静态对象，肯定不会互斥，比如将上面代码中标【1】和【2】的synchronized代码结合使用。

2、synchronized对象锁

这里说的synchronized对象锁的作用范围是对象级别的即仅仅作用于同一个对象，如果是同一个类的两个不同的对象是不会互斥的，即没有效果的。

2.1、 synchronized修饰同一个类对象的两个非静态方法时互斥

public class TestObjectLock {

    public static void main(String[] args) throws Exception {
        // 【注意】当且仅当是同一个SynchronizeAndObjectLock2对象
        TestObjectLock testObjectLock = new TestObjectLock();
        new Thread(() -> {
            testObjectLock.test1();
        }).start();

        new Thread(() -> {
            testObjectLock.test2();
        }).start();
    }
    public synchronized void test1(){
        System.out.println(new Date() + " " + Thread.currentThread().getName() + " begin...");
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (Exception e) {}
        System.out.println(new Date() + " " + Thread.currentThread().getName() + " end...");
    }

    public synchronized void test2(){
        System.out.println(new Date() + " " + Thread.currentThread().getName() + " begin...");
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (Exception e) {}
        System.out.println(new Date() + " " + Thread.currentThread().getName() + " end...");
    }
}

运行结果：

【结论】两个线程同时执行被synchronized修饰的相同对象的不同（相同）方法，锁生效，因为两个线程使用的是相同的对象锁。

2.2、synchronized分别修饰同一个类对象的非静态方法和当前对象时互斥

public class Test2ObjectLock {

    public static void main(String[] args) throws Exception {
        // 【注意】当且仅当是同一个SynchronizeAndObjectLock3对象
        Test2ObjectLock test2ObjectLock = new Test2ObjectLock();
        new Thread(() -> {
            test2ObjectLock.test1();
        }).start();

        new Thread(() -> {
            test2ObjectLock.test2();
        }).start();
    }

    public void test1(){
        synchronized(this) {
            System.out.println(new Date() + " " + Thread.currentThread().getName() + " begin...");
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (Exception e) {}
            System.out.println(new Date() + " " + Thread.currentThread().getName() + " end...");
        }

    }

    public synchronized void test2(){
        System.out.println(new Date() + " " + Thread.currentThread().getName() + " begin...");
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (Exception e) {}
        System.out.println(new Date() + " " + Thread.currentThread().getName() + " end...");
    }
}

运行结果：

【结论】synchronized修饰非静态方法与synchronized(this)互斥，可见，snchronized修饰非静态方法实质锁的是当前对象。

2.3、 synchronized修饰不同对象的两个非静态方法时不会互斥

public class Test3ObjectLock {

    public static void main(String[] args) throws Exception {
        new Thread(() -> {
            // 这里new 了一个Test3ObjectLock对象
            new Test3ObjectLock().test1();
        }).start();

        new Thread(() -> {
            // 这里new 了另一个Test3ObjectLock对象
            new Test3ObjectLock().test2();
        }).start();
    }
    public synchronized void test1(){
        System.out.println(new Date() + " " + Thread.currentThread().getName() + " begin...");
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (Exception e) {}
        System.out.println(new Date() + " " + Thread.currentThread().getName() + " end...");
    }

    public synchronized void test2(){
        System.out.println(new Date() + " " + Thread.currentThread().getName() + " begin...");
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (Exception e) {}
        System.out.println(new Date() + " " + Thread.currentThread().getName() + " end...");
    }
}

执行结果：

【结论】两个线程同时执行被synchronized修饰的不同对象的不同（相同）方法，锁未生效，因为两个线程使用的是不同的对象锁。

2.4、 synchronized代码块修饰同一个对象时互斥

public class Test4ObjectLock {

    private final Object objectLock = new Object();

    public static void main(String[] args) throws Exception {

        Test4ObjectLock test4ObjectLock = new Test4ObjectLock();
        new Thread(() -> {
            test4ObjectLock.test1();
        }).start();

        new Thread(() -> {
            test4ObjectLock.test2();
        }).start();
    }
    public void test1(){
        synchronized(objectLock) {
            System.out.println(new Date() + " " + Thread.currentThread().getName() + " begin...");
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (Exception e) {}
            System.out.println(new Date() + " " + Thread.currentThread().getName() + " end...");
        }

    }

    public void test2(){
        synchronized(objectLock) {
            System.out.println(new Date() + " " + Thread.currentThread().getName() + " begin...");
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (Exception e) {}
            System.out.println(new Date() + " " + Thread.currentThread().getName() + " end...");
        }
    }
}

运行结果：

【结论】synchronized代码块修饰同一个对象时互斥，若synchronized代码块修饰的是不同对象，那么不会互斥。

3、synchronized修饰当前类和当前对象时不会互斥

public class TestClassAndObjectLock {

    public static void main(String[] args) throws Exception {
        new Thread(() -> {
            TestClassAndObjectLock.test1();
        }).start();

        new Thread(() -> {
            new TestClassAndObjectLock().test2();
        }).start();
    }
    public static void test1(){
        synchronized (TestClassAndObjectLock.class) {
            System.out.println(new Date() + " " + Thread.currentThread().getName() + " begin...");
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (Exception e) {}
            System.out.println(new Date() + " " + Thread.currentThread().getName() + " end...");
        }
    }

    public void test2(){
        synchronized (this) {
            System.out.println(new Date() + " " + Thread.currentThread().getName() + " begin...");
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (Exception e) {}
            System.out.println(new Date() + " " + Thread.currentThread().getName() + " end...");
        }
    }
}

运行结果：

【结论】可见，类锁和对象锁是相互独立的，互不相斥。

3、synchronized锁注意事项

1、synchronized锁不能被中断

为了模拟synchronized锁不可中断，下面先让两个线程进入死锁，然后再用main线程去中断其中一个线程，看被中断的线程能否释放锁并被唤醒。

public class DeadLockCannotInterruptDemo {
    private static Object lock1 = new Object();
    private static Object lock2 = new Object();

    public static void main(String[] args) throws Exception {
        Thread threadA = new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (lock1) {
                    System.out.println(Thread.currentThread().getName() + " get lock1");
                    try {
                        Thread.sleep(10);
                        synchronized (lock2) {
                            System.out.println(Thread.currentThread().getName() + " get lock2");
                        }
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        });

        Thread threadB = new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (lock2) {
                    System.out.println(Thread.currentThread().getName() + " get lock2");
                    try {
                        Thread.sleep(10);
                        synchronized (lock1) {
                            System.out.println(Thread.currentThread().getName() + " get lock1");
                        }
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        });

        threadA.start();
        threadB.start();

        TimeUnit.SECONDS.sleep(3);
        System.out.println("main thread begin to interrupt " + threadA.getName() + " and " + 
                threadA.getName() + " will release lock1...");
        threadA.interrupt();
    }
}

运行结果：

【结论】如上图，main线程中断Thread-0后，Thread-0并不会释放锁并醒过来。同样的，ReentrantLock的tryLock或lockInterruptibly是可以被中断的。

2 、synchronized锁可重入

2.1、不同方法，synchronized是可重入的

public class SynchronizeAndReentrant {
    public static void main(String[] args) throws Exception {
        SynchronizeAndReentrant synchronizeAndReentrant = new SynchronizeAndReentrant();
        synchronizeAndReentrant.test1();
    }
    public synchronized void test1(){
        System.out.println(" test1 method is called...");
        test2();
    }

    public synchronized void test2(){
        System.out.println(" test2 method is called...");
    }
}

运行结果：

2.2 、相同方法，synchronized是可重入的

public class SynchronizeAndReentrant2 {
    int i = 1;
    public static void main(String[] args) throws Exception {
        SynchronizeAndReentrant2 synchronizeAndReentrant = new SynchronizeAndReentrant2();
        synchronizeAndReentrant.test1();
    }
    public synchronized void test1(){

        System.out.println(" test1 method is called " + i++ + "st time..." );
        while(i < 5) {
            test1();
        }
    }
}

运行结果：

3、 synchronized锁不带超时功能

synchronized锁不带超时功能,而ReentrantLock的tryLock是具备带超时功能的，在指定时间没获取到锁，该线程会苏醒，有助于预防死锁的产生。

4 唤醒/等待需要synchronized锁

public class NotifyNeedSynchronized {
    public static Object lock = new Object();
    public static void main(String[] args) throws Exception{
        // 抛出IllegalMonitorStateException
        //lock.notify();
        lock.wait();
    }
}

运行结果：

【结论】使用Object的notify和wait等方法时，必须要使用synchronized锁，否则会抛出IllegalMonitorStateException。

5 、使用synchronized锁时尽量缩小范围以保证性能

使用synchronized锁时，为了尽可能提高性能，我们应该尽量缩小锁的范围。能不锁方法就不锁方法，推荐尽量使用synchronized代码块来降低锁的范围。以下面的一段netty源码为例：

public <T> ServerBootstrap childOption(ChannelOption<T> childOption, T value) {
    if (childOption == null) {
        throw new NullPointerException("childOption");
    }
    if (value == null) {
        synchronized (childOptions) {
            childOptions.remove(childOption);
        }
    } else {
        synchronized (childOptions) {
            childOptions.put(childOption, value);
        }
    }
    return this;
}

可见，找到并发访问代码的临界区，并不用synchronized锁全部代码，尽量避免使用synchronized来修饰方法。

4、synchronized 与 volatile 对比

5、synchronized 底层实现原理

重量级锁实现原理：

synchronized 底层是利用 monitor 对象，CAS 和 mutex 互斥锁来实现的，内部会有等待队列(cxq 和 EntryList)和条件等待队列(waitSet)来存放相应阻塞的线程。未竞争到锁的线程存储到等待队列中，获得锁的线程调用 wait 后便存放在条件等待队列中，解锁和 notify 都会唤醒相应队列中的等待线程来争抢锁。然后由于阻塞和唤醒依赖于底层的操作系统实现，系统调用存在用户态与内核态之间的切换，所以有较高的开销，因此称之为重量级锁。

在获取锁时，是将当前线程插入到cxq的头部，而释放锁时，默认策略（QMode=0）是：如果EntryList为空，则将cxq中的元素按原有顺序插入到EntryList，并唤醒第一个线程，也就是当EntryList为空时，是后来的线程先获取锁。_EntryList不为空，直接从_EntryList中唤醒线程。

为什么会有_cxq 和 _EntryList 两个列表来放线程？

因为会有多个线程会同时竞争锁，所以搞了个 _cxq 这个单向链表基于 CAS 来 hold 住这些并发，然后另外搞一个 _EntryList 这个双向链表，来在每次唤醒的时候搬迁一些线程节点，降低 _cxq 的尾部竞争。

每个 Java 对象在内存中都包含对象头，synchronized 的锁信息就存储在这里：

重量级锁优化

JVM内置锁在1.5之后版本做了重大的优化，如锁粗化（Lock Coarsening）、锁消除（Lock Elimination）、轻量级锁（Lightweight Locking）、偏向锁（Biased Locking）、自适应自旋（Adaptive Spinning）等技术来减少锁操作的开销，内置锁的并发性能已经基本与Lock持平。

锁升级过程：

无锁 → 偏向锁 → 轻量级锁 → 重量级锁

阶段一：偏向锁

偏向锁工作流程：

1. 对象创建时，Mark Word 的锁标志位为 01，偏向模式为 0（无锁）。
2. 第一个线程访问时，CAS 将 ThreadID 写入 Mark Word，偏向模式置为 1。
3. 该线程再次进入时，检查 ThreadID 是否匹配，匹配则直接执行。

偏向锁撤销流程：

线程A持有偏向锁, 线程B尝试获取时发生竞争

1. 暂停持有偏向锁的线程（安全点）。
2. 检查线程状态，如果已退出同步块则撤销偏向锁。
3. 如果还在执行，升级为轻量级锁。

阶段2：轻量级锁（Lightweight Locking）

轻量级锁工作流程：

1. 在当前线程栈帧中创建锁记录（Lock Record）。
2. 将对象头的 Mark Word 复制到锁记录中（Displaced Mark Word）。
3. 使用 CAS 将对象头 Mark Word 替换为指向锁记录的指针。
4. 如果成功，获取轻量级锁；如果失败，说明有竞争，升级为重量级锁。

阶段3：重量级锁（Heavyweight Locking）

重量级锁工作流程：

1. 当轻量级锁竞争失败时，膨胀为重量级锁。
2. 对象头 Mark Word 指向 Monitor 对象。
3. 未获取锁的线程进入 EntryList 阻塞队列。
4. 获取锁的线程执行完毕时，唤醒 EntryList 中的线程。

锁粗化

锁粗化，简单来说，就是将多个连续的锁扩展为一个更大范围的锁。通过锁粗化，可以将多次加锁和解锁操作减少到一次，从而减少这部分开销，提高程序的运行效率。

// 示例：多个连续的同步块可以合并
public void coarseningExample() {
    // 原始代码：多个细粒度锁
    synchronized(lock) {
        // 操作1
    }
    // 中间没有竞争代码
    synchronized(lock) {
        // 操作2
    }
    
    // JVM 优化后：合并为一个粗粒度锁
    synchronized(lock) {
        // 操作1
        // 操作2
    }
}

锁消除

锁消除主要应用在没有多线程竞争的情况下。具体来说，当一个数据仅在一个线程中使用，或者说这个数据的作用域仅限于一个线程时，这个线程对该数据的所有操作都不需要加锁。这种优化主要是通过逃逸分析（Escape Analysis）来实现的。

// 示例：同步代码没有逃逸，可以被消除
public String concatString(String s1, String s2, String s3) {
    // StringBuffer 是线程安全的，但这里 sb 是局部变量，不会逃逸
    // JVM 会自动消除 synchronized 锁
    StringBuffer sb = new StringBuffer();
    sb.append(s1);
    sb.append(s2);
    sb.append(s3);
    return sb.toString();
}

CAS自旋优化

在 Java 6 之后自旋是自适应的，比如对象刚刚的一次自旋操作成功过，那么认为这次自旋成功的可能性会高，就多自旋几次；反之，就少自旋甚至不自旋。自旋的目的是为了减少线程挂起的次数，尽量避免直接挂起线程（挂起操作涉及系统调用，存在用户态和内核态切换，这才是重量级锁最大的开销）。

posted @ 2022-03-10 23:05 邓维-java 阅读(1205) 评论(0) 收藏举报

刷新页面返回顶部

学如逆水行舟，不进则退！

当你的才华配不上你的任性时，那就努力奋斗吧！

Synchronized 使用与原理详解

Synchronized 使用与原理详解

synchronized 的局限性

1、synchronized类锁

结论： 1.1、 synchronized修饰同一个类的两个静态方法时互斥。

结论：1.2、 synchronized分别修饰同一个类的静态方法和代码块中使用类锁时互斥

结论：1.3、 synchronized分别修饰同一个静态对象时互斥

2、synchronized对象锁

2.1、 synchronized修饰同一个类对象的两个非静态方法时互斥

2.2、synchronized分别修饰同一个类对象的非静态方法和当前对象时互斥

2.3、 synchronized修饰不同对象的两个非静态方法时不会互斥

2.4、 synchronized代码块修饰同一个对象时互斥

3、synchronized修饰当前类和当前对象时不会互斥

3、synchronized锁注意事项

1、synchronized锁不能被中断

2 、synchronized锁可重入

2.1、不同方法，synchronized是可重入的

2.2 、相同方法，synchronized是可重入的

3、 synchronized锁不带超时功能

4 唤醒/等待需要synchronized锁

5 、使用synchronized锁时尽量缩小范围以保证性能

4、synchronized 与 volatile 对比

5、synchronized 底层实现原理

重量级锁实现原理：

重量级锁优化

阶段2：轻量级锁（Lightweight Locking）

阶段3：重量级锁（Heavyweight Locking）

锁粗化

锁消除

CAS自旋优化

公告

学如逆水行舟， 不进则退！

当你的才华配不上你的任性时， 那就努力奋斗吧！

Synchronized 使用与原理详解

Synchronized 使用与原理详解

synchronized 的局限性

1、synchronized类锁

结论： 1.1、 synchronized修饰同一个类的两个静态方法时互斥。

结论：1.2、 synchronized分别修饰同一个类的静态方法和代码块中使用类锁时互斥

结论：1.3、 synchronized分别修饰同一个静态对象时互斥

2、synchronized对象锁

2.1、 synchronized修饰同一个类对象的两个非静态方法时互斥

2.2、synchronized分别修饰同一个类对象的非静态方法和当前对象时互斥

2.3、 synchronized修饰不同对象的两个非静态方法时不会互斥

2.4、 synchronized代码块修饰同一个对象时互斥

3、synchronized修饰当前类和当前对象时不会互斥

3、synchronized锁注意事项

1、synchronized锁不能被中断

2 、synchronized锁可重入

2.1、不同方法，synchronized是可重入的

2.2 、相同方法，synchronized是可重入的

3、 synchronized锁不带超时功能

4 唤醒/等待需要synchronized锁

5 、使用synchronized锁时尽量缩小范围以保证性能

4、synchronized 与 volatile 对比

5、synchronized 底层实现原理

重量级锁实现原理 ：

重量级锁优化

阶段2：轻量级锁（Lightweight Locking）

阶段3：重量级锁（Heavyweight Locking）

锁粗化

锁消除

CAS自旋优化

公告

学如逆水行舟，不进则退！

当你的才华配不上你的任性时，那就努力奋斗吧！

重量级锁实现原理：