Java异常处理与多线程协作案例分析

原创叁歲伎倆 2024-10-14 16:42 38阅读 0赞

在Java编程中，异常处理和多线程协作是两种常见的编程技巧。下面我们将通过具体的案例来分析这两种技术。

一、异常处理案例

1. **try-catch-finally**：
```java
try {
    // 可能抛出异常的代码
    int divisor = 0;
    int result = num / divisor;
} catch (Exception e) {
    // 处理捕获到的异常
    System.out.println("捕获到异常: " + e.getMessage());
} finally {
    // 不论是否发生异常，都会执行的代码
    System.out.println("finally块，无论是否有异常都会执行");
}
```
2. **throws声明**：
```java
public void divide(int num, int divisor) throws ArithmeticException {
    // ...业务逻辑
    if (divisor == 0) {
        throw new ArithmeticException("除数不能为零");
    }
}
```
二、多线程协作案例

1. **生产者-消费者模型（Blocking Queue）**：
```java
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.TimeUnit;

class Producer implements Runnable {
    private final BlockingQueue<Integer> queue;

Producer(BlockingQueue<Integer> queue) {
        this.queue = queue;
    }

@Override
    public void run() {
        try {
            // 生产数据并放入队列
            for (int i = 0; i < 10; i++) {
                queue.put(i);
                System.out.println("生产数据: " + i);
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

class Consumer implements Runnable {
    private final BlockingQueue<Integer> queue;

Consumer(BlockingQueue<Integer> queue) {
        this.queue = queue;
    }

@Override
    public void run() {
        try {
            // 消费数据并打印结果
            while (true) {
                if (!queue.isEmpty()) {
                    int data = queue.take();
                    System.out.println("消费数据: " + data);
                } else {
                    break; // 数据消费完毕，退出循环
                }
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

public class Main {
    public static void main(String[] args) {
        BlockingQueue<Integer> queue = new LinkedBlockingQueue<>(10); // 设置队列容量

// 创建生产者和消费者线程
        Thread producerThread = new Thread(new Producer(queue)));
        Thread consumerThread = new Thread(new Consumer(queue)));

// 启动生产者和消费者线程
        producerThread.start();
        consumerThread.start();

// 等待所有线程执行完毕
        producerThread.join();
        consumerThread.join();
    }
}
```
以上案例展示了如何通过`BlockingQueue`实现多线程间的生产者-消费者协作。