程序员经验分享-hwhale

详解synchronized锁的各种用法及注意事项

2023-05-16

【源码笔记】 专注于Java后端系列框架的源码分析，关注【源码笔记】公众号，第一时间接收最新源码分析文章更新。Github地址：https://github.com/yuanmabiji/Java-SourceCode-Blogs

1 前言

本文主要通过简单的demo来阐述synchronized锁的各种用法以及使用synchronized锁的相关注意事项，记录下来同时也方便自己记忆。

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

2 synchronized类锁

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

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

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

        new Thread(() -> {
            // new了另一个ClassLock对象
            new ClassLock().test2();
        }).start();
    }

}
class ClassLock {
    public synchronized static 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 static void test2(){ 不会互斥，因为此时test2没有使用类锁。
    public synchronized static 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 static方法，类锁生效，虽然是不同对象，因为两个线程使用的是同一个类锁。反过来，假如test2方法没有synchronized修饰的话，只有test1方法有被synchronized修饰，此时两个方法也不会互斥，一个有锁，一个没有锁，自然不会互斥。

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

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

        new Thread(() -> {
            // new了另一个ClassLock2对象
            new ClassLock2().test2();
            // ClassLock2.test2();
        }).start();
    }

}
class ClassLock2 {
    public synchronized static 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 static void test2(){
    	// 【注意】synchronized (SynchronizeAndClassLock2.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 (SynchronizeAndClassLock2.class),此时不会互斥。

2.3 synchronized分别修饰同一个静态对象时互斥

public class SynchronizeAndClassLock10 {

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

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

class RunObject1 {
    public static void test1(){
    	// 【1】synchronized (StaticLock2.staticLock1) {
        synchronized (StaticLock2.staticLock) {
            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 RunObject2 {
    public static void test2() {
    	// 【2】synchronized (StaticLock2.staticLock2) {
        synchronized (StaticLock2.staticLock) {
            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 StaticLock2 {
    public static Object staticLock = new Object();
}

运行结果：

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

3 synchronized对象锁

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

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

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

        new Thread(() -> {
            synchronizeAndObjectLock2.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修饰的相同对象的不同（相同）方法，锁生效，因为两个线程使用的是相同的对象锁

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

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

        new Thread(() -> {
            synchronizeAndObjectLock3.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...");
    }
}

运行结果：

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

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

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

        new Thread(() -> {
            // 这里new 了另一个SynchronizeAndObjectLock对象
            new SynchronizeAndObjectLock().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修饰的不同对象的不同（相同）方法，锁未生效，因为两个线程使用的是不同的对象锁。

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

public class SynchronizeAndObjectLock5 {
    private Object objectLock = new Object();

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

        new Thread(() -> {
            synchronizeAndObjectLock5.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代码块修饰的是不同对象，那么不会互斥。

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

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

        new Thread(() -> {
            new ClassAndObjectLock().test2();
        }).start();
    }
    public static void test1(){
        synchronized (ClassAndObjectLock.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...");
        }
    }
}

运行结果：

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

5 synchronized锁注意事项

5.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是可以被中断的。

5.2 synchronized锁可重入

5.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...");
    }
}

运行结果：

5.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();
        }
    }
}

运行结果：

5.3 synchronized锁不带超时功能

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

5.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.5 使用synchronized锁时尽量缩小范围以保证性能

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

// ServerBootstrap.java

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来修饰方法。

6 总结

本文对synchronized的各种用法及注意事项通过demo简单梳理了下，后面有时间会探讨下synchronized的原理。

【源码笔记】 专注于Java后端系列框架的源码分析，关注【源码笔记】公众号，第一时间接收最新源码分析文章更新。Github地址：https://github.com/yuanmabiji/Java-SourceCode-Blogs

本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容，请联系:hwhale#tublm.com(使用前将#替换为@)

Synchronized

锁的各种用法及注意事项

详解synchronized锁的各种用法及注意事项 的相关文章

  • Java多线程详解（线程同步）

    嗨喽 小伙伴们我来了 上一章 我们通过几个例子 点击跳转 介绍了线程安全问题 而说到线程安全就不得不提到线程同步 它是解决线程安全的一种重要方法 本章就来简单地介绍一下线程同步 从上一章的学习我们知道 当多个线程操作一个资源的时候 有可能由

  • Java中synchronized同步锁用法及作用范围

    Java 中的 synchronized 关键字可以在多线程环境下用来作为线程安全的同步锁 本文主要对 synchronized 的作用 以及其有效范围进行讨论 Java中的对象锁和类锁 java的对象锁和类锁在锁的概念上基本上和内置锁是一

  • 【转载】Java中的锁机制 synchronized & 偏向锁 & 轻量级锁 & 重量级锁 & 各自优缺点及场景 & AtomicReference

    参考文章 http blog csdn net chen77716 article details 6618779 目前在Java中存在两种锁机制 synchronized和Lock Lock接口及其实现类是JDK5增加的内容 其作者是大名

  • 详解Java锁对象

    1 Synchronized 1 1 synchronized特性 1 互斥 synchronized会起到互斥效果 某个线程执行到某个对象的synchronized中时 其他线程如果也执行到同一个对象synchronized就会阻塞等待

  • Synchronized（对象锁）和Static Synchronized（类锁）的区别

    Synchronized和Static Synchronized区别 通过分析这两个用法的分析 我们可以理解java中锁的概念 一个是实例锁 锁在某一个实例对象上 如果该类是单例 那么该锁也具有全局锁的概念 一个是全局锁 该锁针对的是类 无

  • 并发编程 三 synchronized

    多线程编程中 有可能会出现多个线程同时访问同一个共享 可变资源的情况 这个资源我们称之其为临界资源 这种资源可能是 对象 变量 文件等 由于线程执行的过程是不可控的 所以需要采用同步机制来协同对对象可变状态的访问 实际上 所有的并发模式在解

  • Java线程学习实例——采用同步锁，互斥锁与同步锁的区别，synchronized的使用方法

    栗子来源 https blog csdn net wenzhi20102321 article details 52524545 首先对java中同步锁与互斥锁进行区分 主要来源于知乎中的大佬总结如下 1 锁的概念 锁的目的就是避免多个线程

  • 13张图，带大家深入理解Synchronized

    目录 前言 内容大纲 Synchronized使用方式 普通函数 静态函数 代码块 Synchronized原理 Synchronized优化 锁粗化 锁消除 锁升级 偏向锁 轻量级锁 重量级锁 前言 Java并发编程系列第二篇Synchr

  • 对象锁和类锁的个人理解

    一 对象锁 1 解释 对象锁 顾名思义锁的是对象实例 但程序中同一个类可以有多个实例化对象 所以对象锁只能锁住同一个实例化对象 再两个或多个实例化对象之间不起作用 2 使用方法 1 锁住实体里的非静态变量 synchronized 变量名

  • 在 Java 临界区中，我应该同步什么？

    在 Java 中 在代码中声明临界区的惯用方法如下 private void doSomething thread safe code synchronized this thread unsafe code thread safe cod

  • java中的final变量和synchronized块

    Java中的final变量是什么 例如 如果我写final int temp 函数中final关键字的含义是什么 另外 我什么时候想使用final变量 既作为类变量又作为函数变量 为什么同步块中的变量必须声明为final Final 变量和

  • Java 同步方法...不同步

    对于我当前的 java 练习 我必须从 2 个不同的 Gmail 帐户获取邮件 我通过创建 Gmail 类的新实例来完成此操作 gmail 类扩展了线程 其中有一个同步方法 readMail 用于获取邮件并打印它 这个 readMail 方

  • 为什么 Java 同步不能按预期工作？

    我试图弄清楚同步方法是如何工作的 根据我的理解 我创建了两个线程T1 and T2这将调用相同的方法addNew 由于该方法是同步的 难道它不应该先为一个线程执行 for 循环的所有迭代 然后再为另一个线程执行吗 输出不断变化 有时打印正确

  • 当我们使用synchronized关键字时，什么会被锁定？ [复制]

    这个问题在这里已经有答案了 在阅读线程中的并发问题并通过以下方式处理它时 我想到了问题synchronized关键词是 当我们使用这个术语时lock它用于包含以下内容的对象run方法 或线程的工作 但是为什么我们不能使用这个术语lock仅适

  • java 中的 Thread.sleep() 与同步

    当 Thread sleep 10000 被调用时 当前线程将进入睡眠状态 如果在同步方法中调用Thread sleep 10000 那么在此期间其他线程是否可以执行 如果你这样做Thread sleep 10000 在同步方法中或阻止您d

  • Java中的互斥方法执行

    我有两种方法 a and b 虽然我可以接受多个线程同时访问任何方法 这是可取的 但我不希望任何线程进入a while b 正在被执行 我怎么做 Edit 1 假设有 4 个线程Thread 1正在访问A 我想要的是所有 4 个线程都不应该

  • java 中的同步 - 正确使用

    我正在构建一个在多进程 线程 中使用的简单程序 我的问题更容易理解 什么时候我必须使用保留字同步 我是否需要在影响骨骼变量的任何方法中使用这个词 我知道我可以将它放在任何非静态的方法上 但我想了解更多 谢谢你 这是代码 public cla

  • 如果一个同步方法调用另一个非同步方法，该非同步方法是否有锁

    在Java中 如果一个同步方法包含对非同步方法的调用 那么另一个方法是否仍然可以同时访问该非同步方法 基本上我要问的是同步方法中的所有内容都有锁 包括对其他同步方法的调用 如果一个同步方法调用另一个非同步方法 该非同步方法是否有锁 答案取决

  • Java中的多个对象锁？

    锁定私有字段变量 而不是使用锁定对象 是否安全 可接受的做法 这样 我就可以为不同的目的使用不同的锁 下面的例子 class Test private Integer x 0 private Integer y 0 public void

  • grails 上的同步块在 Windows 上有效，但在 Linux 上无效

    我有一个 grails 应用程序 它依赖于服务中的同步块 当我在 Windows 上运行它时 同步按预期工作 但当我在 ams linux 上运行时 会出现 StaleObjectStateException 该问题在以下示例中重现 cla

随机推荐

热门标签