Java多线程：同步阻塞问题示例

原创绝地灬酷狼 2024-09-20 15:51 81阅读 0赞

在Java多线程编程中，同步阻塞问题是常见的并发控制方式。以下是一个简单的示例，演示了生产者-消费者模型中的同步阻塞问题。

```java
// 创建两个共享资源的类（如缓冲区）
class Buffer {
    int data;
    boolean empty = true;

// 同步方法：检查并初始化缓冲区
    synchronized void init(int value) {
        if (!empty) {
            throw new IllegalStateException("Buffer already initialized.");
        }
        data = value;
        empty = false;
    }

// 同步方法：获取数据
    synchronized int getData() {
        if (empty) {
            throw new NoSuchElementException("Buffer is empty.");
        }
        return data;
    }

// 同步方法：清空缓冲区
    synchronized void clear() {
        data = 0;
        empty = true;
    }
}

// 生产者线程类
class ProducerThread implements Runnable {
    private Buffer buffer;
    private int value;

public ProducerThread(Buffer buffer, int value) {
        this.buffer = buffer;
        this.value = value;
    }

@Override
    public void run() {
        // 生产数据，模拟耗时操作
        try {
            Thread.sleep(2000); // 模拟耗时2秒
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

// 同步写入数据到缓冲区
        synchronized buffer {
            buffer.init(value);
        }
    }
}

// 消费者线程类
class ConsumerThread implements Runnable {
    private Buffer buffer;

public ConsumerThread(Buffer buffer) {
        this.buffer = buffer;
    }

@Override
    public void run() {
        // 同步获取并消费数据
        synchronized buffer {
            while (!buffer.isEmpty()) {
                int data = buffer.getData();
                System.out.println("Consumed data: " + data);

// 模拟耗时操作，使消费者线程等待
                try {
                    Thread.sleep(2000); // 模拟耗时2秒
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

buffer.clear(); // 清空缓冲区以获取新的数据
            }
        }
    }
}

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

// 创建生产者线程并启动
        Thread producerThread = new Thread(new ProducerThread(buffer, 100))));
        producerThread.start();

// 创建消费者线程并启动
        Thread consumerThread = new Thread(new ConsumerThread(buffer)));
        consumerThread.start();

try {
            // 等待消费者线程完成任务
            consumerThread.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

// 检查缓冲区是否为空，以确认生产者和消费者是否完成了它们的任务
        if (buffer.isEmpty()) {
            System.out.println("生产和消费任务已成功完成.");
        } else {
            System.out.println("生产和消费任务还未完全完成, 请检查缓冲区是否为空.");
        }
    }
}
```

这个示例模拟了生产者-消费者模型，其中生产者线程负责产生数据，并将数据写入到共享的缓冲区。消费者线程则从缓冲区获取并处理数据。

通过加入同步阻塞（如使用synchronized关键字），确保多线程在访问共享资源时不会出现并发冲突的问题。