Java并发编程常见问题——线程同步案例

原创阳光穿透心脏的1/2处 2024-12-11 05:18 8阅读 0赞

线程同步是Java并发编程中常见的问题，主要是因为多个线程同时访问共享资源可能会导致数据不一致或者死锁等问题。以下是一个简单的线程同步案例：

**案例：生产者消费者模型**

1. **类定义**：
```java
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

class Product {
    private int id;
    private boolean isAvailable;

// ... getters and setters
}

class Consumer {
    private int orderId;
    private boolean isFinished;

// ... getters and setters
}
```

2. **同步代码**：
```java
public class ProducerConsumerExample {

private final Lock productLock = new ReentrantLock();
    private final Lock consumerLock = new ReentrantLock();

public void produceProduct() {
        for (int i = 1; i <= 10; i++) {
            Product product = new Product(i, true);
            // 同步获取产品锁
            productLock.lock();
            try {
                // 插入生产者数据到队列中
                // ... 你的代码插入这里
                consumerLock.lock(); // 同步获取消费者锁
                if (product.isAvailable()) {
                    System.out.println("Product " + i + " produced and added to queue.");
                    // 更新产品可用状态
                    product.setAvailable(false);
                } else {
                    System.out.println("Product " + i + " is not available for production.");
                }
            } finally {
                // 无论是否发生异常，都要进行解锁操作
                consumerLock.unlock();
                productLock.unlock();
            }
        }
    }

public void consumeProduct() {
        while (true) {
            // ... 你的代码消费这里
            System.out.println("Consuming product from queue...");
            // 假设我们从队列中获取一个产品，然后进行消费操作
            // 这里只是示例，实际的逻辑需要根据具体需求来设计
            Thread.sleep(1000); // 模拟耗时操作
        }
    }

public static void main(String[] args) {
        ProducerConsumerExample example = new ProducerConsumerExample();
        example.produceProduct(); // 生产产品
        example.consumeProduct(); // 消费产品
    }
}
```

这个案例使用了`ReentrantLock`进行同步，保证了在多线程环境下数据的一致性。