Java多线程同步问题解析：5种场景示例

原创蔚落 2024-09-25 17:42 31阅读 0赞

在Java多线程编程中，同步是保证数据一致性和互斥访问的关键。以下是五种常见的同步场景及示例：

1. **synchronized关键字**：
   - **单例模式**：确保全局只有一个实例。
   ```java
   public class Singleton {
       private static Singleton instance;

private Singleton() {}

public static Singleton getInstance() {
           if (instance == null) {
               synchronized (Singleton.class) {
                   if (instance == null) {
                       instance = new Singleton();
                   }
               }
           }
           return instance;
       }
   ```
2. **wait/notify**：
   - **生产者消费者问题**：保证消息传递的顺序。
   ```java
   class Node {
       int data;
       Node next;

Node(int data) {
           this.data = data;
           this.next = null;
       }
   }

class Queue {
       Node head, tail;

void enqueue(Node node) {
           if (head == null) {
               head = tail = node;
           } else {
               tail.next = node;
               tail = node;
           }
       }

void dequeue() {
           if (head == null) {
               System.out.println("Queue is empty.");
               return;
           }
           Node node = head;
           head = node.next;
           if (head == null) {
               tail = null;
           }
           return node;
       }
   }
   ```
3. **Semaphore**：
   - **资源限制**：控制并发访问的资源数量。
   ```java
   import java.util.concurrent.Semaphore;

class Counter {
       Semaphore semaphore;

Counter() {
           semaphore = new Semaphore(1);
       }

void increment() throws InterruptedException {
           semaphore.acquire();
           System.out.println("Count incremented.");
           semaphore.release();
       }
   }
   ```
4. **条件变量**（CyclicBarrier）：
   - **线程间同步**：当一组线程达到某个共同点时暂停，直到所有线程都通过了这个点才继续。

以上是五种常见的Java多线程同步场景及示例，希望对你理解并发编程有所帮助。