【Java 基础篇】Java多线程编程详解：线程创建、同步、线程池与性能优化

ゝ一世哀愁。 2023-10-16 11:35 18阅读 0赞

![在这里插入图片描述][9315483573b247bfaca8d57bb4b83487.png]

Java是一门强大的编程语言，其中最引人注目的特性之一是多线程支持。多线程允许我们在同一程序中同时执行多个任务，这大大提高了应用程序的性能和响应能力。本文将深入介绍Java线程的基础知识，无论您是初学者还是有一些经验的开发人员，都将从中获益。

### 什么是线程？ ###

在计算机科学领域，线程是指在一个进程内部执行的独立单元。一个进程可以包含多个线程，每个线程都有自己的执行路径，可以独立运行。线程是操作系统进行任务调度和分配的基本单位，它允许我们实现并发执行，使得程序能够更高效地利用计算机资源。

### Java中的线程 ###

Java是一门多线程编程语言，它内置了多线程支持的类库和API，使得开发人员可以轻松地创建和管理线程。在Java中，线程是通过`java.lang.Thread`类来表示的。您可以通过继承`Thread`类或实现`Runnable`接口来创建线程。

#### 继承Thread类创建线程 ####

要创建一个线程，您可以继承`Thread`类，并重写`run()`方法来定义线程的执行逻辑。以下是一个简单的示例：

class MyThread extends Thread {
        
        public void run() {
        
            // 线程的执行逻辑
            for (int i = 0; i < 10; i++) {
        
                System.out.println("Thread: " + i);
            }
        }
    }

然后，您可以创建线程对象并调用`start()`方法来启动线程：

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

#### 实现Runnable接口创建线程 ####

除了继承`Thread`类，您还可以通过实现`Runnable`接口来创建线程。这种方式更加灵活，因为一个类可以同时实现多个接口。以下是示例代码：

class MyRunnable implements Runnable {
        
        public void run() {
        
            // 线程的执行逻辑
            for (int i = 0; i < 10; i++) {
        
                System.out.println("Runnable: " + i);
            }
        }
    }

然后，您需要将`Runnable`对象传递给`Thread`类的构造函数，并调用`start()`方法启动线程：

public class Main {
        
        public static void main(String[] args) {
        
            MyRunnable myRunnable = new MyRunnable();
            Thread thread = new Thread(myRunnable); // 创建线程并传入Runnable对象
            thread.start(); // 启动线程
        }
    }

#### Callable和Future ####

除了上述两种方式，还可以使用`Callable`和`Future`来创建线程，这是一种更高级的方法，允许线程执行完毕后返回结果。这在需要获取线程执行结果时非常有用。

import java.util.concurrent.Callable;
    import java.util.concurrent.FutureTask;
    
    class MyCallable implements Callable<Integer> {
        
        public Integer call() {
        
            int sum = 0;
            for (int i = 1; i <= 10; i++) {
        
                sum += i;
            }
            return sum;
        }
    }
    
    public class Main {
        
        public static void main(String[] args) throws Exception {
        
            MyCallable myCallable = new MyCallable();
            FutureTask<Integer> futureTask = new FutureTask<>(myCallable);
    
            Thread thread = new Thread(futureTask);
            thread.start();
    
            int result = futureTask.get(); // 获取线程执行结果
            System.out.println("线程执行结果：" + result);
        }
    }

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

一个线程在其生命周期内会经历不同的状态。理解线程的生命周期有助于我们更好地管理和控制线程的行为。Java中的线程可以处于以下几种状态：

1.  **新建状态（New）：** 当线程对象被创建但尚未启动时，线程处于新建状态。
2.  **就绪状态（Runnable）：** 当线程获得CPU时间片并执行时，线程处于就绪状态。
3.  **阻塞状态（Blocked）：** 当线程在等待某个条件的时候，会进入阻塞状态，直到条件满足。
4.  **终止状态（Terminated）：** 线程执行完任务或发生异常后，线程处于终止状态，不再执行。

在接下来的部分，我们将深入探讨线程的创建与启动。

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

一个Java线程可以处于以下几种状态：

1.  **新建状态（New）：** 当线程对象被创建但尚未启动时，线程处于新建状态。
2.  **就绪状态（Runnable）：** 当线程获得CPU时间片并执行时，线程处于就绪状态。
3.  **运行状态（Running）：** 当线程获得CPU时间片并执行时，线程处于运行状态。
4.  **阻塞状态（Blocked）：** 当线程在等待某个条件的时候，会进入阻塞状态，直到条件满足。
5.  **等待状态（Waiting）：** 当线程等待某个条件的时候，会进入等待状态，直到条件满足。
6.  **超时等待状态（Timed Waiting）：** 当线程等待某个条件的时候，可以设置一个超时时间，超过这个时间后线程会进入超时等待状态。
7.  **终止状态（Terminated）：** 线程执行完任务或发生异常后，线程处于终止状态，不再执行。

了解线程的生命周期对于编写多线程程序非常重要，因为我们需要根据线程的状态来进行合适的操作和控制。

### 创建与启动线程 ###

在Java中，有两种常见的方式来创建和启动线程：

1.  **继承Thread类：** 您可以创建一个继承自`Thread`类的子类，并重写`run()`方法来定义线程的执行逻辑。然后，创建线程对象并调用`start()`方法来启动线程。
2.  **实现Runnable接口：** 您可以创建一个实现`Runnable`接口的类，并重写`run()`方法来定义线程的执行逻辑。然后，创建线程对象，并将`Runnable`对象传递给线程的构造函数，并调用`start()`方法来启动线程。

下面是两种方式的示例代码：

// 继承Thread类创建线程
    class MyThread extends Thread {
        
        public void run() {
        
            // 线程的执行逻辑
            for (int i = 0; i < 10; i++) {
        
                System.out.println("Thread: " + i);
            }
        }
    }
    
    // 实现Runnable接口创建线程
    class MyRunnable implements Runnable {
        
        public void run() {
        
            // 线程的执行逻辑
            for (int i = 0; i < 10; i++) {
        
                System.out.println("Runnable: " + i);
            }
        }
    }
    
    public class Main {
        
        public static void main(String[] args) {
        
            // 创建并启动继承Thread类的线程
            MyThread myThread = new MyThread();
            myThread.start();
    
            // 创建并启动实现Runnable接口的线程
            MyRunnable myRunnable = new MyRunnable();
            Thread thread = new Thread(myRunnable);
            thread.start();
        }
    }

### 线程的状态转换 ###

一个线程在其生命周期内会经历不同的状态，这些状态之间可以相互转换。以下是线程可能的状态转换：

1.  **新建（New） -> 就绪（Runnable）：** 当线程对象被创建后，线程处于新建状态，但尚未启动。通过调用`start()`方法，线程将转换为就绪状态。
2.  **就绪（Runnable） -> 运行（Running）：** 当线程获得CPU时间片并开始执行时，线程从就绪状态转换为运行状态。
3.  **运行（Running） -> 就绪（Runnable）：** 当线程的时间片用完，或者主动调用`yield()`方法，线程将从运行状态转换为就绪状态。
4.  **运行（Running） -> 阻塞（Blocked）：** 当线程在等待某个条件时，例如等待I/O操作完成，线程将从运行状态转换为阻塞状态。
5.  **运行（Running） -> 终止（Terminated）：** 当线程的`run()`方法执行完毕，线程将从运行状态转换为终止状态。
6.  **就绪（Runnable） -> 终止（Terminated）：** 当线程的`run()`方法执行完毕，线程将从就绪状态直接转换为终止状态。
7.  **阻塞（Blocked） -> 就绪（Runnable）：** 当线程等待的条件满足时，线程将从阻塞状态转换为就绪状态。
8.  **阻塞（Blocked） -> 终止（Terminated）：** 当线程等待的条件不再满足，或者等待超时，线程将从阻塞状态转换为终止状态。
9.  **等待（Waiting） -> 就绪（Runnable）：** 当线程等待的条件满足时，线程将从等待状态转换为就绪状态。
10. **等待（Waiting） -> 终止（Terminated）：** 当线程等待的条件不再满足，或者等待超时，线程将从等待状态转换为终止状态。
11. **超时等待（Timed Waiting） -> 就绪（Runnable）：** 当线程等待的条件满足时，线程将从超时等待状态转换为就绪状态。
12. **超时等待（Timed Waiting） -> 终止（Terminated）：** 当线程等待的条件不再满足，或者等待超时，线程将从超时等待状态转换为终止状态。

理解这些状态的转换非常重要，因为我们需要根据线程的当前状态来决定如何操作线程，以实现我们想要的并发行为。

### 线程的优先级 ###

Java线程可以具有不同的优先级，用于告诉操作系统在竞争CPU时间片时应该优先考虑哪个线程。线程的优先级范围从1到10，默认优先级是5。您可以使用`setPriority()`方法设置线程的优先级，范围从1（最低优先级）到10（最高优先级）。

Thread thread = new Thread();
    thread.setPriority(8); // 设置线程优先级为8

请注意，线程的优先级只是一个建议，操作系统可以选择是否遵守它。因此，不要过分依赖线程优先级来控制程序的行为。

### 线程的同步与互斥 ###

在多线程编程中，经常会涉及到多个线程访问共享资源的情况，这可能会导致数据不一致或竞态条件。为了避免这些问题，我们需要使用线程的同步和互斥机制来确保线程安全。

#### synchronized关键字 ####

`synchronized`关键字可以用于方法或代码块，它可以确保在同一时间只有一个线程可以访问被`synchronized`修饰的方法或代码块。这可以有效地避免多个线程同时访问共享资源。

public synchronized void synchronizedMethod() {
        
        // 线程安全的代码
    }

或者使用`synchronized`代码块：

public void nonSynchronizedMethod() {
        
        // 非线程安全的代码
    
        synchronized (lockObject) {
        
            // 线程安全的代码
        }
        // 非线程安全的代码
    }

#### volatile关键字 ####

`volatile`关键字用于修饰变量，它可以确保一个线程对变量的修改对其他线程可见。当一个线程修改了一个`volatile`变量的值，其他线程将立即看到这个修改。

private volatile boolean flag = false;
    
    public void setFlagTrue() {
        
        flag = true;
    }
    
    public boolean isFlag() {
        
        return flag;
    }

#### Lock和Condition ####

除了`synchronized`和`volatile`，Java还提供了更灵活的锁机制，可以使用`Lock`接口和`Condition`接口来实现。

import java.util.concurrent.locks.Lock;
    import java.util.concurrent.locks.ReentrantLock;
    import java.util.concurrent.locks.Condition;
    
    Lock lock = new ReentrantLock();
    Condition condition = lock.newCondition();
    
    public void await() {
        
        lock.lock();
        try {
        
            condition.await();
        } catch (InterruptedException e) {
        
            e.printStackTrace();
        } finally {
        
            lock.unlock();
        }
    }
    
    public void signal() {
        
        lock.lock();
        try {
        
            condition.signal();
        } finally {
        
            lock.unlock();
        }
    }

使用`Lock`和`Condition`可以实现更复杂的线程同步和互斥逻辑，适用于更复杂的多线程应用程序。

### 线程池 ###

在实际开发中，经常需要创建和管理大量的线程。如果每次都手动创建和销毁线程，会带来较大的开销。为了提高线程的创建和管理效率，可以使用线程池。

线程池是一组预先创建好的线程，可以重复使用来执行任务。Java提供了`java.util.concurrent`包，其中包含了线程池的相关类，例如`ThreadPoolExecutor`。通过使用线程池，可以更好地管理系统中的线程，提高性能和资源利用率。

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

import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    
    public class ThreadPoolExample {
        
        public static void main(String[] args) {
        
            // 创建一个固定大小的线程池
            ExecutorService executorService = Executors.newFixedThreadPool(5);
    
            // 提交任务给线程池
            for (int i = 0; i < 10; i++) {
        
                Runnable task = new MyTask(i);
                executorService.submit(task);
            }
    
            // 关闭线程池
            executorService.shutdown();
        }
    }
    
    class MyTask implements Runnable {
        
        private int taskId;
    
        public MyTask(int taskId) {
        
            this.taskId = taskId;
        }
    
        public void run() {
        
            System.out.println("Task " + taskId + " is running.");
        }
    }

### 线程安全的集合 ###

在多线程编程中，经常需要使用集合来存储和管理数据。然而，传统的集合类（如`ArrayList`和`HashMap`）不是线程安全的，如果多个线程同时访问这些集合，可能会导致数据不一致或异常。

为了解决这个问题，Java提供了线程安全的集合类，例如`ConcurrentHashMap`和`CopyOnWriteArrayList`。这些集合类使用了各种锁和同步机制，以确保多线程访问时的线程安全性。

import java.util.concurrent.ConcurrentHashMap;
    
    public class ThreadSafeCollectionExample {
        
        public static void main(String[] args) {
        
            ConcurrentHashMap<Integer, String> map = new ConcurrentHashMap<>();
    
            // 线程安全地添加元素
            map.put(1, "One");
            map.put(2, "Two");
            map.put(3, "Three");
    
            // 线程安全地遍历元素
            map.forEach((key, value) -> {
        
                System.out.println(key + ": " + value);
            });
        }
    }

### 线程间通信 ###

在多线程编程中，不同线程之间需要进行通信和协作。Java提供了多种线程间通信的机制，包括`wait()`、`notify()`、`notifyAll()`等方法，以及`java.util.concurrent`包中的`Lock`和`Condition`。

以下是一个使用`wait()`和`notify()`实现线程间通信的示例：

class SharedResource {
        
        private int data;
        private boolean newData = false;
    
        public synchronized void produce(int value) {
        
            while (newData) {
        
                try {
        
                    wait(); // 等待消费者消费数据
                } catch (InterruptedException e) {
        
                    e.printStackTrace();
                }
            }
            data = value;
            newData = true;
            notify(); // 唤醒消费者线程
        }
    
        public synchronized int consume() {
        
            while (!newData) {
        
                try {
        
                    wait(); // 等待生产者生产数据
                } catch (InterruptedException e) {
        
                    e.printStackTrace();
                }
            }
            newData = false;
            notify(); // 唤醒生产者线程
            return data;
        }
    }

public class Main {
        
        public static void main(String[] args) {
        
            SharedResource sharedResource = new SharedResource();
    
            // 生产者线程
            Thread producer = new Thread(() -> {
        
                for (int i = 0; i < 5; i++) {
        
                    sharedResource.produce(i);
                    System.out.println("Produced: " + i);
                }
            });
    
            // 消费者线程
            Thread consumer = new Thread(() -> {
        
                for (int i = 0; i < 5; i++) {
        
                    int value = sharedResource.consume();
                    System.out.println("Consumed: " + value);
                }
            });
    
            producer.start();
            consumer.start();
        }
    }

### 线程安全与性能 ###

在多线程编程中，线程安全是一个重要的考虑因素，但同时也需要关注性能。过多的锁和同步可能会导致性能下降，因此需要在线程安全和性能之间进行权衡。

一些常见的性能优化技巧包括：

*  减小锁的粒度：只在必要的地方使用锁，避免过多的同步。
 *  使用线程池：重用线程可以减少线程创建和销毁的开销。
 *  使用线程安全的集合：选择合适的线程安全集合来减少同步开销。
 *  使用无锁数据结构：例如`java.util.concurrent`包中的`ConcurrentHashMap`和`ConcurrentLinkedQueue`，它们使用了无锁算法来提高性能。

### 结论 ###

多线程编程是Java中的一个重要主题，它可以帮助我们充分利用多核处理器和提高应用程序的性能。但多线程编程也会带来复杂性和潜在的问题，因此需要谨慎使用。

在本文中，我们介绍了Java线程的基础知识，包括线程的创建与启动、线程的生命周期、线程的同步与互斥、线程池、线程安全的集合、线程间通信等内容。希望本文可以帮助您更好地理解和应用多线程编程，提高Java应用程序的性能和可靠性。

[9315483573b247bfaca8d57bb4b83487.png]: https://img-blog.csdnimg.cn/9315483573b247bfaca8d57bb4b83487.png