Java多线程编程基础：创建线程、线程同步

# 1. Java多线程编程简介

## 1.1 理解多线程编程的重要性

多线程编程是指在一个程序中同时运行多个线程来完成不同的任务。在当今的计算机系统中，多核处理器已经成为主流，多线程编程能够更好地利用多核处理器的性能优势，提高程序的运行效率。此外，多线程编程还能够改善程序的响应性，使程序能够同时处理多个任务和用户输入。

## 1.2 Java中的多线程编程优势和应用场景

Java作为一种广泛应用于企业级开发的编程语言，对多线程编程提供了良好的支持。Java中的多线程编程能够帮助开发者更好地利用计算机资源，提高程序的性能和响应速度。在实际应用中，Java多线程编程常被用于服务器编程、并发访问数据库、图形界面程序等场景。

接下来，我们将深入探讨如何在Java中进行多线程编程。

# 2. 创建线程

在Java多线程编程中，我们可以通过不同的方式来创建线程，常见的方式包括使用Thread类和实现Runnable接口。让我们详细了解这两种创建线程的方式：

### 2.1 使用Thread类创建线程

通过继承Thread类并重写run()方法来创建线程，下面是一个简单的示例：

public class MyThread extends Thread {
    public void run() {
        System.out.println("MyThread running...");
    }
}

public class ThreadExample {
    public static void main(String[] args) {
        MyThread thread = new MyThread();
        thread.start();
    }
}

**代码解析：**
- 我们定义了一个继承自Thread类的MyThread类，并重写了run()方法，该方法定义了线程的执行逻辑。
- 在主函数中，我们实例化MyThread类并调用start()方法启动线程，start()方法会调用run()方法执行线程逻辑。

**代码总结：** 使用Thread类创建线程是一种简单直接的方式，但由于Java是单继承的，若已有父类则无法再使用Thread创建线程。

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

通过实现Runnable接口并将其传递给Thread对象来创建线程，这种方式避免了单继承的限制。下面是一个示例：

public class MyRunnable implements Runnable {
    public void run() {
        System.out.println("MyRunnable running...");
    }
}

public class RunnableExample {
    public static void main(String[] args) {
        MyRunnable myRunnable = new MyRunnable();
        Thread thread = new Thread(myRunnable);
        thread.start();
    }
}

**代码解析：**
- 我们定义了一个实现了Runnable接口的MyRunnable类，并实现了run()方法来定义线程执行的逻辑。
- 在主函数中，我们实例化MyRunnable类，并将其传递给Thread对象，然后调用start()方法启动线程。

**代码总结：** 实现Runnable接口创建线程是一种更灵活的方式，可以避免单继承限制且支持多线程共享一个实例。

通过以上示例，我们了解了在Java中创建线程的两种方式。在实际开发中，根据具体情况选择合适的方式可以更好地进行多线程编程。

# 3. 线程的生命周期管理

在Java多线程编程中，了解并管理线程的生命周期是非常重要的。一个线程在其生命周期中会经历不同的状态，理解这些状态有助于我们更好地控制线程的行为和执行流程。

**3.1 线程的五个状态：新建、就绪、运行、阻塞、终止**
- **新建状态**：当线程对象被创建但还未调用`start()`方法启动线程时，线程处于新建状态。
- **就绪状态**：当线程调用`start()`方法后，线程进入就绪状态，等待获取CPU时间片执行。
- **运行状态**：当线程获取CPU时间片并执行时，线程处于运行状态。
- **阻塞状态**：当线程被暂时挂起或等待某个条件满足时，线程进入阻塞状态。
- **终止状态**：线程执行完任务或发生异常导致线程终止时，线程处于终止状态。

**3.2 管理线程状态转换的方法**
Java提供了一些方法来帮助我们管理线程的状态转换，以下是一些常用的方法：
- `Thread.sleep(long millis)`：使当前线程进入阻塞状态，让出CPU给其他线程执行，一段时间后重新进入就绪状态。
- `Thread.yield()`：暂停当前正在执行的线程对象，并执行其他线程，类似于让步一下CPU，让其他线程有机会执行。
- `join()`：让一个线程等待另一个线程完成后才能继续执行，通常用于在主线程等待子线程执行完成。
- `wait()`、`notify()`、`notifyAll()`：这些方法用于线程间的协作和通信，wait使线程等待，notify唤醒一个等待的线程，notifyAll唤醒所有等待的线程。

通过合理使用以上方法，我们可以更好地管理线程的状态与执行顺序，确保多线程程序的正常运行和逻辑顺序。

# 4. 线程同步基础

在多线程编程中，线程同步是一个重要的概念，用于解决多个线程访问共享资源时可能出现的数据错乱和不一致的问题。本章节将介绍线程同步的基础知识，包括理解并发和竞态条件，以及如何使用Java中的关键字和类来实现线程同步。

#### 4.1 理解并发和竞态条件

并发是指系统中同时存在多个线程在执行，并且这些线程之间可能会共享相同的资源。当多个线程竞争同一资源时，可能会导致数据错乱和不一致的情况，这就是竞态条件。

举个例子，假设有两个线程同时对一个共享的计数器进行加1操作，如果没有适当的同步措施，可能会导致两个线程同时读取计数器的值，然后分别加1后写回，这样最终的计数结果就会比预期少1。为了避免这种情况，我们需要使用线程同步机制。

#### 4.2 使用synchronized关键字实现线程同步

在Java中，可以使用关键字`synchronized`来实现线程的同步。可以将`synchronized`应用于方法或代码块，确保同一时间只有一个线程可以访问被`synchronized`保护的代码块。

下面是一个使用`synchronized`关键字实现线程同步的例子：

public class SynchronizedExample {
    private int count = 0;

    public synchronized void increment() {
        count++;
    }

    public synchronized int getCount() {
        return count;
    }

    public static void main(String[] args) {
        SynchronizedExample example = new SynchronizedExample();

        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                example.increment();
            }
        });

        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                example.increment();
            }
        });

        t1.start();
        t2.start();

        try {
            t1.join();
            t2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("Final count: " + example.getCount());
    }
}

在上面的例子中，我们创建了一个共享的计数器`count`，然后分别用两个线程对其进行1000次加1操作。由于`increment()`方法使用了`synchronized`关键字修饰，保证了对`count`的操作是原子的，不会发生数据错乱。最终输出的计数结果将为2000。

#### 4.3 使用ReentrantLock实现线程同步

除了`synchronized`关键字外，Java中还提供了`ReentrantLock`来实现线程的同步。相比`synchronized`，`ReentrantLock`提供了更灵活的锁定机制，可以实现更复杂的同步需求。

下面是一个使用`ReentrantLock`实现线程同步的例子：

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class ReentrantLockExample {
    private int count = 0;
    private Lock lock = new ReentrantLock();

    public void increment() {
        lock.lock();
        try {
            count++;
        } finally {
            lock.unlock();
        }
    }

    public int getCount() {
        return count;
    }

    public static void main(String[] args) {
        ReentrantLockExample example = new ReentrantLockExample();

        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                example.increment();
            }
        });

        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                example.increment();
            }
        });

        t1.start();
        t2.start();

        try {
            t1.join();
            t2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("Final count: " + example.getCount());
    }
}

在上面的例子中，我们使用`ReentrantLock`来保护对`count`的操作，确保只有一个线程可以访问该代码块。通过`lock()`和`unlock()`方法来手动控制锁的获取和释放。

通过本章的学习，我们了解了线程同步的基础知识，以及如何使用`synchronized`关键字和`ReentrantLock`类来实现线程的同步，确保多线程程序的正确性和稳定性。

# 5. 线程间通信

在多线程编程中，线程间通信是非常重要的一部分。线程间通信指的是多个线程之间在执行过程中进行信息交换和协作，以达到共同完成任务的目的。

#### 5.1 使用wait和notify实现线程间通信

在Java中，可以使用`wait()`和`notify()`方法来实现线程间的等待和唤醒操作。在使用这两个方法时，需要先获取对象的锁，即在synchronized代码块或方法中使用。下面是一个简单的示例：

public class WaitNotifyExample {
    public static void main(String[] args) {
        final Object lock = new Object();

        Thread thread1 = new Thread(() -> {
            synchronized (lock) {
                System.out.println("Thread 1: Waiting...");
                try {
                    lock.wait(); // 等待被唤醒
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("Thread 1: Resumed");
            }
        });

        Thread thread2 = new Thread(() -> {
            synchronized (lock) {
                System.out.println("Thread 2: Sleeping for 2 seconds...");
                try {
                    Thread.sleep(2000); // 等待2秒
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                lock.notify(); // 唤醒其他线程
            }
        });

        thread1.start();
        thread2.start();
    }
}

在上面的示例中，Thread 1首先进入等待状态，然后Thread 2经过2秒后唤醒了Thread 1。通过`wait()`和`notify()`的配合，实现了线程间的基本通信。

#### 5.2 使用Condition实现线程间通信

除了使用`wait()`和`notify()`方法，Java中还提供了`Condition`接口来实现线程间的通信。`Condition`可以精确的控制线程的等待和唤醒，同样需要在锁的保护下进行操作。下面是一个简单的示例：

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;

public class ConditionExample {
    public static void main(String[] args) {
        ReentrantLock lock = new ReentrantLock();
        Condition condition = lock.newCondition();

        Thread thread1 = new Thread(() -> {
            lock.lock();
            try {
                System.out.println("Thread 1: Waiting...");
                condition.await(); // 等待被唤醒
                System.out.println("Thread 1: Resumed");
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
        });

        Thread thread2 = new Thread(() -> {
            lock.lock();
            try {
                System.out.println("Thread 2: Sleeping for 2 seconds...");
                try {
                    Thread.sleep(2000); // 等待2秒
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                condition.signal(); // 唤醒其他线程
            } finally {
                lock.unlock();
            }
        });

        thread1.start();
        thread2.start();
    }
}

在上面的示例中，使用`Condition`接口进行线程间的通信，同样实现了线程的等待和唤醒操作。

通过以上示例，我们可以看到如何在Java中使用`wait`、`notify`和`Condition`实现线程间的通信，这对于多线程编程来说是至关重要的。

# 6. 线程池的使用

线程池是一种管理线程的技术，它包含一个线程队列，可以自动调度线程的运行和关闭。在Java中，线程池可以通过`java.util.concurrent`包中的ThreadPoolExecutor来实现。

#### 6.1 理解线程池的概念和作用

线程池的主要作用是减少线程的创建和销毁次数，提高线程的重复利用率，避免资源的频繁申请和释放，从而提高程序的性能。线程池可以帮助我们更好地管理程序中的线程，并且可以避免线程过多导致系统资源耗尽的情况。

#### 6.2 Java中线程池的实现和使用方法

在Java中，线程池可以使用`Executors`工具类来创建，也可以直接使用`ThreadPoolExecutor`类来自定义线程池的参数。

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class ThreadPoolExample {
    public static void main(String[] args) {
        // 使用Executors工具类创建一个固定大小的线程池
        ExecutorService executor = Executors.newFixedThreadPool(5);

        for (int i = 0; i < 10; i++) {
            // 提交任务给线程池
            executor.execute(new Task(i));
        }

        // 关闭线程池
        executor.shutdown();
    }

    static class Task implements Runnable {
        private int taskId;

        public Task(int taskId) {
            this.taskId = taskId;
        }

        @Override
        public void run() {
            System.out.println("Task " + taskId + " is running on thread " + Thread.currentThread().getName());
        }
    }
}

#### 6.3 如何选择合适的线程池参数

在选择线程池参数时，需要考虑任务的性质、系统资源、任务的调度方式等因素。常见的线程池参数包括核心线程数、最大线程数、线程存活时间、任务队列等。

- `corePoolSize`：核心线程数，线程池中始终保持活动的线程数量，即使它们处于空闲状态。
- `maximumPoolSize`：最大线程数，线程池中允许的最大线程数量。
- `keepAliveTime`：线程空闲时间，超过该时间的空闲线程将被回收。
- `workQueue`：任务队列，用于保存等待执行的任务。

根据具体的业务场景和系统资源情况，选择合适的线程池参数是非常重要的。

以上是关于线程池的基本介绍和使用方法，希望能帮助你更好地理解和应用线程池技术。