并发编程挑战：Java线程同步问题示例

原创痛定思痛。 2024-12-07 07:21 18阅读 0赞

在Java中，线程同步主要是通过各种锁机制实现的。这里我们举一个典型的线程同步问题——生产者消费者问题。

```java
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

class Product {
    private Lock lock = new ReentrantLock();
    
    public void produce() throws InterruptedException {
        lock.acquire(); // 获取锁
        System.out.println("Product produced by thread " + Thread.currentThread().getName());
        lock.release(); // 释放锁
    }
}

class Consumer {
    private Lock lock = new ReentrantLock();

public void consume(Product product) throws InterruptedException {
        lock.acquire(); // 获取锁
        System.out.println("Consumer " + Thread.currentThread().getName() + " consumed product by thread " + product.produceThread());
        lock.release(); // 释放锁
    }
}

public class ThreadSyncExample {
    private Product product = new Product();
    private Consumer consumer = new Consumer();

public void startThreads() throws InterruptedException {
        Thread produceThread = new Thread(product::produce);
        Thread consumeThread = new Thread(consumer::consume, product));

// 启动线程
        produceThread.start();
        consumeThread.start();
    }

public static void main(String[] args) {
        ThreadSyncExample example = new ThreadSyncExample();
        try {
            example.startThreads();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
```

在这个例子中，`Product`类代表生产者，它有一个线程锁来保护生产操作。`Consumer`类代表消费者，它也有一个线程锁来确保安全的消费行为。

主线程启动两个线程：一个是生产者线程，另一个是消费者线程。这样就实现了Java中的线程同步问题。