Java 多线程基础概念
在 Java 中，多线程是实现并发编程的核心机制，允许程序同时执行多个任务，从而提高 CPU 利用率和程序响应速度，线程是进程中的执行单元，每个进程可以包含多个线程，它们共享进程的内存空间和资源，Java 提供了丰富的多线程 API，使开发者能够轻松创建和管理线程，理解多线程的基本概念，如线程的生命周期、同步机制以及线程安全，是高效开发多线程应用的前提。
创建线程的两种方式
Java 中创建线程主要有两种方式：继承 Thread 类和实现 Runnable 接口。
继承 Thread 类
通过继承 Thread 类并重写 run() 方法，可以自定义线程的执行逻辑，创建线程后，调用 start() 方法启动线程，JVM 会调用线程的 run() 方法。
class MyThread extends Thread {
@Override
public void run() {
System.out.println("Thread is running: " + Thread.currentThread().getName());
}
}
public class Main {
public static void main(String[] args) {
MyThread thread = new MyThread();
thread.start(); // 启动线程
}
}
需要注意的是，由于 Java 不支持多重继承，继承 Thread 类会限制类继承其他父类，因此在实际开发中较少使用这种方式。
实现 Runnable 接口
实现 Runnable 接口是更灵活的方式，因为它避免了类的继承限制，只需实现 Runnable 接口的 run() 方法，并将 Runnable 实例传递给 Thread 构造函数即可。
class MyRunnable implements Runnable {
@Override
public void run() {
System.out.println("Thread is running: " + Thread.currentThread().getName());
}
}
public class Main {
public static void main(String[] args) {
Thread thread = new Thread(new MyRunnable());
thread.start(); // 启动线程
}
}
从 Java 8 开始，还可以使用 Lambda 表达式简化 Runnable 的实现，
Thread thread = new Thread(() -> {
System.out.println("Thread is running: " + Thread.currentThread().getName());
});
thread.start();
线程的生命周期
线程的生命周期包括以下状态：
- 新建（New）：线程被创建但尚未启动。
- 就绪（Runnable）：线程已启动，等待 JVM 调度执行。
- 运行（Running）：线程正在执行
run()方法。 - 阻塞（Blocked）：线程因等待监视器锁或其他资源而暂停执行。
- 等待（Waiting）：线程无限期等待其他线程的通知。
- 超时等待（Timed Waiting）：线程在指定时间内等待。
- 终止（Terminated）：线程执行完毕或被强制终止。
通过 Thread 类的方法（如 sleep()、wait()、notify()）可以控制线程的状态转换。
线程同步与锁
在多线程环境下，多个线程同时访问共享资源可能导致数据不一致问题，Java 提供了多种同步机制来保证线程安全：
synchronized 关键字
synchronized 可以用于方法或代码块，确保同一时间只有一个线程可以访问被同步的资源。
class Counter {
private int count = 0;
public synchronized void increment() {
count++;
}
}
或使用同步代码块：
public void increment() {
synchronized (this) {
count++;
}
}
Lock 接口
java.util.concurrent.locks.Lock 提供了比 synchronized 更灵活的锁定机制，ReentrantLock，它支持尝试获取锁、可中断获取锁和超时获取锁等功能。
import java.util.concurrent.locks.ReentrantLock;
class Counter {
private int count = 0;
private final ReentrantLock lock = new ReentrantLock();
public void increment() {
lock.lock();
try {
count++;
} finally {
lock.unlock();
}
}
}
线程池的使用
直接创建和销毁线程会带来性能开销，线程池通过复用线程来提高效率，Java 提供了 Executor 框架来管理线程池，核心类是 ThreadPoolExecutor。
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++) {
executor.execute(() -> {
System.out.println("Task executed by: " + Thread.currentThread().getName());
});
}
executor.shutdown(); // 关闭线程池
}
}
常用的线程池类型包括：
newFixedThreadPool：固定大小线程池。newCachedThreadPool：可缓存线程池，根据需要创建线程。newSingleThreadExecutor：单线程线程池。
高级并发工具
Java 并发包（java.util.concurrent）提供了许多高级工具，简化多线程开发：
CountDownLatch
用于让一个或多个线程等待其他线程完成操作。
import java.util.concurrent.CountDownLatch;
public class Main {
public static void main(String[] args) throws InterruptedException {
CountDownLatch latch = new CountDownLatch(3);
for (int i = 0; i < 3; i++) {
new Thread(() -> {
System.out.println("Thread finished");
latch.countDown();
}).start();
}
latch.await(); // 等待所有线程完成
System.out.println("All threads completed");
}
}
Semaphore
用于控制同时访问特定资源的线程数量。
import java.util.concurrent.Semaphore;
public class Main { {
Semaphore semaphore = new Semaphore(3); // 限制最多3个线程同时访问
for (int i = 0; i < 10; i++) {
new Thread(() -> {
try {
semaphore.acquire(); // 获取许可
System.out.println("Thread accessing resource");
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
semaphore.release(); // 释放许可
}
}).start();
}
}
}
线程安全的集合类
Java 提供了线程安全的集合类，如 ConcurrentHashMap、CopyOnWriteArrayList 等，用于在多线程环境下安全地操作数据。
import java.util.concurrent.ConcurrentHashMap;
public class Main { {
ConcurrentHashMap<String, Integer> map = new ConcurrentHashMap<>();
map.put("key", 1);
System.out.println(map.get("key"));
}
}
Java 多线程编程是构建高性能并发应用的基础，通过继承 Thread 类或实现 Runnable 接口可以创建线程，使用 synchronized 和 Lock 实现同步，借助线程池提高资源利用率，并利用高级并发工具简化复杂场景的开发，在实际开发中，需注意线程安全问题，合理选择同步机制和并发工具,以确保程序的正确性和高效性。
