Java多线程编程详细教程与案例

Java 多线程编程详细教程与案例

引言

Java多线程编程是Java并发编程的核心内容之一，它允许程序同时执行多个任务，从而提高程序的执行效率和响应速度。本文将详细介绍Java多线程的基本概念、创建方式以及线程间的通信和同步机制，并通过一个实际的案例来演示如何应用这些技术。

Java多线程的基本概念

在Java中，线程是进程中的一个执行单元，它拥有独立的执行栈和程序计数器，但共享进程中的内存和其他资源。每个线程都有自己的生命周期，包括新建（NEW）、就绪（RUNNABLE）、运行（RUNNING）、阻塞（BLOCKED）、等待（WAITING）、计时等待（TIMED_WAITING）和终止（TERMINATED）等状态。

创建多线程的方式

在Java中，创建多线程的方式主要有两种：继承Thread类和实现Runnable接口。

1. 继承Thread类

通过继承Thread类，并重写其run方法，可以创建一个新的线程。以下是一个简单的示例：

        
            public class MyThread extends Thread {
                @Override
                public void run() {
                    System.out.println("这是一个新的线程！");
                }

                public static void main(String[] args) {
                    MyThread myThread = new MyThread();
                    myThread.start();  // 启动线程
                }
            }

2. 实现Runnable接口

实现Runnable接口是创建线程的更推荐的方式，因为它避免了Java单继承的限制。以下是一个示例：

        
            public class MyRunnable implements Runnable {
                @Override
                public void run() {
                    System.out.println("这是一个通过Runnable实现的线程！");
                }

                public static void main(String[] args) {
                    MyRunnable myRunnable = new MyRunnable();
                    Thread thread = new Thread(myRunnable);
                    thread.start();  // 启动线程
                }
            }

线程间的通信和同步

在Java中，线程间的通信和同步主要通过synchronized关键字、wait/notify/notifyAll方法和Lock接口等机制来实现。以下是一个简单的生产者-消费者模型的示例，演示了如何使用这些机制：

生产者-消费者模型示例

        
            import java.util.LinkedList;
            import java.util.Queue;

            class Producer implements Runnable {
                private Queue queue;
                private int maxSize;

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

                @Override
                public void run() {
                    for (int i = 0; i < 10; i++) {
                        synchronized (queue) {
                            while (queue.size() == maxSize) {
                                try {
                                    queue.wait();
                                } catch (InterruptedException e) {
                                    e.printStackTrace();
                                }
                            }
                            queue.offer(i);
                            System.out.println("生产者生产了：" + i);
                            queue.notifyAll();
                        }

                        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++) {
                        synchronized (queue) {
                            while (queue.isEmpty()) {
                                try {
                                    queue.wait();
                                } catch (InterruptedException e) {
                                    e.printStackTrace();
                                }
                            }
                            Integer item = queue.poll();
                            System.out.println("消费者消费了：" + item);
                            queue.notifyAll();
                        }

                        try {
                            Thread.sleep(150);  // 模拟消费时间
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }

            public class ProducerConsumerExample {
                public static void main(String[] args) {
                    Queue queue = new LinkedList();
                    int maxSize = 5;

                    Thread producerThread = new Thread(new Producer(queue, maxSize));
                    Thread consumerThread = new Thread(new Consumer(queue));

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