Java多线程同步问题：常见解决方案示例

原创 ╰半橙微兮° 2024-10-09 03:45 76阅读 0赞

在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;
           } else {
               throw new Exception("Counter underflow.");
           }
       }

// ...其他方法
   }
   ```
   
2. **wait/notify**：
   - 使用`wait()`和`notify()`方法在对象上创建线程间的通信。
   ```java
   class ShareCounter {
       private int count = 0;
       private Object lock = new Object();

public void increment() {
           synchronized (lock) { // acquire lock
               if (count < Integer.MAX_VALUE) {
                   count++;
                   lock.notifyAll(); // notify waiting threads
               }
           }
       }

public static void main(String[] args) {
           ShareCounter counter = new ShareCounter();
           Thread thread1 = new Thread(() -> {
               for (int i = 0; i < 5; i++) {
                   counter.increment();
                   try { // simulate a delay
                       Thread.sleep(100);
                   } catch (InterruptedException e) {
                       e.printStackTrace();
                   }
               }
           })), // create thread 1
           Thread(thread2 = new Thread(() -> {
               for (int j = 0; j < 3; j++) {
                   counter.increment();
                   try { // simulate a delay
                       Thread.sleep(100);
                   } catch (InterruptedException e) {
                       e.printStackTrace();
                   }
               }
           })))), // create thread 2
           new Thread(() -> { // create monitor thread
               while (!counter.isFinished())) {
                   try { // loop until counter signals completion
                       Thread.sleep(500);
                   } catch (InterruptedException e) {
                       e.printStackTrace();
                   }
               }
           })), // create monitor thread
       );
       // start all threads and wait for them to finish
       counter.startThreads();
       counter.join();

System.out.println("Final count: " + counter.getCount());
       }
   }
   ```
   
3. **使用`Semaphore`**：
   - `Semaphore`可以控制同时访问共享资源的线程数量。
   ```java
   class Counter {
       private int count = 0;
       private Semaphore semaphore = new Semaphore(1); // allow one thread to increment

public void increment() throws InterruptedException {
           semaphore.acquire(); // acquire the semaphore lock
           count++;
           semaphore.release(); // release the semaphore lock
       }

public synchronized int decrement() {
           if (count > 0) {
               count--;
               semaphore.acquire(); // acquire semaphore lock again, since counter has decremented
               semaphore.release(); // release semaphore lock
               return count;
           } else {
               throw new Exception("Counter underflow.");
           }
       }

// ...other methods
   }
   ```
   
以上就是Java多线程同步的一些常见解决方案及其示例。在实际项目中，需要根据具体需求和场景选择合适的同步机制。