理解和避免Java多线程安全问题：示例7

原创迈不过友情╰ 2024-09-30 05:18 93阅读 0赞

在Java多线程编程中，安全问题是常见的挑战。这里我们以一个简单的生产者消费者问题来解析和避免多线程安全问题。

示例代码：
```java
// 定义共享资源队列
class Queue {
    private int[] items = new int[10];
    private int count = 0;

public synchronized boolean isEmpty() {
        return count == 0;
    }

public synchronized int size() {
        return count;
    }

public synchronized void enqueue(int item) {
        if (item < 0 || item > 9) {
            System.out.println("Invalid item, cannot enqueue.");
            return;
        }
        if (count >= items.length) {
            // 队列已满，创建新的元素数组
            int newCapacity = 2 * items.length;
            items = Arrays.copyOf(items, newCapacity);
        }
        items[count] = item;
        count++;
    }

public synchronized int dequeue() {
        if (count == 0) {
            System.out.println("Queue is empty, cannot dequeue.");
            return -1;
        }
        int item = items[0];
        items[0] = 0; // 设置元素为0，以便后续删除
        count--;
        return item;
    }
}

// 生产者和消费者类
class Producer implements Runnable {
    private Queue queue;

public Producer(Queue queue) {
        this.queue = queue;
    }

@Override
    public void run() {
        for (int i = 0; i < 10; i++) { // 生产10个元素
            System.out.println("Producer produced: " + i);
            queue.enqueue(i); // 将元素放入队列
            try {
                Thread.sleep(100); // 暂停一段时间，模拟生产过程
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

class Consumer implements Runnable {
    private Queue queue;

public Consumer(Queue queue) {
        this.queue = queue;
    }

@Override
    public void run() {
        for (int i = 0; i < 10; i++) { // 消费10个元素
            System.out.println("Consumer consumed: " + i);
            int item = queue.dequeue(); // 从队列中取出一个元素并消费
            if (item != -1 && item == i) {
                System.out.println("Element is valid, consumed as expected.");
            } else {
                System.out.println("Invalid element, unable to consume.");
            }
            try {
                Thread.sleep(200); // 模拟处理元素的时间
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

public class Main {
    public static void main(String[] args) {
        Queue queue = new Queue(); // 创建队列实例

// 启动生产者线程
        Thread producerThread = new Thread(new Producer(queue)));
        producerThread.start();

// 等待消费者线程执行完毕
        try {
            consumerThread.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

System.out.println("Main thread completed execution.");
    }
}
```
在上述示例中，我们通过创建两个类（Producer和Consumer）来实现多线程安全问题的避免。生产者负责生产元素并放入队列，消费者负责从队列中取出并消费元素。

通过这种方式，我们保证了队列操作的原子性，从而避免了数据不一致的问题。