Java多线程编程-详解

拼搏现实的明天。 2024-03-22 14:24 117阅读 0赞

Java多线程编程是Java开发中一个非常重要的主题，它可以让程序员充分利用现代计算机的多核处理器，提高程序的性能和响应速度。本文将介绍Java中的多线程编程基础知识，并通过示例代码演示如何使用Java多线程编程。

### 1.什么是Java多线程编程？ ###

在开始讲解Java多线程编程之前，我们需要了解一些基本概念。

#### 1.1 进程与线程的区别 ####

**进程**是运行在操作系统上的独立执行单位，每个进程都有自己的地址空间、堆栈和数据段。

**线程**是进程内的可执行实体，是程序执行的最小单位。

同一进程内的所有线程共享相同的地址空间和数据段，但每个线程都有自己的堆栈。**因此，相对于进程而言，线程更轻量级、更灵活。**

#### 1.2 Java 线程的实现方式 ####

在Java中，线程的实现方式有两种：

>  *  继承 Thread 类
>  *  实现 Runnable 接口

这两种方式都可以创建线程，但推荐使用实现 Runnable 接口的方式来创建线程，因为它可以避免由于 Java 的单继承机制带来的局限性，并且能够更好地与线程池进行集成。

#### 1.3 线程的生命周期 ####

在Java中，每个线程都有自己的生命周期，它由线程的五个状态组成：

>  *  **新建状态（New）：**当一个Thread对象被创建时，它处于新建状态。
>  *  **就绪状态（Runnable）：**当调用线程对象的start方法后，它进入就绪状态。此时，它已经准备好了运行，但还没有分配到 CPU 时间片。
>  *  **运行状态（Running）：**当线程获得 CPU 时间片并开始执行时，它进入运行状态。
>  *  **阻塞状态（Blocked）：**当线程暂停执行时，它进入阻塞状态。例如，当线程等待某个资源时，它会进入阻塞状态。
>  *  **终止状态（Terminated）：**线程执行完其 run 方法后，它进入终止状态。

### 2. Java 多线程实现方式 ###

在Java中，有两种方式来实现多线程：

#### 2.1 继承 Thread 类 ####

通过继承Thread类，可以创建一个线程类，并重写run()方法，在该方法中定义线程的执行逻辑。

例如：

// 继承Thread类
    public class MyThread extends Thread {
    
        @Override
        public void run() {
            // 线程执行的代码
        }
    
    }

#### 2.2 实现 Runnable 接口 ####

实现Runnable接口可以创建一个线程类，并实现run()方法，在该方法中定义线程的执行逻辑。

例如：

// 实现Runnable接口
    public class MyRunnable implements Runnable {
    
        @Override
        public void run() {
            // 线程执行的代码
        }
    
    }

#### 2.3.启动线程 ####

在Java中，要启动一个线程，必须使用start()方法。该方法会调用线程的run()方法，并在一个新的线程中执行该方法。

例如：

// 启动线程
    MyThread thread = new MyThread();   // 创建线程
    thread.start();                     // 启动线程

#### 2.4.线程的优先级 ####

在Java中，线程可以设置优先级，通过设置线程的优先级可以控制线程在竞争CPU资源时的优先级，优先级范围为1到10，数字越大表示优先级越高。Java默认线程的优先级为5。

Thread thread = new MyThread();
    thread.setPriority(Thread.MAX_PRIORITY); //设置线程优先级
    thread.start();

#### 2.5.线程同步 ####

在Java多线程编程中，线程同步是非常重要的。线程同步可以防止多个线程同时访问共享数据，从而避免数据出现异常。Java提供了许多线程同步机制，其中比较常用的是**synchronized关键字和Lock接口。**

**synchronized关键字**可以用来修饰方法或代码块，当一个线程访问被synchronized关键字修饰的方法或代码块时，其他线程会被阻塞，直到当前线程执行完毕。

例如：

public class Counter {
        private int count = 0;
        
        public synchronized void increment() {
            count++;
        }
        
        public int getCount() {
            return count;
        }
    }
    
    public class IncrementThread extends Thread {
        private Counter counter;
        
        public IncrementThread(Counter counter) {
            this.counter = counter;
        }
        
        public void run() {
            for (int i = 0; i < 100000; i++) {
                counter.increment();
            }
        }
    }
    
    public class Main {
        public static void main(String[] args) throws InterruptedException {
            Counter counter = new Counter();
            IncrementThread thread1 = new IncrementThread(counter);
            IncrementThread thread2 = new IncrementThread(counter);
            
            thread1.start();
            thread2.start();
            
            thread1.join();
            thread2.join();
            
            System.out.println("Counter: " + counter.getCount());
        }
    }

在上面的代码中，我们创建了一个Counter类来存储计数器的值，并使用synchronized关键字将increment()方法标记为同步方法。

然后，我们创建两个IncrementThread实例，并将它们传递给同一个Counter实例。在main()方法中，我们启动这两个线程，并使用join()方法等待它们完成。最后，我们输出计数器的值。

--------------------

**Lock接口**是Java提供的另一种线程同步机制，它可以更灵活地控制线程的同步。通过调用Lock接口的lock()方法和unlock()方法，可以实现线程的同步。

例如：

Lock lock = new ReentrantLock();
    lock.lock();
    //需要同步的代码
    lock.unlock();

#### 2.6.线程的异常处理 ####

多线程编程中，线程可能会因为各种原因（如访问不存在的资源、无法获取资源的锁等）而产生异常，需要对这些异常进行处理，防止程序的崩溃。

在Java中，可以通过try-catch语句对线程的异常进行捕获和处理。

--------------------

### 3. 线程池和线程间通信 ###

#### 3.1.线程池 ####

线程池是一种可以重复使用的线程集合，它可以管理和执行多个任务。Java中的Executor框架提供了ThreadPoolExecutor类来实现线程池。

线程池的优点包括：

> 1.  重复使用线程，减少线程创建和销毁的开销。
> 2.  控制并发数量，避免系统资源被过度占用。
> 3.  提供统一的任务管理和调度机制，方便实现任务优先级、超时等功能。

以下是一个简单的线程池示例：

import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    
    public class Main {
        public static void main(String[] args) {
            ExecutorService executor = Executors.newFixedThreadPool(5); // 创建一个固定大小的线程池
    
            for (int i = 0; i < 10; i++) {
                Runnable worker = new WorkerThread("Task " + i);
                executor.execute(worker); // 提交任务给线程池
            }
    
            executor.shutdown(); // 关闭线程池
            while (!executor.isTerminated()) {} // 等待所有任务完成
    
            System.out.println("All tasks are finished.");
        }
    }
    
    class WorkerThread implements Runnable {
        private String task;
    
        public WorkerThread(String task) {
            this.task = task;
        }
    
        public void run() {
            System.out.println(Thread.currentThread().getName() + " is processing " + task);
            try {
                Thread.sleep(1000); // 模拟执行任务需要的时间
            } catch (InterruptedException e) {}
            System.out.println(Thread.currentThread().getName() + " has finished " + task);
        }
    }

在上面的代码中，我们创建了一个固定大小为5的线程池，并提交了10个任务给线程池。每个任务都是一个WorkerThread实例，它将打印自己的任务名并模拟执行需要的时间。当所有任务完成后，我们关闭线程池并输出消息。

#### 3.2.线程间通信 ####

线程间通信是指多个线程之间通过共享资源来进行信息传递的过程。Java提供了两种机制来实现线程间通信：wait/notify和BlockingQueue。

以下是一个使用wait/notify机制进行线程间通信的示例：

public class Message {
        private String message;
        private boolean empty = true;
        
        public synchronized String read() {
            while (empty) { // 如果消息队列为空，则等待直到有新消息
                try {
                    wait();
                } catch (InterruptedException e) {}
            }
            
            empty = true; // 标记消息队列为空
            notifyAll(); // 唤醒所有等待的线程
            
            return message;
        }
        
        public synchronized void write(String message) {
            while (!empty) { // 如果消息队列已满，则等待直到有空位
                try {
                    wait();
                } catch (InterruptedException e) {}
            }
            
            empty = false; // 标记消息队列不为空
            this.message = message;
            notifyAll(); // 唤醒所有等待的线程
        }
    }
    
    public class ReaderThread extends Thread {
        private Message message;
        
        public ReaderThread(Message message) {
            this.message = message;
        }
        
        public void run() {
            String msg = message.read();
            System.out.println("ReaderThread got message: " + msg);
        }
    }
    
    public class WriterThread extends Thread {
        private Message message;
        
        public WriterThread(Message message) {
            this.message = message;
        }
        
        public void run() {
            message.write("Hello World!");
        }
    }
    
    public class Main {
        public static void main(String[] args) {
            Message message = new Message();
            
            ReaderThread readerThread1 = new ReaderThread(message);
            ReaderThread readerThread2 = new ReaderThread(message);
            WriterThread writerThread = new WriterThread(message);
            
            readerThread1.start();
            readerThread2.start();
            writerThread.start();
        }
    }

在上面的代码中，我们创建了一个Message类来存储消息，并使用wait/notify机制来实现线程间通信。在ReaderThread中，我们使用read()方法读取消息，在WriterThread中，我们使用write()方法写入消息。

### 总结 ###

Java多线程编程是Java开发中一个非常重要的主题，本文介绍了Java多线程编程中一些关键概念和技术，包括线程和进程、线程创建、线程同步、线程池和线程间通信等。通过学习Java多线程编程，可以让程序更加高效、稳定和可扩展。