Java多线程基础全解析：从概念到实战_多线程java入门到实战-优快云博客

本文链接：https://blog.youkuaiyun.com/zhaoshanshan168/article/details/144164716

---

**Java多线程**是并发编程的核心技术之一，广泛应用于服务器开发、任务调度、实时处理等场景。通过学习多线程，开发者可以提升程序的执行效率和资源利用率。本文将从基础概念、实现方法到实际应用，全面解析Java多线程的核心内容。

---

## 一、多线程的基本概念

### 1.1 什么是线程？

线程是程序执行的最小单位，是CPU调度的基本单元。一个Java程序启动后，至少有一个主线程负责执行`main`方法。

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

| **属性** | **进程** | **线程** |
|---------------|---------------------------------------------|------------------------------|
| **定义** | 操作系统分配资源的最小单位 | 程序执行的最小单位 |
| **资源独立性** | 各进程独立运行，资源隔离 | 线程共享进程的资源 |
| **切换开销** | 较高，需切换内存等资源 | 较低，只切换CPU上下文 |
| **通信方式** | 需要IPC机制（管道、信号量、共享内存等） | 共享内存，通信简单高效 |

---

## 二、Java实现多线程的三种方式

Java支持三种主要方式实现多线程。

### 2.1 继承Thread类

继承`Thread`类并重写`run`方法。

**示例代码**：

```java
class MyThread extends Thread {
@Override
public void run() {
System.out.println(Thread.currentThread().getName() + " is running.");
}
}

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

**特点**：
- 每个线程表示为一个`Thread`对象。
- 使用`start`方法启动线程。

---

### 2.2 实现Runnable接口

通过实现`Runnable`接口，将任务逻辑写入`run`方法。

**示例代码**：

```java
class MyRunnable implements Runnable {
@Override
public void run() {
System.out.println(Thread.currentThread().getName() + " is running.");
}
}

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

**优点**：
- 支持多继承。
- 任务逻辑与线程对象分离，代码更灵活。

---

### 2.3 实现Callable接口

`Callable`接口支持返回结果和抛出异常。

**示例代码**：

```java
import java.util.concurrent.*;

class MyCallable implements Callable<String> {
@Override
public String call() throws Exception {
return Thread.currentThread().getName() + " has completed.";
}
}

public class CallableExample {
public static void main(String[] args) throws Exception {
ExecutorService executor = Executors.newSingleThreadExecutor();
Future<String> result = executor.submit(new MyCallable());
System.out.println(result.get());
executor.shutdown();
}
}
```

**特点**：
- 使用`Future`对象获取结果或检查任务状态。
- 支持更复杂的任务处理。

---

## 三、线程控制方法

Java提供了一系列方法控制线程的执行。

### 3.1 常用方法

| 方法名 | 描述 |
|-----------------------|-----------------------------------------------|
| `start()` | 启动线程并调用`run`方法。 |
| `sleep(milliseconds)` | 让线程休眠指定时间，释放CPU资源。 |
| `join()` | 等待当前线程执行完成。 |
| `yield()` | 暂时让出CPU时间片，供其他线程使用。 |
| `interrupt()` | 中断线程，触发`InterruptedException`异常。 |

**示例：线程休眠与等待**：

```java
public class ThreadControl {
public static void main(String[] args) throws InterruptedException {
Thread thread = new Thread(() -> {
try {
System.out.println("Thread sleeping...");
Thread.sleep(2000);
System.out.println("Thread awake!");
} catch (InterruptedException e) {
System.out.println("Thread interrupted!");
}
});

thread.start();
thread.join(); // 等待线程结束
System.out.println("Main thread finished.");
}
}
```

---

## 四、线程同步与共享资源

### 4.1 线程安全问题

当多个线程访问共享资源时，如果没有正确的同步，会导致数据不一致问题。

**示例：线程不安全的计数器**：

```java
class Counter {
private int count = 0;

public void increment() {
count++;
}

public int getCount() {
return count;
}
}

public class RaceCondition {
public static void main(String[] args) throws InterruptedException {
Counter counter = new Counter();
Runnable task = () -> {
for (int i = 0; i < 1000; i++) {
counter.increment();
}
};

Thread thread1 = new Thread(task);
Thread thread2 = new Thread(task);
thread1.start();
thread2.start();
thread1.join();
thread2.join();

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

---

### 4.2 使用`synchronized`实现线程同步

**示例代码**：

```java
class Counter {
private int count = 0;

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

public synchronized int getCount() {
return count;
}
}

public class SynchronizedExample {
public static void main(String[] args) throws InterruptedException {
Counter counter = new Counter();

Runnable task = () -> {
for (int i = 0; i < 1000; i++) {
counter.increment();
}
};

Thread thread1 = new Thread(task);
Thread thread2 = new Thread(task);
thread1.start();
thread2.start();
thread1.join();
thread2.join();

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