详解Java中的线程同步机制：synchronized关键字的多例

原创超、凢脫俗 2024-09-20 02:54 17阅读 0赞

在Java中，线程同步是一种管理多个线程访问共享资源的方式。`synchronized`关键字就是一种强大的工具，用于确保同一时间只有一个线程能够执行特定的代码块。

1. **独占锁（Synchronized on an Object）**：
   使用对象作为锁，如：

```java
   class Counter {
       int count = 0;
       synchronizedCounter() {
           count++;
           System.out.println("Counter incremented: " + count);
       }
   }

public class SynchronizedDemo {
       public static void main(String[] args) {
           Counter counter = new Counter();
           // 同时线程1和2调用counter的incrementCounter方法
           Thread thread1 = new Thread(() -> counter.synchronizedCounter()));
           Thread thread2 = new Thread(() -> counter.synchronizedCounter()));

thread1.start();
           thread2.start();

try {
               thread1.join();
               thread2.join();
           } catch (InterruptedException e) {
               e.printStackTrace();
           }

System.out.println("Final count: " + counter.count));
       }
   }
   ```

2. **非独占锁（Synchronized on a Method）**：
   可以使用`synchronized`关键字修饰方法，如：

```java
   class Example {
       private int count = 0;

synchronizedExampleMethod() {
           count++;
           System.out.println("Example method incremented: " + count);
       }
   }

public class SynchronizedMethodDemo {
       public static void main(String[] args) {
           Example example = new Example();
           // 同时线程1和2调用example的synchronizedExampleMethod方法
           Thread thread1 = new Thread(() -> example.synchronizedExampleMethod()));
           Thread thread2 = new Thread(() -> example.synchronizedExampleMethod()));

thread1.start();
           thread2.start();

try {
               thread1.join();
               thread2.join();
           } catch (InterruptedException e) {
               e.printStackTrace();
           }

System.out.println("Final count: " + example.count));
       }
   }
   ```

以上两种方式都可以实现线程同步，确保在特定条件下只有一个线程能够访问共享资源。