实例展示Java多线程同步问题

原创旧城等待， 2024-12-07 19:57 11阅读 0赞

在Java中，多线程的同步问题主要体现在以下几种情况：

1. **互斥锁（Mutex）**：
```java
// 示例：两个线程分别读写同一个资源
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

class SharedResource {
    private int count = 0;

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

public synchronized int decrement() {
        if (count > 0) {
            count--;
            return count;
        } else {
            throw new RuntimeException("Can't decrement count to negative");
        }
    }
}

public class Main {
    private final Lock lock = new ReentrantLock();

public void thread1(SharedResource resource) throws InterruptedException {
        lock.lock();
        try {
            System.out.println("Thread 1: Incrementing count before read");
            resource.increment(); // 直接修改资源
            Thread.sleep(500); // 等待时间，模拟读取后操作

System.out.println("Thread 1: Reading the updated count after read");
            int count = resource.decrement();
            System.out.println("Thread 1: Final count: " + count);
        } finally {
            lock.unlock();
        }
    }

public void thread2(SharedResource resource) throws InterruptedException {
        lock.lock();
        try {
            System.out.println("Thread 2: Reading initial count before write");
            int count = resource.decrement(); // 首先尝试读取资源
            if (count < 0) { // 如果读取的值为负，说明资源被其他线程修改了
                System.out.println("Thread 2: Detected race condition, skipping write");
                return; // 直接返回，避免写入操作
            } else {
                System.out.println("Thread 2: Reading initial count after read, before update");
                count = resource.decrement(); // 再次尝试读取资源，确保数据一致
                if (count < 0) { // 如果再次读取的值为负，说明资源在更新过程中被其他线程修改了
                    System.out.println("Thread 2: Detected race condition, skipping update");
                    return; // 直接返回，避免写入操作
                }
            }

// 这里可以模拟更新资源的操作
            Thread.sleep(500); // 等待时间

System.out.println("Thread 2: Reading updated count after write");
            int finalCount = resource.decrement();
            System.out.println("Thread 2: Final count: " + finalCount);
        } finally {
            lock.unlock();
        }
    }

public static void main(String[] args) throws InterruptedException {
        Main main = new Main();
        Thread thread1 = new Thread(main::thread1, "Thread 1")));
        Thread thread2 = new Thread(main::thread2, "Thread 2")));

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

thread1.join();
        thread2.join();

System.out.println("All threads finished executing.");
    }
}
```

在这个例子中，两个线程（`thread1` 和 `thread2`）分别读写同一个资源。由于Java多线程的默认行为是互斥的，所以如果资源没有被正确锁定，就会出现资源冲突的问题。

通过上述代码示例，你可以看到当线程1在读取资源后尝试更新资源时，因为资源已经被线程2写入了，导致更新失败。这就是多线程同步问题的一个例子。