引言
在现代计算机系统中，多线程编程是提高应用程序性能和响应能力的关键技术之一。Java，作为一种广泛应用的编程语言，提供了强大的多线程支持。本文将深入探讨Java多线程的基本概念、实现方法以及如何通过实例代码展示其应用。
多线程基础
什么是多线程？
多线程是指在一个程序中同时运行多个线程（Thread）。每个线程可以看作是一个独立的执行路径，它们可以并发地执行，从而提高程序的执行效率。
Java中的线程
在Java中，线程可以通过两种方式创建：
继承 Thread类。实现 Runnable接口。
线程的生命周期
Java线程的生命周期包括以下几个状态：
新建（New） 就绪（Ready） 运行（Running） 阻塞（Blocked） 等待（Waiting） 超时等待（Timed Waiting） 终止（Terminated）
实现多线程
继承Thread类
通过继承Thread类，可以创建一个新的线程类。然后，通过覆盖run()方法，定义线程的执行体。
public class MyThread extends Thread {
@Override
public void run() {
System.out.println("Thread is running!");
}
public static void main(String[] args) {
MyThread thread = new MyThread();
thread.start(); // 启动线程
}
}
实现Runnable接口
实现Runnable接口是另一种创建线程的方式。这种方式更加灵活，因为Java单继承的限制使得继承Thread类可能不够灵活。
public class MyRunnable implements Runnable {
@Override
public void run() {
System.out.println("Runnable is running!");
}
public static void main(String[] args) {
MyRunnable myRunnable = new MyRunnable();
Thread thread = new Thread(myRunnable);
thread.start(); // 启动线程
}
}
线程同步
问题的提出
当多个线程同时访问共享资源时，可能会产生线程安全问题。例如，两个线程同时对一个变量进行加减操作，可能会导致结果不正确。
解决方案
Java提供了多种机制来解决线程安全问题，其中最常用的是synchronized关键字。
synchronized方法
在方法上使用synchronized关键字，可以确保该方法在同一时刻只能由一个线程访问。
public class Counter {
private int count = 0;
public synchronized void increment() {
count++;
}
public synchronized int getCount() {
return count;
}
}
synchronized块
如果只想同步方法中的一部分代码，可以使用synchronized块。
public class Counter {
private int count = 0;
private final Object lock = new Object();
public void increment() {
synchronized (lock) {
count++;
}
}
public int getCount() {
synchronized (lock) {
return count;
}
}
}
线程间通信
wait()和notify()
wait()和notify()是Object类中的方法，用于实现线程间的通信。wait()使当前线程等待，notify()唤醒等待的线程。
public class SharedResource {
private boolean isReady = false;
public synchronized void waitForReady() {
while (!isReady) {
try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
public synchronized void ready() {
isReady = true;
notify();
}
}
实例代码：生产者-消费者问题
生产者-消费者问题是多线程编程中的经典问题。通过这个问题，我们可以展示如何使用线程同步和线程间通信。
import java.util.LinkedList;
import java.util.Queue;
class Producer implements Runnable {
private final Queue<Integer> queue = new LinkedList<>();
private final int LIMIT = 10;
private final Object lock = new Object();
@Override
public void run() {
int value = 0;
while (true) {
synchronized (lock) {
while (queue.size() == LIMIT) {
try {
lock.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
queue.add(value);
System.out.println("Produced " + value);
value++;
lock.notify();
}
}
}
}
class Consumer implements Runnable {
private final Queue<Integer> queue = new LinkedList<>();
private final int LIMIT = 10;
private final Object lock = new Object();
@Override
public void run() {
while (true) {
synchronized (lock) {
while (queue.isEmpty()) {
try {
lock.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
int value = queue.poll();
System.out.println("Consumed " + value);
lock.notify();
}
}
}
}
public class ProducerConsumer {
public static void main(String[] args) {
Queue<Integer> queue = new LinkedList<>();
Thread producerThread = new Thread(new Producer());
Thread consumerThread = new Thread(new Consumer());
producerThread.start();
consumerThread.start();
}
}
// 注意：上面的生产者消费者实例代码有问题，因为Producer和Consumer操作的不是同一个queue对象。
// 下面是修正后的版本：
import java.util.LinkedList;
import java.util.Queue;
class Producer implements Runnable {
private final Queue<Integer> queue;
private final int LIMIT = 10;
public Producer(Queue<Integer> queue) {
this.queue = queue;
}
@Override
public void run() {
int value = 0;
while (true) {
synchronized (queue) {
while (queue.size() == LIMIT) {
try {
queue.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
queue.add(value);
System.out.println("Produced " + value);
value++;
queue.notify();
}
}
}
}
class Consumer implements Runnable {
private final Queue<Integer> queue;
public Consumer(Queue<Integer> queue) {
this.queue = queue;
}
@Override
public void run() {
while (true) {
synchronized (queue) {
while (queue.isEmpty()) {
try {
queue.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
int value = queue.poll();
System.out.println("Consumed " + value);
queue.notify();
}
}
}
}
public class ProducerConsumer {
public static void main(String[] args) {
Queue<Integer> queue = new LinkedList<>();
Thread producerThread = new Thread(new Producer(queue));
Thread consumerThread = new Thread(new Consumer(queue));
producerThread.start();
consumerThread.start();
}
}
在这个修正后的版本中，Producer和Consumer类都接受一个Queue对象作为参数，从而确保它们操作的是同一个队列。通过synchronized关键字和wait()、notify()方法，实现了线程间的同步和通信。
结论
Java多线程编程是一个复杂而强大的领域。通过本文的介绍，我们了解了Java线程的基本概念、实现方法以及线程同步和通信的基本机制。通过实例代码，我们进一步加深了对这些概念的理解。在实际应用中，多线程编程需要谨慎处理线程安全问题，以确保程序的正确性和稳定性。
原文作者：后端Q；如有侵权，请联系管理员删除。
