实战问题：Java多线程并发编程实例

原创朱雀 2024-12-08 03:57 16阅读 0赞

在Java中，多线程并发编程主要通过`Thread`类和`synchronized`关键字实现。下面提供一个简单的例子，展示如何使用多线程并发处理任务。

```java
// 创建一个任务类
class Task {
    private int id;
    private String description;

// 构造函数
    Task(int id, String description) {
        this.id = id;
        this.description = description;
    }

// 获取任务ID
    public int getId() {
        return id;
    }

// 返回任务描述
    public String getDescription() {
        return description;
    }
}

// 创建一个生产者线程
class Producer extends Thread {
    private int taskCount = 10; // 任务总数
    private List<Task> tasks = new ArrayList<>(); // 任务列表

// 线程构造函数
    public Producer() {
        start();
    }

// 生产任务
    @Override
    public void run() {
        for (int i = 0; i < taskCount; i++) {
            Task task = new Task(i, "Task " + i));
            tasks.add(task);
        }

System.out.println("Tasks produced by producer thread:");

// 打印任务列表
        for (Task task : tasks) {
            System.out.println(task.getId() + ": " + task.getDescription()));
        }
    }
}

// 创建一个消费者线程
class Consumer extends Thread {
    private List<Task> tasks = new ArrayList<>(); // 任务列表

// 线程构造函数
    public Consumer(List<Task> tasks) {
        this.tasks = tasks;
        start();
    }

// 消费任务
    @Override
    public void run() {
        System.out.println("Tasks received by consumer thread:");

// 打印任务列表
        for (Task task : tasks) {
            System.out.println(task.getId() + ": " + task.getDescription()));
        }
    }
}

// 主程序
public class MultiThreadedExample {
    public static void main(String[] args) {
        // 创建生产者线程
        Producer producer = new Producer();
        
        // 创建消费者线程，等待任务接收
        Consumer consumer = new Consumer(producer.tasks);

// 同步开始生产和消费
        synchronized (consumer) {
            System.out.println("Both producer and consumer threads are running.");
            producer.start(); // 开始生产者线程
        }

// 消费者线程等待并打印任务列表
        try {
            consumer.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
```

这个示例中，一个生产者线程（`Producer`）生成10个任务，然后将它们放入任务列表。一个消费者线程（`Consumer`）等待这些任务，并打印它们的任务描述。

两个线程通过同步机制（`synchronized`关键字）确保在任何时候只有一个线程处理任务。