Java多线程并发编程中的锁问题实例

原创偏执的太偏执、 2024-09-19 02:57 71阅读 0赞

在Java多线程并发编程中，锁（Lock）是一种同步机制，用于控制对共享资源的访问。下面以生产者消费者问题为例，展示锁的问题：

```java
// 假设我们有一个固定大小的缓冲区
class Buffer {
    int capacity = 10;
    int size = 0;
    // 这是一个公平的锁，确保所有等待获取锁的线程都能得到机会
    Lock lock = new ReentrantLock();

void put(int item) {
        lock.lock();
        try {
            if (size == capacity) {
                System.out.println("Buffer is full, can't put " + item);
                return;
            }
            buffer[size++] = item;
            System.out.println("Put " + item + " into buffer at position " + size - 1);
        } finally {
            lock.unlock();
        }
    }

void take() {
        lock.lock();
        try {
            if (size == 0) {
                System.out.println("Buffer is empty, can't take");
                return;
            }
            int item = buffer[size--];
            System.out.println("Take " + item + " from buffer at position " + size);
        } finally {
            lock.unlock();
        }
    }
}

public class Main {
    public static void main(String[] args) {
        Buffer buffer = new Buffer();

// 生产者线程
        Thread producerThread = new Thread(() -> {
            for (int i = 0; i < 10; i++) { // 产生10个元素
                System.out.println("Producer: Put " + i + " into buffer");
                buffer.put(i);
                try {
                    Thread.sleep(100); // 模拟生产时间
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }));

// 消费者线程
        Thread consumerThread = new Thread(() -> {
            for (int i = 0; i < 10; i++) { // 产生10个元素，模拟消费时间
                System.out.println("Consumer: Take " + i + " from buffer");
                buffer.take();
                try {
                    Thread.sleep(50); // 模拟消费时间
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }));

producerThread.start();
        consumerThread.start();

// 等待所有线程执行完毕
        while (!producerThread.isFinished() || !consumerThread.isFinished()) {
            try {
                Thread.sleep(1000); // 每秒检查一次，防止死锁
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

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

在这个例子中，如果`producerThread`和`consumerThread`都同时执行`take()`操作，可能会导致死锁。因为当缓冲区为空时，`take()`会阻塞，而`producerThread`也可能会被阻塞在`put()`方法中，这种情况就形成了死锁。