Java并发陷阱：线程同步不当示例

原创 ╰+哭是因爲堅強的太久メ 2024-11-30 00:48 1阅读 0赞

在Java编程中，线程同步不当是一个常见的并发陷阱。下面是一段示例代码，展示了这种问题：

```java
// 创建两个共享资源的类
public class Resource {
    private int count;

// 构造函数初始化计数器为0
    public Resource() { count = 0; }

// 获取当前资源的计数
    public int getCount() { return count; }
    
    // 增加资源，同步保证操作的一致性
    synchronized void incrementCount() {
        count++;
    }
}

// 主线程示例
public class MainThread {
    private Resource resource1;
    private Resource resource2;

public MainThread(Resource resource1, Resource resource2) {
        this.resource1 = resource1;
        this.resource2 = resource2;
    }

public void startConsuming() {
        // 同步保证资源1的使用
        synchronized (resource1) {
            resource1.incrementCount();
            System.out.println("Resource 1 incremented to " + resource1.getCount());
        }
        
        // 在资源1操作完成后，再同步保证资源2的使用
        synchronized (resource2) {
            resource2.incrementCount();
            System.out.println("Resource 2 incremented to " + resource2.getCount());
        }
    }

public static void main(String[] args) {
        Resource resource1 = new Resource();
        Resource resource2 = new Resource();

MainThread consumerThread = new MainThread(resource1, resource2);

Thread thread1 = new Thread(consumerThread::startConsuming));
        Thread thread2 = new Thread(consumerThread::startConsuming));

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

// 注意，此处无法保证资源同步操作的原子性
    }
}
```

在这个例子中，两个线程（thread1和thread2）同时消费两个共享资源（resource1和resource2）。但是，如果代码没有正确地使用`synchronized`关键字来保证对资源的操作是线程安全的，那么就会出现资源不一致的问题。