Java面试常见问题：多线程的同步问题如何解决？

原创墨蓝 2024-10-18 04:45 40阅读 0赞

在Java中，多线程并发执行可能会导致数据不一致的问题。为了解决这些问题，可以使用以下几种多线程同步机制：

1. **synchronized关键字**：
   - 使用 synchronized 关键字修饰方法或代码块，确保在同一时刻只有一个线程访问。
   ```java
   class Counter {
       private int count = 0;

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

// synchronized getter
       public synchronized int getCount() {
           return count;
       }
   }
   ```

2. **wait/notify/notifyAll**：
   - 在锁的内部使用 wait 方法让当前线程等待。
   - 使用 notify 或 notifyAll 来唤醒等待的线程。
   ```java
   class ConditionExample {
       private boolean flag = false;

// synchronized method with condition
       public synchronized void setFlagIfTrue() {
           if (flag) {
               flag = false;  // reset flag
               notifyAll();    // wake up all waiting threads
           } else {
               try {
                   wait();          // wait until flag is true
               } catch (InterruptedException e) {
                   e.printStackTrace();
               }
           }
       }

public void run() {
           System.out.println("Thread 1 started...");

for (int i = 0; i < 5; i++) {
               setFlagIfTrue();   // call method to check flag
               if (!flag) {
                  System.out.println("Thread 1 detected true flag.");
                  break;
               }
               try {
                   Thread.sleep(200);    // simulate some work
               } catch (InterruptedException e) {
                   e.printStackTrace();
               }
           }

System.out.println("Thread 1 finished.");
       }

public static void main(String[] args) {
           ThreadExample example = new ThreadExample();
           example.run();   // start the thread
       }
   }
   ```

3. **CountDownLatch/Semaphore/ReentrantLock**：
   - 管理线程的并发，如限制同时访问资源的数量。
   - 多用于不同线程间协作的场合。

通过这些同步机制，可以确保在多线程环境中正确地共享和管理数据。