Java synchronized 多线程同步问题详解

Eidesen 发布于2019-08-16 10:31 / 1958人阅读

摘要：同步代码块二类，锁是小括号中的类对象对象。因为对于同一个实例对象，各线程之间访问其中的同步方法是互斥的。优化同步代码块的方式有，减少同步区域或减小锁的范围。

1. 引言

在 Java 多线程编程中，我们常需要考虑线程安全问题，其中关键字 synchronized 在线程同步中就扮演了非常重要的作用。

下面就对 synchronized 进行详细的示例讲解，其中本文构建 thread 的写法是采用 Java 8 新增的 Lambda 表达式。如果你对 Lambda 表达式还不了解，可以查看我之前的文章《Java 8 Lambda 表达式详解》。

2. synchronized 锁的是什么

首先我们明确一点，synchronized 锁的不是代码，锁的都是对象。

锁的对象有以下几种：

同步非静态方法（synchronized method），锁是当前对象的实例对象。

同步静态方法（synchronized static method），锁是当前对象的类对象（Class 对象）。

同步代码块一（synchronized (this)，synchronized (类实例对象)），锁是小括号 () 中的实例对象。

同步代码块二（synchronized (类.class)），锁是小括号 () 中的类对象（Class 对象）。

2.1 实例对象锁与类对象锁

1）实例对象锁，不同的实例拥有不同的实例对象锁，所以对于同一个实例对象，在同一时刻只有一个线程可以访问这个实例对象的同步方法；不同的实例对象，不能保证多线程的同步操作。

2）类对象锁（全局锁），在 JVM 中一个类只有一个与之对应的类对象，所以在同一时刻只有一个线程可以访问这个类的同步方法。

3. 示例分析 3.1 同步非静态实例方法

同步非静态方法，实际上锁定的是当前对象的实例对象。在同一时刻只有一个线程可以访问该实例的同步方法，但对于多个实例的同步方法，不同实例之间对同步方法的访问是不受同步影响（synchronized 同步失效）。

首先我们尝试下，synchronized 同步失败的情况：

package com.wuxianjiezh.demo.threadpool;

public class MainTest {

    public static void main(String[] args) {
        Bank xMBank = new Bank();
        Bank xGBank = new Bank();
        Bank xHBank = new Bank();
        Thread xMThread = new Thread(() -> xMBank.deposit(xMBank, 200), "小明");
        Thread xGThread = new Thread(() -> xGBank.deposit(xGBank, 200), "小刚");
        Thread xHThread = new Thread(() -> xHBank.deposit(xHBank, 200), "小红");
        xMThread.start();
        xGThread.start();
        xHThread.start();
    }
}

class Bank {

    private int money = 1000;

    public synchronized void deposit(Bank bank, int money) {
        // synchronized (this) { // 同步方法块（实例对象）
        // synchronized (bank) { // 同步方法块（实例对象）
            String threadName = Thread.currentThread().getName();
            System.out.println(threadName + "--当前银行余额为：" + this.money);
            this.money += money;
            System.out.println(threadName + "--存入后银行余额为：" + this.money);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        // }
    }
}

运行结果：

小明--当前银行余额为：1000
小刚--当前银行余额为：1000
小明--存入后银行余额为：1200
小红--当前银行余额为：1000
小刚--存入后银行余额为：1200
小红--存入后银行余额为：1200

从上面的运行结果，我们发现对 Bank 中 money 的操作并没有同步，synchronized 失效了？

这是因为实例对象锁，只对同一个实例生效，对同一个对象的不同实例不保证同步。

修改上述代码，实现同步操作。这里将有两种方案：只实例化一个或在方法块中的锁定类对象。

方案一、多个线程只对同一个实例对象操作：

package com.wuxianjiezh.demo.threadpool;

public class MainTest {

    public static void main(String[] args) {
        Bank xMBank = new Bank();
        // Bank xGBank = new Bank();
        // Bank xHBank = new Bank();
        Thread xMThread = new Thread(() -> xMBank.deposit(xMBank, 200), "小明");
        Thread xGThread = new Thread(() -> xMBank.deposit(xMBank, 200), "小刚");
        Thread xHThread = new Thread(() -> xMBank.deposit(xMBank, 200), "小红");
        xMThread.start();
        xGThread.start();
        xHThread.start();
    }
}

class Bank {

    private int money = 1000;

    public synchronized void deposit(Bank bank, int money) {
        // synchronized (this) { // 同步方法块（实例对象）
        // synchronized (bank) { // 同步方法块（实例对象）
            String threadName = Thread.currentThread().getName();
            System.out.println(threadName + "--当前银行余额为：" + this.money);
            this.money += money;
            System.out.println(threadName + "--存入后银行余额为：" + this.money);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        // }
    }
}

运行结果：

小明--当前银行余额为：1000
小明--存入后银行余额为：1200
小红--当前银行余额为：1200
小红--存入后银行余额为：1400
小刚--当前银行余额为：1400
小刚--存入后银行余额为：1600
...

可以看到，结果正确执行。因为对于同一个实例对象，各线程之间访问其中的同步方法是互斥的。

方案二、在方法块中锁定类对象：

package com.wuxianjiezh.demo.threadpool;

public class MainTest {

    public static void main(String[] args) {
        Bank xMBank = new Bank();
        Bank xGBank = new Bank();
        Bank xHBank = new Bank();
        Thread xMThread = new Thread(() -> xMBank.deposit(xMBank, 200), "小明");
        Thread xGThread = new Thread(() -> xGBank.deposit(xGBank, 200), "小刚");
        Thread xHThread = new Thread(() -> xHBank.deposit(xHBank, 200), "小红");
        xMThread.start();
        xGThread.start();
        xHThread.start();
    }
}

class Bank {

    private int money = 1000;

    public void deposit(Bank bank, int money) {
        synchronized (Bank.class) { // 全局锁
            String threadName = Thread.currentThread().getName();
            System.out.println(threadName + "--当前银行余额为：" + this.money);
            this.money += money;
            System.out.println(threadName + "--存入后银行余额为：" + this.money);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

运行结果：

小明--当前银行余额为：1000
小明--存入后银行余额为：1200
小红--当前银行余额为：1000
小红--存入后银行余额为：1200
小刚--当前银行余额为：1000
小刚--存入后银行余额为：1200

思考：从结果中我们发现，线程是同步操作了，但为什么在我们的 money 怎么才 1200 啊？

要回答上面问题也很简单，首先线程是同步操作了，这个没有疑问，说明我们的全局锁生效了，那为什么钱少了，因为我们这里 mew 了三个对象，三个对象都有各自的 money，他们并不共享，所以最后都是 1200，最终一共还是增加了 6000，钱一点没有少喔。

那有没有办法，让这些线程间共享 money 呢？方法很简单，只要设置 money 为 static 即可。

3.1.1 对同步代码块优化的思考

对于一个方法，可能包含多个操作部分，而每个操作部分的消耗各不相同，而且并不是所有的操作都是需要同步控制的，那么，是否可以将那些影响效率，又不需要同步操作的内容，提取到同步代码块外呢？

请看以下示例：

package com.wuxianjiezh.demo.threadpool;

public class MainTest {

    public static void main(String[] args) {
        Bank xMBank = new Bank();
        Bank xGBank = new Bank();
        Bank xHBank = new Bank();
        Thread xMThread = new Thread(() -> xMBank.deposit(xMBank, 200), "小明");
        Thread xGThread = new Thread(() -> xGBank.deposit(xGBank, 200), "小刚");
        Thread xHThread = new Thread(() -> xHBank.deposit(xHBank, 200), "小红");
        xMThread.start();
        xGThread.start();
        xHThread.start();
    }
}

class Bank {

    private int money = 1000;

    public void deposit(Bank bank, int money) {
        String threadName = Thread.currentThread().getName();
        synchronized (Bank.class) { // 同步方法块（实例对象）
            System.out.println(threadName + "--当前银行余额为：" + this.money);
            this.money += money;
            System.out.println(threadName + "--存入后银行余额为：" + this.money);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        try {
            // 假设这里是非常耗时，并且不需要同步控制的操作
            Thread.sleep(2000);
            System.out.println(threadName + "--和钱无关，不需要同步控制的操作");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

运行结果：

小明--当前银行余额为：1000
小明--存入后银行余额为：1200
小红--当前银行余额为：1000
小红--存入后银行余额为：1200
小刚--当前银行余额为：1000
小刚--存入后银行余额为：1200
小明--和钱无关，不需要同步控制的操作
小红--和钱无关，不需要同步控制的操作
小刚--和钱无关，不需要同步控制的操作

这时发现，各线程虽然都有自己的实例化对象，但其中操作 money 的部分是同步的，对于与 money 无关的操作则又是异步的。

结论：可以通过减少同步区域来优化同步代码块。

3.1.2 对同步代码块优化的思考（进阶）

我们知道同步的对象不是实例对象就是类对象。现在假设一个类有多个同步方法，那么当某个线程进入其中一个同步方法时，这个类的其它同步方法也会被锁住，造成其它与当前锁定操作的同步方法毫无关系的同步方法也被锁住，最后的结果就是影响了整个多线程执行的性能，使原本不需要互斥的方法也都进行了互斥操作。比如：

package com.wuxianjiezh.demo.threadpool;

public class MainTest {

    public static void main(String[] args) {
        Bank xMBank = new Bank();
        Thread xMThread = new Thread(() -> xMBank.deposit(xMBank, 200), "小明");
        Thread xGThread = new Thread(xMBank::showInfo, "小刚");
        xMThread.start();
        xGThread.start();
    }
}

class Bank {

    private int money = 1000;

    public void deposit(Bank bank, int money) {
        long begin = System.currentTimeMillis();

        String threadName = Thread.currentThread().getName();
        synchronized (this) { // 同步方法块（实例对象）
            this.money += money;
            try {
                System.out.println(threadName + "--当前银行余额为：" + this.money);
                // 模拟一个非常耗时的操作
                Thread.sleep(5000);
                System.out.println(threadName + "--存入后银行余额为：" + this.money);

                long end = System.currentTimeMillis();
                System.out.println(threadName + "--存入耗时：" + (end - begin));
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * 一个与资金操作没有任务关系的同步方法
     */
    public void showInfo() {
        long begin = System.currentTimeMillis();

        String threadName = Thread.currentThread().getName();
        synchronized (this) {
            try {
                System.out.println(threadName + "--开始查看银行信息");
                Thread.sleep(5000);
                System.out.println(threadName + "--银行详细信息...");

                long end = System.currentTimeMillis();
                System.out.println(threadName + "--查看耗时：" + (end - begin));
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

运行结果：

小明--当前银行余额为：1200
小明--存入后银行余额为：1200
小明--存入耗时：5000
小刚--开始查看银行信息
小刚--银行详细信息...
小刚--查看耗时：10000

从运行结果中，我们看到小刚这个线程平白无故多等了 5 秒钟，严重影响了线程性能。

针对上面的情况，我们可以采用多个实例对象锁的方案解决，比如：

package com.wuxianjiezh.demo.threadpool;

public class MainTest {

    public static void main(String[] args) {
        Bank xMBank = new Bank();
        Thread xMThread = new Thread(() -> xMBank.deposit(xMBank, 200), "小明");
        Thread xGThread = new Thread(xMBank::showInfo, "小刚");
        xMThread.start();
        xGThread.start();
    }
}

class Bank {

    private int money = 1000;

    private final Object syncDeposit = new Object(); // 同步锁
    private final Object syncShowInfo = new Object(); // 同步锁

    public void deposit(Bank bank, int money) {
        long begin = System.currentTimeMillis();

        String threadName = Thread.currentThread().getName();
        synchronized (this.syncDeposit) { // 同步方法块（实例对象）
            this.money += money;
            try {
                System.out.println(threadName + "--当前银行余额为：" + this.money);
                // 模拟一个非常耗时的操作
                Thread.sleep(5000);
                System.out.println(threadName + "--存入后银行余额为：" + this.money);

                long end = System.currentTimeMillis();
                System.out.println(threadName + "--存入耗时：" + (end - begin));
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * 一个与资金操作没有任务关系的同步方法
     */
    public void showInfo() {
        long begin = System.currentTimeMillis();

        String threadName = Thread.currentThread().getName();
        synchronized (this.syncShowInfo) {
            try {
                System.out.println(threadName + "--开始查看银行信息");
                Thread.sleep(5000);
                System.out.println(threadName + "--银行详细信息...");

                long end = System.currentTimeMillis();
                System.out.println(threadName + "--查看耗时：" + (end - begin));
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

运行结果：

小刚--开始查看银行信息
小明--当前银行余额为：1200
小刚--银行详细信息...
小明--存入后银行余额为：1200
小明--存入耗时：5000
小刚--查看耗时：5000

我们发现，两个线程间同步被取消了，性能问题也解决了。

总结：可以创建不同同步方法的不同同步锁（减小锁的范围）来优化同步代码块。

3.2 同步静态方法

同步静态方法，锁的是类对象而不是某个实例对象，所以可以理解为对于静态方法的锁是全局的锁，同步也是全局的同步。

package com.wuxianjiezh.demo.threadpool;

public class MainTest {

    public static void main(String[] args) {
        Bank xMBank = new Bank();
        Bank xGBank = new Bank();
        Bank xHBank = new Bank();
        Thread xMThread = new Thread(() -> xMBank.deposit(xMBank, 200), "小明");
        Thread xGThread = new Thread(() -> xGBank.deposit(xGBank, 200), "小刚");
        Thread xHThread = new Thread(() -> xHBank.deposit(xHBank, 200), "小红");
        xMThread.start();
        xGThread.start();
        xHThread.start();
    }
}

class Bank {

    private static int money = 1000;

    public synchronized static void deposit(Bank bank, int money) {
        // synchronized (Bank.class) { // 全局锁
        String threadName = Thread.currentThread().getName();
        System.out.println(threadName + "--当前银行余额为：" + Bank.money);
        Bank.money += money;
        System.out.println(threadName + "--存入后银行余额为：" + Bank.money);
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        // }
    }
}

运行结果：

小明--当前银行余额为：1000
小明--存入后银行余额为：1200
小红--当前银行余额为：1200
小红--存入后银行余额为：1400
小刚--当前银行余额为：1400
小刚--存入后银行余额为：1600

4. 总结

同步锁 synchronized 要点：

synchronized 锁的不是代码，锁的都是对象。

实例对象锁：同步非静态方法（synchronized method），同步代码块（synchronized (this)，synchronized (类实例对象)）。

类对象（Class 对象）锁：同步静态方法（synchronized static method），同步代码块（synchronized (类.class)）。

相同对象的不同的实例拥有不同的实例对象锁，但类对象锁（全局锁）有仅只有一个。

优化同步代码块的方式有，减少同步区域或减小锁的范围。

云服务器超融合服务器多线程synchronized Java多线程同步 java多线程同步锁 java多线程问题

文章版权归作者所有，未经允许请勿转载,若此文章存在违规行为，您可以联系管理员删除。

转载请注明本文地址：https://www.ucloud.cn/yun/69948.html

synchronized关键字使用详解

摘要：基本使用同步代码块同步代码块延时秒，方便后面测试作用代码块时，方法中的，是指调用该方法的对象。那么这个时候使用关键字就需要注意了推荐使用同步代码块，同步的代码块中传入外部定义的一个变量。简述计算机单线程在执行任务时，是严格按照程序的代码逻辑，按照顺序执行的。因此单位时间内能执行的任务数量有限。为了能在相同的时间内能执行更多的任务，就必须采用多线程的方式来执行（注意：多线程模式无法减...

Jeffrrey 2019-08-16 17:09 评论0 收藏0
40道阿里巴巴JAVA研发岗多线程面试题详解，你能答出多少

摘要：但是单核我们还是要应用多线程，就是为了防止阻塞。多线程可以防止这个问题，多条线程同时运行，哪怕一条线程的代码执行读取数据阻塞，也不会影响其它任务的执行。 1、多线程有什么用？一个可能在很多人看来很扯淡的一个问题：我会用多线程就好了，还管它有什么用？在我看来，这个回答更扯淡。所谓知其然知其所以然，会用只是知其然，为什么用才是知其所以然，只有达到知其然知其所以然的程度才可以说是把一个知识点...

lpjustdoit 2019-08-16 18:36 评论0 收藏0
一起学并发编程 - synchronized详解

摘要：每个对象只有一个锁与之相关联。实现同步则是以系统开销作为代价，甚至可能造成死锁，所以尽量避免滥用。这种机制确保了同一时刻该类实例，所有声明为的函数中只有一个方法处于可执行状态，从而有效避免了类成员变量访问冲突。 synchronized是JAVA语言的一个关键字，使用 synchronized 来修饰方法或代码块的时候，能够保证多个线程中最多只有一个线程执行该段代码 ... 概述 ...

acrazing 2019-08-15 11:57 评论0 收藏0
Java 多线程核心技术梳理(附源码)

摘要：本文对多线程基础知识进行梳理，主要包括多线程的基本使用，对象及变量的并发访问，线程间通信，的使用，定时器，单例模式，以及线程状态与线程组。源码采用构建，多线程这部分源码位于模块中。通知可能等待该对象的对象锁的其他线程。本文对多线程基础知识进行梳理，主要包括多线程的基本使用，对象及变量的并发访问，线程间通信，lock的使用，定时器，单例模式，以及线程状态与线程组。写在前面花了一周时...

Winer 2019-08-16 11:46 评论0 收藏0
Java锁，真的有这么复杂吗？

摘要：撤销锁偏向锁使用了一种等到竞争出现才释放锁的机制，所以当其他线程尝试竞争偏向锁时，持有偏向锁的线程才会释放锁。轻量级锁线程在执行同步代码块之前，会先在当前线程的栈桢中创建用于存储锁记录的空间，并将对象头中的复制到锁记录中，官方称为。前言作者前面也写了几篇关于Java并发编程，以及线程和volatil的基础知识，有兴趣可以阅读作者的原文博客，今天关于Java中的两种锁进行详解，希望对...

rainyang 2019-06-25 12:49 评论0 收藏0