详解：Java多线程同步问题实例

原创短命女 2024-09-17 19:45 46阅读 0赞

在Java编程中，多线程的同步问题通常指的是如何在多个线程之间共享资源、避免数据竞争和死锁等问题。

以下是一些关于Java多线程同步问题的实例：

1. **synchronized关键字**：
   ```java
   class Counter {
       private int count = 0;

public synchronized void increment() {
           count++;
       }

public synchronized int decrement() {
           if (count > 0) {
               count--;
           }
           return count;
       }

// Getter for count
       public synchronized int getCount() {
           return count;
       }
   }
   ```
2. **使用ReentrantLock**：
   ```java
   import java.util.concurrent.locks.ReentrantLock;

class SingletonWithLock {
       private static final ReentrantLock lock = new ReentrantLock();

private SingletonWithLock() {}

public static synchronized Singleton getInstance() {
           if (lock.isHeldByCurrentThread()) {
               // 如果当前线程持有锁，则无需重新获取
               return instance;
            } else {
               // 获取锁
               lock.lock();
               try {
                   // 确保只有一个实例，如果已经存在则返回
                   if (instance != null) {
                       return instance;
                   }
                   // 创建新实例
                   instance = new SingletonWithLock();
                   return instance;
               } finally {
                   // 无论是否成功创建新实例，都需要释放锁
                   lock.unlock();
               }
           }
       }

private static SingletonWithLock instance;
   }
   ```
3. **使用CountDownLatch**：
   ```java
   class ProducerConsumer {
       private final CountDownLatch signal = new CountDownLatch(1);

// 生产者线程
       public void producerThread() {
           try {
               for (int i = 0; i < 10; i++) {
                   // 模拟生产任务，这里只是一个简单的打印操作
                   System.out.println("Producer produced item " + i);
                   
                   // 提交信号给消费者线程
                   signal.countDown();
               }
           } catch (InterruptedException e) {
               e.printStackTrace();
           }
       }

// 消费者线程
       public void consumerThread() throws InterruptedException {
           try {
               System.out.println("Consumer waiting for signal...");

// 等待信号被生产者线程提交
               signal.await();

System.out.println("Consumer received signal, starting processing...");
               // 模拟消费者处理任务，这里只是一个简单的打印操作
               for (int i = 0; i < 5; i++) {
                   System.out.println("Consumer processed item " + i);
               }
           } catch (InterruptedException e) {
               e.printStackTrace();
           }
       }

public static void main(String[] args) throws InterruptedException {
           // 创建生产者线程和消费者线程
           ProducerConsumer producer = new ProducerConsumer();
           Thread producerThread = new Thread(producer::producerThread));
           Thread consumerThread = new Thread(producer::consumerThread));

// 启动生产者线程和消费者线程
           producerThread.start();
           consumerThread.start();

// 等待所有线程执行完毕
           producerThread.join();
           consumerThread.join();
       }
   }
   ```
以上实例分别展示了如何使用synchronized关键字、ReentrantLock以及CountDownLatch来解决多线程同步问题。