Java synchronized 多线程同步问题详解

拼搏现实的明天。 2024-04-18 08:55 84阅读 0赞

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

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

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

## 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 要点：

1.  synchronized 锁的不是代码，锁的都是对象。
2.  实例对象锁：同步非静态方法（synchronized method），同步代码块（synchronized (this)，synchronized (类实例对象)）。
3.  类对象（Class 对象）锁：同步静态方法（synchronized static method），同步代码块（synchronized (类.class)）。
4.  相同对象的不同的实例拥有不同的实例对象锁，但类对象锁（全局锁）有仅只有一个。
5.  优化同步代码块的方式有，减少同步区域或减小锁的范围。