学习目标

  • 理解Java中对象锁与类锁的概念与区别
  • 掌握synchronized修饰方法与代码块的不同使用方式
  • 了解synchronized的底层实现原理
  • 能够使用synchronized解决实际并发问题

1. 对象锁与类锁的概念

在多线程环境中，当多个线程同时访问共享资源时，可能会导致数据不一致。Java提供了synchronized关键字来解决这个问题，它通过锁机制确保同一时刻只有一个线程可以执行被保护的代码。在Java中，锁主要分为两种：对象锁和类锁。

1.1 对象锁（实例锁）

对象锁是Java中最常见的锁类型，它锁定的是特定的对象实例。当一个线程获取了某个对象的锁后，其他线程必须等待这个线程释放锁后才能获取该对象的锁。 对象锁的获取方式有两种：

  1. 同步实例方法：synchronized修饰非静态方法
  2. 同步代码块：synchronized(this)或synchronized(实例对象)

看一个简单的对象锁示例：

  1. package org.devlive.tutorial.multithreading.chapter05;
  3. import java.util.concurrent.TimeUnit;
  5. public class ObjectLockDemo {
  6.     // 定义一个共享变量
  7.     private int counter = 0;
  9.     // 使用synchronized修饰实例方法，锁是当前对象(this)
  10.     public synchronized void incrementSync() {
  11.         counter++;
  12.         System.out.println(Thread.currentThread().getName() + " - 计数器：" + counter);
  13.         try {
  14.             // 线程睡眠500毫秒，便于观察效果
  15.             TimeUnit.MILLISECONDS.sleep(500);
  16.         } catch (InterruptedException e) {
  17.             e.printStackTrace();
  18.         }
  19.     }
  21.     // 使用synchronized代码块，锁是当前对象(this)
  22.     public void incrementSyncBlock() {
  23.         synchronized (this) {
  24.             counter++;
  25.             System.out.println(Thread.currentThread().getName() + " - 计数器：" + counter);
  26.             try {
  27.                 // 线程睡眠500毫秒，便于观察效果
  28.                 TimeUnit.MILLISECONDS.sleep(500);
  29.             } catch (InterruptedException e) {
  30.                 e.printStackTrace();
  31.             }
  32.         }
  33.     }
  35.     public static void main(String[] args) {
  36.         final ObjectLockDemo demo = new ObjectLockDemo();
  38.         // 创建5个线程并发执行同步方法
  39.         for (int i = 0; i < 5; i++) {
  40.             new Thread(() -> {
  41.                 demo.incrementSync();
  42.             }, "线程-" + i).start();
  43.         }
  44.     }
  45. }

运行上述代码，你会发现5个线程是按顺序执行incrementSync方法的，而不是并发执行。这是因为synchronized保证了同一时刻只有一个线程能够获取到对象锁并执行同步方法。

提示： 对象锁只对同一个对象实例有效。如果创建了多个对象实例，每个实例都有自己的对象锁，不同实例的锁互不干扰。

1.2 类锁（静态锁）

类锁是Java中另一种重要的锁类型，它锁定的是类而不是对象实例。无论创建了多少个实例，一个类只有一个类锁。当一个线程获取了某个类的类锁后，其他线程必须等待这个线程释放锁后才能获取该类的类锁。 类锁的获取方式有两种：

  1. 同步静态方法：synchronized修饰静态方法
  2. 同步代码块：synchronized(类名.class)

看一个类锁的示例：

  1. package org.devlive.tutorial.multithreading.chapter05;
  3. import java.util.concurrent.TimeUnit;
  5. public class ClassLockDemo {
  6.     // 静态计数器
  7.     private static int counter = 0;
  9.     // 使用synchronized修饰静态方法，锁是当前类的Class对象
  10.     public static synchronized void incrementStatic() {
  11.         counter++;
  12.         System.out.println(Thread.currentThread().getName() + " - 计数器：" + counter);
  13.         try {
  14.             TimeUnit.MILLISECONDS.sleep(500);
  15.         } catch (InterruptedException e) {
  16.             e.printStackTrace();
  17.         }
  18.     }
  20.     // 使用synchronized代码块锁定类对象
  21.     public void incrementWithClassLock() {
  22.         synchronized (ClassLockDemo.class) {
  23.             counter++;
  24.             System.out.println(Thread.currentThread().getName() + " - 计数器：" + counter);
  25.             try {
  26.                 TimeUnit.MILLISECONDS.sleep(500);
  27.             } catch (InterruptedException e) {
  28.                 e.printStackTrace();
  29.             }
  30.         }
  31.     }
  33.     public static void main(String[] args) {
  34.         // 创建两个不同的实例
  35.         final ClassLockDemo demo1 = new ClassLockDemo();
  36.         final ClassLockDemo demo2 = new ClassLockDemo();
  38.         // 创建5个线程，使用不同实例的方法
  39.         for (int i = 0; i < 5; i++) {
  40.             if (i % 2 == 0) {
  41.                 new Thread(() -> {
  42.                     ClassLockDemo.incrementStatic(); // 使用静态方法（类锁）
  43.                 }, "静态方法线程-" + i).start();
  44.             } else {
  45.                 new Thread(() -> {
  46.                     demo2.incrementWithClassLock(); // 使用实例方法中的类锁
  47.                 }, "类锁代码块-" + i).start();
  48.             }
  49.         }
  50.     }
  51. }

运行上述代码，你会发现无论是通过静态方法还是通过类锁代码块访问，所有线程都必须排队执行，因为它们争夺的是同一个类锁。

重要概念： 类锁实际上是锁定类的Class对象。在Java中，无论一个类有多少个对象实例，这个类只有一个Class对象，所以类锁也只有一个。

1.3 对象锁与类锁的对比

下面通过一个示例来展示对象锁与类锁的区别：

  1. package org.devlive.tutorial.multithreading.chapter05;
  3. import java.util.concurrent.TimeUnit;
  5. public class LockComparisonDemo {
  6.     // 实例变量
  7.     private int instanceCounter = 0;
  8.     // 静态变量
  9.     private static int staticCounter = 0;
  11.     // 对象锁方法
  12.     public synchronized void incrementInstance() {
  13.         instanceCounter++;
  14.         System.out.println(Thread.currentThread().getName() + " - 实例计数器：" + instanceCounter);
  15.         try {
  16.             TimeUnit.SECONDS.sleep(1);
  17.         } catch (InterruptedException e) {
  18.             e.printStackTrace();
  19.         }
  20.     }
  22.     // 类锁方法
  23.     public static synchronized void incrementStatic() {
  24.         staticCounter++;
  25.         System.out.println(Thread.currentThread().getName() + " - 静态计数器：" + staticCounter);
  26.         try {
  27.             TimeUnit.SECONDS.sleep(1);
  28.         } catch (InterruptedException e) {
  29.             e.printStackTrace();
  30.         }
  31.     }
  33.     public static void main(String[] args) {
  34.         // 创建同一个实例
  35.         final LockComparisonDemo demo = new LockComparisonDemo();
  37.         // 线程1：访问实例方法（对象锁）
  38.         new Thread(() -> {
  39.             for (int i = 0; i < 3; i++) {
  40.                 demo.incrementInstance();
  41.             }
  42.         }, "对象锁线程").start();
  44.         // 线程2：访问静态方法（类锁）
  45.         new Thread(() -> {
  46.             for (int i = 0; i < 3; i++) {
  47.                 LockComparisonDemo.incrementStatic();
  48.             }
  49.         }, "类锁线程").start();
  51.         // 关键点：对象锁和类锁是相互独立的，不会互相阻塞
  52.     }
  53. }

运行这段代码，你会发现”对象锁线程”和”类锁线程”是并发执行的，这说明对象锁和类锁互不干扰。这是因为它们锁定的是不同的对象：对象锁锁定的是实例对象，而类锁锁定的是Class对象。

2. synchronized修饰方法与代码块的区别

synchronized关键字可以修饰方法或代码块，它们有一些重要的区别。

2.1 修饰方法 vs 修饰代码块

  1. 锁的粒度不同
    • 修饰方法：锁的是整个方法体
    • 修饰代码块：只锁定特定的代码块
  2. 性能影响
    • 修饰方法：可能导致锁的持有时间过长
    • 修饰代码块：可以精确控制锁的范围，提高并发性能
  3. 灵活性
    • 修饰方法：简单直观，但不够灵活
    • 修饰代码块：可以指定不同的锁对象，更加灵活

下面是一个对比示例：

  1. package org.devlive.tutorial.multithreading.chapter05;
  3. import java.util.concurrent.TimeUnit;
  5. public class SynchronizedComparison {
  7.     private int data = 0;
  9.     // 修饰整个方法
  10.     public synchronized void methodSync() {
  11.         System.out.println(Thread.currentThread().getName() + " 开始执行方法同步...");
  13.         // 执行一些非同步操作（假设是耗时的IO操作）
  14.         try {
  15.             System.out.println(Thread.currentThread().getName() + " 执行耗时操作...");
  16.             TimeUnit.SECONDS.sleep(2);
  17.         } catch (InterruptedException e) {
  18.             e.printStackTrace();
  19.         }
  21.         // 真正需要同步的只是这部分数据操作
  22.         data++;
  23.         System.out.println(Thread.currentThread().getName() + " 数据更新为：" + data);
  25.         // 再次执行一些非同步操作
  26.         try {
  27.             System.out.println(Thread.currentThread().getName() + " 执行额外操作...");
  28.             TimeUnit.SECONDS.sleep(1);
  29.         } catch (InterruptedException e) {
  30.             e.printStackTrace();
  31.         }
  33.         System.out.println(Thread.currentThread().getName() + " 方法执行完毕");
  34.     }
  36.     // 只同步关键代码块
  37.     public void blockSync() {
  38.         System.out.println(Thread.currentThread().getName() + " 开始执行方法...");
  40.         // 执行一些非同步操作（假设是耗时的IO操作）
  41.         try {
  42.             System.out.println(Thread.currentThread().getName() + " 执行耗时操作...");
  43.             TimeUnit.SECONDS.sleep(2);
  44.         } catch (InterruptedException e) {
  45.             e.printStackTrace();
  46.         }
  48.         // 只同步关键代码块
  49.         synchronized(this) {
  50.             data++;
  51.             System.out.println(Thread.currentThread().getName() + " 数据更新为：" + data);
  52.         }
  54.         // 再次执行一些非同步操作
  55.         try {
  56.             System.out.println(Thread.currentThread().getName() + " 执行额外操作...");
  57.             TimeUnit.SECONDS.sleep(1);
  58.         } catch (InterruptedException e) {
  59.             e.printStackTrace();
  60.         }
  62.         System.out.println(Thread.currentThread().getName() + " 方法执行完毕");
  63.     }
  65.     public static void main(String[] args) {
  66.         SynchronizedComparison demo = new SynchronizedComparison();
  68.         System.out.println("====== 测试方法同步 ======");
  69.         Thread t1 = new Thread(() -> demo.methodSync(), "线程1");
  70.         Thread t2 = new Thread(() -> demo.methodSync(), "线程2");
  71.         t1.start();
  72.         t2.start();
  74.         // 等待两个线程执行完毕
  75.         try {
  76.             t1.join();
  77.             t2.join();
  78.         } catch (InterruptedException e) {
  79.             e.printStackTrace();
  80.         }
  82.         System.out.println("\n====== 测试代码块同步 ======");
  83.         demo.data = 0; // 重置数据
  84.         Thread t3 = new Thread(() -> demo.blockSync(), "线程3");
  85.         Thread t4 = new Thread(() -> demo.blockSync(), "线程4");
  86.         t3.start();
  87.         t4.start();
  88.     }
  89. }

运行上述代码，你会发现：

  • 在方法同步中，第二个线程必须等第一个线程完全执行完整个方法才能开始执行。
  • 在代码块同步中，两个线程可以并发执行方法中的非同步部分，只有在执行同步代码块时才需要等待。

这说明了代码块同步相比方法同步可以提高并发性能，尤其是在方法中包含大量非同步操作的情况下。

2.2 不同锁对象的选择

在使用synchronized代码块时，可以选择不同的锁对象。锁对象的选择会影响并发行为：

  1. package org.devlive.tutorial.multithreading.chapter05;
  3. import java.util.concurrent.TimeUnit;
  5. public class LockObjectDemo {
  7.     // 定义不同的锁对象
  8.     private final Object lockA = new Object();
  9.     private final Object lockB = new Object();
  11.     private int counterA = 0;
  12.     private int counterB = 0;
  14.     // 使用lockA作为锁对象
  15.     public void incrementA() {
  16.         synchronized (lockA) {
  17.             counterA++;
  18.             System.out.println(Thread.currentThread().getName() + " - 计数器A：" + counterA);
  19.             try {
  20.                 TimeUnit.SECONDS.sleep(1);
  21.             } catch (InterruptedException e) {
  22.                 e.printStackTrace();
  23.             }
  24.         }
  25.     }
  27.     // 使用lockB作为锁对象
  28.     public void incrementB() {
  29.         synchronized (lockB) {
  30.             counterB++;
  31.             System.out.println(Thread.currentThread().getName() + " - 计数器B：" + counterB);
  32.             try {
  33.                 TimeUnit.SECONDS.sleep(1);
  34.             } catch (InterruptedException e) {
  35.                 e.printStackTrace();
  36.             }
  37.         }
  38.     }
  40.     public static void main(String[] args) {
  41.         LockObjectDemo demo = new LockObjectDemo();
  43.         // 线程1：访问A资源
  44.         new Thread(() -> {
  45.             for (int i = 0; i < 3; i++) {
  46.                 demo.incrementA();
  47.             }
  48.         }, "线程A").start();
  50.         // 线程2：访问B资源
  51.         new Thread(() -> {
  52.             for (int i = 0; i < 3; i++) {
  53.                 demo.incrementB();
  54.             }
  55.         }, "线程B").start();
  57.         // 线程3：也访问A资源
  58.         new Thread(() -> {
  59.             for (int i = 0; i < 3; i++) {
  60.                 demo.incrementA();
  61.             }
  62.         }, "线程C").start();
  63.     }
  64. }

运行上述代码，你会观察到：

  • “线程A”和”线程C”会互相阻塞，因为它们使用了相同的锁对象lockA
  • “线程B”独立执行，不受其他线程影响，因为它使用了不同的锁对象lockB

这种方式称为”细粒度锁”，可以提高程序的并发性能。但是要注意，使用不同的锁对象也会增加程序的复杂性，可能导致死锁问题。

最佳实践： 选择锁对象时，应该遵循以下原则：

  1. 使用final修饰锁对象，防止锁对象被修改
  2. 不要使用String常量或基本类型的包装类作为锁对象
  3. 尽量避免使用公共对象（如全局变量）作为锁对象

3. synchronized的底层实现原理

要深入理解synchronized，我们需要了解它的底层实现原理。

3.1 Monitor监视器

synchronized的底层实现是基于Monitor（监视器）机制。在Java虚拟机中，每个对象都有一个与之关联的Monitor。当线程执行到synchronized代码块时，会尝试获取Monitor的所有权：

如果Monitor没有被占用，线程获取Monitor的所有权并继续执行 如果Monitor已被其他线程占用，当前线程会被阻塞，进入Monitor的等待队列

以下是这个过程的简化图示：

  1. 线程A                      对象的Monitor             线程B
  2.   |                             |                   |
  3.   |  尝试获取Monitor所有权      |                   |
  4.   | -------------------------> |                   |
  5.   |                             |                   |
  6.   |  获取成功，执行同步代码块    |                   |
  7.   |                             |                   |
  8.   |                             |  尝试获取Monitor所有权
  9.   |                             | <-----------------
  10.   |                             |                   |
  11.   |                             |  被阻塞，进入等待队列
  12.   |                             |                   |
  13.   |  释放Monitor所有权          |                   |
  14.   | -------------------------> |                   |
  15.   |                             |                   |
  16.   |                             |  获取Monitor所有权
  17.   |                             | ----------------> |
  18.   |                             |                   |
  19.   |                             |  执行同步代码块    |

3.2 字节码层面的实现

在Java字节码层面，synchronized的实现依赖于monitorenter和monitorexit指令：

  • monitorenter：进入同步代码块时，尝试获取Monitor
  • monitorexit：退出同步代码块时，释放Monitor

我们可以通过javap命令反编译字节码来查看这些指令。以下是一个简单示例：

  1. package org.devlive.tutorial.multithreading.chapter05;
  3. public class SynchronizedBytecode {
  4.     public void syncBlock() {
  5.         synchronized (this) {
  6.             System.out.println("同步代码块");
  7.         }
  8.     }
  10.     public synchronized void syncMethod() {
  11.         System.out.println("同步方法");
  12.     }
  13. }

使用javap命令查看字节码（在编译后的目录中执行）：

  1. javap -c org.devlive.tutorial.multithreading.chapter05.SynchronizedBytecode

你会看到类似下面的输出（简化版）：

  1. public void syncBlock();
  2.   Code:
  3.     0: aload_0
  4.     1: dup
  5.     2: astore_1
  6.     3: monitorenter  // 进入同步块
  7.     4: getstatic     #2  // System.out
  8.     ...
  9.     12: aload_1
  10.     13: monitorexit   // 退出同步块
  11.     ...
  13. public synchronized void syncMethod();
  14.   Code:
  15.     0: getstatic     #2  // System.out
  16.     ...
  17.     // 注意没有明显的monitorenter和monitorexit指令

从字节码可以看出：

  • 同步代码块是通过monitorenter和monitorexit指令实现的
  • 同步方法是通过方法修饰符ACC_SYNCHRONIZED标记实现的，JVM会根据这个标记自动加锁和释放锁

3.3 锁的优化

随着Java版本的演进，synchronized的性能得到了极大的优化。JDK 1.6引入了锁的升级机制，将锁分为以下几种状态：

  1. 偏向锁：偏向于第一个获取锁的线程，如果该线程后续继续获取该锁，不需要进行同步操作
  2. 轻量级锁：使用CAS（Compare and Swap）操作尝试获取锁，避免线程阻塞
  3. 重量级锁：传统的锁机制，会导致线程阻塞和上下文切换

锁的状态会随着竞争的激烈程度自动升级，但不会降级。这种机制大大提高了synchronized的性能。

提示： JDK 1.6之前，synchronized被称为”重量级锁”，性能较差。但经过优化后，现代JVM中的synchronized性能已经非常好，在大多数场景下可以放心使用。

4. 实战案例：使用synchronized解决银行账户并发问题

现在，让我们通过一个实际案例来应用synchronized关键字解决并发问题。

4.1 问题描述：银行账户转账

假设有一个银行系统，需要处理账户之间的转账操作。在多线程环境下，如果不加锁控制，可能会出现以下问题：

  • 账户余额计算错误
  • 转账金额丢失
  • 账户余额为负数

4.2 不安全的实现

首先，我们看一个不使用同步机制的实现：

  1. package org.devlive.tutorial.multithreading.chapter05;
  3. import java.util.concurrent.CountDownLatch;
  4. import java.util.concurrent.ExecutorService;
  5. import java.util.concurrent.Executors;
  7. public class BankAccountUnsafe {
  8.     // 账户类
  9.     static class Account {
  10.         private int id;
  11.         private double balance;
  13.         public Account(int id, double initialBalance) {
  14.             this.id = id;
  15.             this.balance = initialBalance;
  16.         }
  18.         public void deposit(double amount) {
  19.             double newBalance = balance + amount;
  21.             // 模拟一些耗时操作，使问题更容易出现
  22.             try {
  23.                 Thread.sleep(10);
  24.             } catch (InterruptedException e) {
  25.                 e.printStackTrace();
  26.             }
  28.             balance = newBalance;
  29.         }
  31.         public void withdraw(double amount) {
  32.             if (balance >= amount) {
  33.                 double newBalance = balance - amount;
  35.                 // 模拟一些耗时操作
  36.                 try {
  37.                     Thread.sleep(10);
  38.                 } catch (InterruptedException e) {
  39.                     e.printStackTrace();
  40.                 }
  42.                 balance = newBalance;
  43.             } else {
  44.                 System.out.println("账户" + id + "余额不足，无法取款");
  45.             }
  46.         }
  48.         public double getBalance() {
  49.             return balance;
  50.         }
  52.         public int getId() {
  53.             return id;
  54.         }
  55.     }
  57.     // 转账操作
  58.     static class TransferTask implements Runnable {
  59.         private Account fromAccount;
  60.         private Account toAccount;
  61.         private double amount;
  63.         public TransferTask(Account fromAccount, Account toAccount, double amount) {
  64.             this.fromAccount = fromAccount;
  65.             this.toAccount = toAccount;
  66.             this.amount = amount;
  67.         }
  69.         @Override
  70.         public void run() {
  71.             System.out.println(Thread.currentThread().getName() + " 准备从账户" + fromAccount.getId() + 
  72.                     "转账" + amount + "元到账户" + toAccount.getId());
  74.             // 取款
  75.             fromAccount.withdraw(amount);
  76.             // 存款
  77.             toAccount.deposit(amount);
  79.             System.out.println(Thread.currentThread().getName() + " 完成转账！");
  80.         }
  81.     }
  83.     public static void main(String[] args) throws InterruptedException {
  84.         // 创建两个账户
  85.         Account accountA = new Account(1, 1000);
  86.         Account accountB = new Account(2, 1000);
  88.         System.out.println("初始状态：");
  89.         System.out.println("账户1余额: " + accountA.getBalance());
  90.         System.out.println("账户2余额: " + accountB.getBalance());
  92.         // 使用线程池创建10个线程
  93.         ExecutorService executor = Executors.newFixedThreadPool(10);
  94.         // 使用CountDownLatch等待所有线程完成
  95.         CountDownLatch latch = new CountDownLatch(100);
  97.         // 提交100个转账任务
  98.         for (int i = 0; i < 50; i++) {
  99.             // A账户向B账户转账
  100.             executor.submit(() -> {
  101.                 new TransferTask(accountA, accountB, 10).run();
  102.                 latch.countDown();
  103.             });
  105.             // B账户向A账户转账
  106.             executor.submit(() -> {
  107.                 new TransferTask(accountB, accountA, 10).run();
  108.                 latch.countDown();
  109.             });
  110.         }
  112.         // 等待所有任务完成
  113.         latch.await();
  114.         executor.shutdown();
  116.         System.out.println("\n最终状态：");
  117.         System.out.println("账户1余额: " + accountA.getBalance());
  118.         System.out.println("账户2余额: " + accountB.getBalance());
  119.         System.out.println("总金额: " + (accountA.getBalance() + accountB.getBalance()));
  120.     }
  121. }

运行上述代码，你会发现总金额可能不等于初始总金额（2000元）。这是因为多个线程同时修改账户余额导致的数据不一致问题。

4.3 使用synchronized解决问题

现在，让我们使用synchronized来解决这个问题：

  1. package org.devlive.tutorial.multithreading.chapter05;
  3. import java.util.concurrent.CountDownLatch;
  4. import java.util.concurrent.ExecutorService;
  5. import java.util.concurrent.Executors;
  7. public class BankAccountSafe
  8. {
  9.     // 安全的账户类
  10.     static class Account
  11.     {
  12.         private int id;
  13.         private double balance;
  15.         public Account(int id, double initialBalance)
  16.         {
  17.             this.id = id;
  18.             this.balance = initialBalance;
  19.         }
  21.         // 使用synchronized修饰存款方法
  22.         public synchronized void deposit(double amount)
  23.         {
  24.             double newBalance = balance + amount;
  26.             // 模拟一些耗时操作
  27.             try {
  28.                 Thread.sleep(10);
  29.             }
  30.             catch (InterruptedException e) {
  31.                 e.printStackTrace();
  32.             }
  34.             balance = newBalance;
  35.         }
  37.         // 使用synchronized修饰取款方法
  38.         public synchronized void withdraw(double amount)
  39.         {
  40.             if (balance >= amount) {
  41.                 double newBalance = balance - amount;
  43.                 // 模拟一些耗时操作
  44.                 try {
  45.                     Thread.sleep(10);
  46.                 }
  47.                 catch (InterruptedException e) {
  48.                     e.printStackTrace();
  49.                 }
  51.                 balance = newBalance;
  52.             }
  53.             else {
  54.                 System.out.println("账户" + id + "余额不足，无法取款");
  55.             }
  56.         }
  58.         public synchronized double getBalance()
  59.         {
  60.             return balance;
  61.         }
  63.         public int getId()
  64.         {
  65.             return id;
  66.         }
  67.     }
  69.     // 安全的转账操作
  70.     static class TransferTask
  71.             implements Runnable
  72.     {
  73.         private Account fromAccount;
  74.         private Account toAccount;
  75.         private double amount;
  77.         public TransferTask(Account fromAccount, Account toAccount, double amount)
  78.         {
  79.             this.fromAccount = fromAccount;
  80.             this.toAccount = toAccount;
  81.             this.amount = amount;
  82.         }
  84.         @Override
  85.         public void run()
  86.         {
  87.             System.out.println(Thread.currentThread().getName() + " 准备从账户" + fromAccount.getId() +
  88.                     "转账" + amount + "元到账户" + toAccount.getId());
  90.             // 使用synchronized代码块，确保同时锁定两个账户
  91.             // 注意：这里需要按固定顺序获取锁，避免死锁
  92.             synchronized (fromAccount.getId() < toAccount.getId() ? fromAccount : toAccount) {
  93.                 synchronized (fromAccount.getId() < toAccount.getId() ? toAccount : fromAccount) {
  94.                     // 取款
  95.                     fromAccount.withdraw(amount);
  96.                     // 存款
  97.                     toAccount.deposit(amount);
  98.                 }
  99.             }
  101.             System.out.println(Thread.currentThread().getName() + " 完成转账！");
  102.         }
  103.     }
  105.     public static void main(String[] args)
  106.             throws InterruptedException
  107.     {
  108.         // 创建两个账户
  109.         Account accountA = new Account(1, 1000);
  110.         Account accountB = new Account(2, 1000);
  112.         System.out.println("初始状态：");
  113.         System.out.println("账户1余额: " + accountA.getBalance());
  114.         System.out.println("账户2余额: " + accountB.getBalance());
  116.         // 使用线程池创建10个线程
  117.         ExecutorService executor = Executors.newFixedThreadPool(10);
  118.         // 使用CountDownLatch等待所有线程完成
  119.         CountDownLatch latch = new CountDownLatch(50);
  121.         // 提交100个转账任务
  122.         for (int i = 0; i < 50; i++) {
  123.             // A账户向B账户转账
  124.             executor.submit(() -> {
  125.                 new TransferTask(accountA, accountB, 10).run();
  126.                 latch.countDown();
  127.             });
  128.         }
  130.         // 等待所有任务完成
  131.         latch.await();
  132.         executor.shutdown();
  134.         System.out.println("\n最终状态：");
  135.         System.out.println("账户1余额: " + accountA.getBalance());
  136.         System.out.println("账户2余额: " + accountB.getBalance());
  137.         System.out.println("总金额: " + (accountA.getBalance() + accountB.getBalance()));
  138.     }
  139. }

运行上述代码，你会发现总金额始终等于初始总金额（2000元）。这是因为我们使用了synchronized确保了账户操作的线程安全。

在这个实现中，我们做了以下改进：

  1. 使用synchronized修饰deposit、withdraw和getBalance方法，确保对单个账户的操作是线程安全的。
  2. 在转账操作中，使用嵌套的synchronized代码块同时锁定两个账户，确保转账过程的原子性。
  3. 使用固定顺序获取锁（按账户ID排序），避免死锁问题。

注意： 在上述实现中，我们使用了一个重要的技巧来避免死锁：按照固定顺序获取锁。如果不这样做，可能会出现线程A持有账户1的锁并等待账户2的锁，而线程B持有账户2的锁并等待账户1的锁，从而形成死锁。

4.4 进一步优化：减小锁粒度

虽然上面的实现解决了线程安全问题，但锁的粒度还可以进一步优化。我们可以只在需要修改余额的关键代码处加锁，而不是整个方法：

  1. package org.devlive.tutorial.multithreading.chapter05;
  3. import java.util.concurrent.CountDownLatch;
  4. import java.util.concurrent.ExecutorService;
  5. import java.util.concurrent.Executors;
  7. public class BankAccountOptimized {
  8.     // 优化锁粒度的账户类
  9.     static class Account {
  10.         private int id;
  11.         private double balance;
  12.         // 使用final对象作为锁
  13.         private final Object balanceLock = new Object();
  15.         public Account(int id, double initialBalance) {
  16.             this.id = id;
  17.             this.balance = initialBalance;
  18.         }
  20.         public void deposit(double amount) {
  21.             // 只在修改余额时加锁
  22.             synchronized (balanceLock) {
  23.                 double newBalance = balance + amount;
  24.                 balance = newBalance;
  25.             }
  27.             // 模拟其他非关键操作（如日志记录等）
  28.             try {
  29.                 Thread.sleep(10);
  30.             } catch (InterruptedException e) {
  31.                 e.printStackTrace();
  32.             }
  33.         }
  35.         public boolean withdraw(double amount) {
  36.             boolean success = false;
  38.             // 只在检查和修改余额时加锁
  39.             synchronized (balanceLock) {
  40.                 if (balance >= amount) {
  41.                     double newBalance = balance - amount;
  42.                     balance = newBalance;
  43.                     success = true;
  44.                 }
  45.             }
  47.             // 模拟其他非关键操作
  48.             try {
  49.                 Thread.sleep(10);
  50.             } catch (InterruptedException e) {
  51.                 e.printStackTrace();
  52.             }
  54.             if (!success) {
  55.                 System.out.println("账户" + id + "余额不足，无法取款");
  56.             }
  58.             return success;
  59.         }
  61.         public double getBalance() {
  62.             synchronized (balanceLock) {
  63.                 return balance;
  64.             }
  65.         }
  67.         public int getId() {
  68.             return id;
  69.         }
  70.     }
  72.     // 转账操作
  73.     static class TransferTask implements Runnable {
  74.         private Account fromAccount;
  75.         private Account toAccount;
  76.         private double amount;
  78.         public TransferTask(Account fromAccount, Account toAccount, double amount) {
  79.             this.fromAccount = fromAccount;
  80.             this.toAccount = toAccount;
  81.             this.amount = amount;
  82.         }
  84.         @Override
  85.         public void run() {
  86.             System.out.println(Thread.currentThread().getName() + " 准备从账户" + fromAccount.getId() + 
  87.                     "转账" + amount + "元到账户" + toAccount.getId());
  89.             // 使用两阶段锁定协议：先锁定源账户，再锁定目标账户
  90.             // 注意：为了避免死锁，我们按照账户ID的顺序获取锁
  91.             Account firstLock = fromAccount.getId() < toAccount.getId() ? fromAccount : toAccount;
  92.             Account secondLock = fromAccount.getId() < toAccount.getId() ? toAccount : fromAccount;
  94.             synchronized (firstLock) {
  95.                 synchronized (secondLock) {
  96.                     // 先检查余额是否足够
  97.                     if (fromAccount.withdraw(amount)) {
  98.                         // 取款成功后存入另一个账户
  99.                         toAccount.deposit(amount);
  100.                         System.out.println(Thread.currentThread().getName() + " 完成转账！");
  101.                     } else {
  102.                         System.out.println(Thread.currentThread().getName() + " 转账失败！");
  103.                     }
  104.                 }
  105.             }
  106.         }
  107.     }
  109.     public static void main(String[] args) throws InterruptedException {
  110.         // 创建两个账户
  111.         Account accountA = new Account(1, 1000);
  112.         Account accountB = new Account(2, 1000);
  114.         System.out.println("初始状态：");
  115.         System.out.println("账户1余额: " + accountA.getBalance());
  116.         System.out.println("账户2余额: " + accountB.getBalance());
  118.         // 使用线程池创建10个线程
  119.         ExecutorService executor = Executors.newFixedThreadPool(10);
  120.         // 使用CountDownLatch等待所有线程完成
  121.         CountDownLatch latch = new CountDownLatch(50);
  123.         // 提交100个转账任务
  124.         for (int i = 0; i < 50; i++) {
  125.             // A账户向B账户转账
  126.             executor.submit(() -> {
  127.                 new TransferTask(accountA, accountB, 10).run();
  128.                 latch.countDown();
  129.             });
  131.             // B账户向A账户转账
  132.             executor.submit(() -> {
  133.                 new TransferTask(accountB, accountA, 10).run();
  134.                 latch.countDown();
  135.             });
  136.         }
  138.         // 等待所有任务完成
  139.         latch.await();
  140.         executor.shutdown();
  142.         System.out.println("\n最终状态：");
  143.         System.out.println("账户1余额: " + accountA.getBalance());
  144.         System.out.println("账户2余额: " + accountB.getBalance());
  145.         System.out.println("总金额: " + (accountA.getBalance() + accountB.getBalance()));
  146.     }
  147. }

在这个优化版本中，我们做了以下改进：

  1. 使用专门的锁对象（balanceLock）而不是this对象
  2. 只在真正需要同步的代码块（余额操作）上加锁，提高并发性能
  3. 将withdraw方法的返回值改为boolean，便于调用者知道取款是否成功
  4. 使用两阶段锁定协议，按固定顺序获取锁，避免死锁

这种方式既保证了线程安全，又提高了并发性能。

5. 常见问题与解决方案

5.1 死锁问题

死锁是指两个或更多线程永远阻塞，等待对方持有的锁。

死锁示例：

  1. package org.devlive.tutorial.multithreading.chapter05;
  3. public class DeadlockDemo {
  4.     // 资源A
  5.     private static final Object resourceA = new Object();
  6.     // 资源B
  7.     private static final Object resourceB = new Object();
  9.     public static void main(String[] args) {
  10.         // 线程1：先获取资源A，再获取资源B
  11.         Thread thread1 = new Thread(() -> {
  12.             synchronized (resourceA) {
  13.                 System.out.println(Thread.currentThread().getName() + " 获取了资源A");
  15.                 try {
  16.                     Thread.sleep(1000);
  17.                 } catch (InterruptedException e) {
  18.                     e.printStackTrace();
  19.                 }
  21.                 System.out.println(Thread.currentThread().getName() + " 等待获取资源B");
  22.                 synchronized (resourceB) {
  23.                     System.out.println(Thread.currentThread().getName() + " 获取了资源B");
  24.                 }
  25.             }
  26.         }, "线程1");
  28.         // 线程2：先获取资源B，再获取资源A
  29.         Thread thread2 = new Thread(() -> {
  30.             synchronized (resourceB) {
  31.                 System.out.println(Thread.currentThread().getName() + " 获取了资源B");
  33.                 try {
  34.                     Thread.sleep(1000);
  35.                 } catch (InterruptedException e) {
  36.                     e.printStackTrace();
  37.                 }
  39.                 System.out.println(Thread.currentThread().getName() + " 等待获取资源A");
  40.                 synchronized (resourceA) {
  41.                     System.out.println(Thread.currentThread().getName() + " 获取了资源A");
  42.                 }
  43.             }
  44.         }, "线程2");
  46.         thread1.start();
  47.         thread2.start();
  48.     }
  49. }

运行上述代码，你会发现程序会永远卡住，这就是死锁。线程1持有资源A的锁并等待资源B的锁，而线程2持有资源B的锁并等待资源A的锁。

死锁解决方案：

  1. 按固定顺序获取锁：确保所有线程按照相同的顺序获取锁，可以避免循环等待。

    1.  package org.devlive.tutorial.multithreading.chapter05;
    3.  // 修复死锁的代码
    4.  public class DeadlockFixed {
    5.      // 资源A
    6.      private static final Object resourceA = new Object();
    7.      // 资源B
    8.      private static final Object resourceB = new Object();
    10.      public static void main(String[] args) {
    11.          // 线程1：先获取资源A，再获取资源B
    12.          Thread thread1 = new Thread(() -> {
    13.              synchronized (resourceA) {
    14.                  System.out.println(Thread.currentThread().getName() + " 获取了资源A");
    16.                  try {
    17.                      Thread.sleep(1000);
    18.                  } catch (InterruptedException e) {
    19.                      e.printStackTrace();
    20.                  }
    22.                  System.out.println(Thread.currentThread().getName() + " 等待获取资源B");
    23.                  synchronized (resourceB) {
    24.                      System.out.println(Thread.currentThread().getName() + " 获取了资源B");
    25.                  }
    26.              }
    27.          }, "线程1");
    29.          // 线程2：也是先获取资源A，再获取资源B，遵循相同的顺序
    30.          Thread thread2 = new Thread(() -> {
    31.              synchronized (resourceA) {
    32.                  System.out.println(Thread.currentThread().getName() + " 获取了资源A");
    34.                  try {
    35.                      Thread.sleep(1000);
    36.                  } catch (InterruptedException e) {
    37.                      e.printStackTrace();
    38.                  }
    40.                  System.out.println(Thread.currentThread().getName() + " 等待获取资源B");
    41.                  synchronized (resourceB) {
    42.                      System.out.println(Thread.currentThread().getName() + " 获取了资源B");
    43.                  }
    44.              }
    45.          }, "线程2");
    47.          thread1.start();
    48.          thread2.start();
    49.      }
    50.  }
  2. 使用锁超时：设定获取锁的超时时间，超时后放弃当前锁并重试。（不过synchronized不支持超时，需要使用Lock接口及其实现类）
  3. 死锁检测：使用工具（如jstack）检测死锁并强制解决。

5.2 性能问题

synchronized在保证线程安全的同时可能会带来性能问题。

常见性能问题：

  1. 锁粒度过大：整个方法加锁可能导致大部分时间都在等待锁
  2. 锁竞争激烈：多个线程频繁争抢同一把锁
  3. 锁持有时间过长：同步代码块中包含耗时操作

解决方案：

  1. 减小锁粒度：只在必要的代码块上加锁
  2. 使用不同的锁对象：将不相关的操作分到不同的锁上
  3. 避免在同步代码块中进行耗时操作：如IO操作、复杂计算等

  4. 考虑使用CAS操作：对于简单的原子操作，考虑使用java.util.concurrent.atomic包中的类

    1. // 减小锁粒度的示例
    2. public class SmallerLockGranularity {
    3.  private final Object stateLock = new Object();
    4.  private final Object listLock = new Object();
    6.  private int state;
    7.  private List<String> list = new ArrayList<>();
    9.  // 使用不同的锁对象保护不同的资源
    10.  public void updateState() {
    11.      synchronized (stateLock) {
    12.          state++;
    13.      }
    14.  }
    16.  public void updateList(String item) {
    17.      synchronized (listLock) {
    18.          list.add(item);
    19.      }
    20.  }
    21. }

5.3 活锁问题

活锁是指线程不断重试一个总是失败的操作，导致无法继续执行，但线程并没有阻塞。

活锁示例：

  1. package org.devlive.tutorial.multithreading.chapter05;
  3. public class LivelockDemo {
  4.     static class Worker {
  5.         private String name;
  6.         private boolean active;
  8.         public Worker(String name, boolean active) {
  9.             this.name = name;
  10.             this.active = active;
  11.         }
  13.         public String getName() {
  14.             return name;
  15.         }
  17.         public boolean isActive() {
  18.             return active;
  19.         }
  21.         public void work(Worker otherWorker, Object sharedResource) {
  22.             while (active) {
  23.                 // 等待对方不活跃
  24.                 if (otherWorker.isActive()) {
  25.                     System.out.println(getName() + ": " + otherWorker.getName() + "正在工作，我稍后再试");
  26.                     try {
  27.                         Thread.sleep(500);
  28.                     } catch (InterruptedException e) {
  29.                         e.printStackTrace();
  30.                     }
  31.                     continue;
  32.                 }
  34.                 synchronized (sharedResource) {
  35.                     System.out.println(getName() + ": 我开始工作了");
  36.                     active = false;
  37.                     // 通知对方可以工作了
  38.                     otherWorker.active = true;
  39.                     System.out.println(getName() + ": 我通知" + otherWorker.getName() + "可以工作了");
  40.                 }
  41.             }
  42.         }
  43.     }
  45.     public static void main(String[] args) {
  46.         final Object sharedResource = new Object();
  47.         final Worker worker1 = new Worker("工人1", true);
  48.         final Worker worker2 = new Worker("工人2", true);
  50.         new Thread(() -> {
  51.             worker1.work(worker2, sharedResource);
  52.         }).start();
  54.         new Thread(() -> {
  55.             worker2.work(worker1, sharedResource);
  56.         }).start();
  57.     }
  58. }

运行上述代码，你会发现两个工人一直互相谦让，都无法开始工作。这就是活锁。

活锁解决方案：

  1. 引入随机等待时间：打破重试的同步性
  2. 优先级调整：为竞争者分配不同的优先级
  1. // 通过随机等待时间解决活锁
  2. public void work(Worker otherWorker, Object sharedResource) {
  3.     while (active) {
  4.         // 等待对方不活跃
  5.         if (otherWorker.isActive()) {
  6.             System.out.println(getName() + ": " + otherWorker.getName() + "正在工作，我稍后再试");
  7.             try {
  8.                 // 引入随机等待时间，打破同步性
  9.                 Thread.sleep((long)(Math.random() * 1000));
  10.             } catch (InterruptedException e) {
  11.                 e.printStackTrace();
  12.             }
  13.             continue;
  14.         }
  16.         // 其余代码保持不变
  17.     }
  18. }

5.4 嵌套锁问题

嵌套锁是指在已持有锁的情况下再次获取锁。Java的synchronized是可重入锁，允许嵌套锁，但仍需谨慎使用。

可重入性示例：

  1. package org.devlive.tutorial.multithreading.chapter05;
  3. public class ReentrantLockDemo {
  5.     public synchronized void outer() {
  6.         System.out.println("进入outer方法");
  7.         inner(); // 在持有锁的情况下调用另一个同步方法
  8.         System.out.println("退出outer方法");
  9.     }
  11.     public synchronized void inner() {
  12.         System.out.println("进入inner方法");
  13.         // 这里可以再次获取同一个锁（this对象的锁）
  14.         System.out.println("退出inner方法");
  15.     }
  17.     public static void main(String[] args) {
  18.         ReentrantLockDemo demo = new ReentrantLockDemo();
  19.         demo.outer();
  20.     }
  21. }

运行上述代码，你会发现程序能够正常执行，而不会死锁。这是因为synchronized是可重入锁，允许同一个线程多次获取同一把锁。

嵌套锁的问题与解决方案：

  1. 死锁风险：如果存在交叉调用，可能导致死锁

    • 解决方案：避免复杂的锁嵌套关系，或使用统一的锁获取顺序

  2. 性能开销：每次获取锁都有开销

    • 解决方案：减少不必要的锁嵌套

  3. 代码可读性下降：嵌套锁使代码更难理解和维护

    • 解决方案：重构代码，降低复杂性

6. 小结

在本章中，我们深入学习了synchronized关键字的使用和原理：

  1. 理解了对象锁与类锁的概念和区别：

    • 对象锁锁定特定实例，通过synchronized修饰实例方法或synchronized(this)实现
    • 类锁锁定整个类，通过synchronized修饰静态方法或synchronized(类名.class)实现

  2. 掌握了synchronized修饰方法与代码块的区别：

    • 修饰方法：锁的范围是整个方法体，简单但粒度大
    • 修饰代码块：可以精确控制锁的范围，性能更好

  3. 了解了synchronized的底层实现原理：

    • 基于Monitor监视器机制
    • 通过monitorenter和monitorexit指令实现
    • JDK 1.6后引入锁升级机制，大幅提升性能

  4. 通过银行账户转账案例掌握了如何使用synchronized解决实际并发问题

  5. 学习了使用synchronized的常见问题与解决方案：

    • 死锁问题：按固定顺序获取锁
    • 性能问题：减小锁粒度，使用不同的锁对象
    • 活锁问题：引入随机等待时间
    • 嵌套锁问题：注意可重入性，避免复杂嵌套

通过本章的学习，你应该能够理解并正确使用synchronized关键字来解决多线程环境下的同步问题。在下一章中，我们将学习volatile关键字，它是另一种解决并发问题的重要工具。

源代码地址：https://github.com/qianmoQ/tutorial/tree/main/java-multithreading-tutorial/src/main/java/org/devlive/tutorial/multithreading/chapter05