多线程编程：Java并发实战案例

原创 ╰+攻爆jí腚メ 2024-11-26 05:36 12阅读 0赞

在Java中，多线程编程可以提高程序的执行效率。以下是一些实际的案例和代码：

1. **生产者消费者模型**：
   - 生产者创建商品，并将其加入到队列（通常使用`LinkedList`）。
   - 消费者从队列获取商品并消费。
   
```java
import java.util.LinkedList;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class ProducerConsumer {
    private final Lock lock = new ReentrantLock();
    private LinkedList<String> buffer = new LinkedList<>();

public void produce() {
        lock.lock();
        try {
            for (int i = 0; i < 10; i++) {
                buffer.add("Product " + i);
                System.out.println(Thread.currentThread().getName() + ": Product added: " + "Product " + i);
                }
            } finally {
                lock.unlock();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

public void consume() {
        lock.lock();
        try {
            while (!buffer.isEmpty()) {
                System.out.println(Thread.currentThread().getName() + ": Consumed: " + buffer.removeFirst());
                }
            }
        } finally {
            lock.unlock();
        }
    }

public static void main(String[] args) {
        ProducerConsumer producerConsumer = new ProducerConsumer();

Thread producerThread = new Thread("Producer") {
            @Override
            public void run() {
                try {
                    producerConsumer.produce();
                } catch (Exception e) {
                    System.out.println(e.getMessage());
                }
            }
        };

Thread consumerThread = new Thread("Consumer") {
            @Override
            public void run() {
                try {
                    producerConsumer.consume();
                } catch (Exception e) {
                    System.out.println(e.getMessage());
                }
            }
        };

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

}
}
```

这个案例中，生产者负责创建商品并放入队列，消费者则从队列获取商品并消费。

2. **并发控制**：
   - 使用`java.util.concurrent.locks`包中的锁实现线程的互斥访问。
   - 例如，可以使用`ReentrantLock`来保护共享资源。

3. **并发异常处理**：
   - 在多线程环境下，可能会出现诸如死锁、活锁等并发问题。
   - 对于这些情况，需要通过异常处理机制进行捕获和处理。