Java多线程是指在一个进程内有多个执行路径或控制单元,每个单元被称为一个线程。每个线程都有自己的栈、程序计数器和局部变量等独立的运行资源。这种设计使得多个线程可以同时运行,每个线程并行处理不同的任务,从而提高了整体的执行效率。
线程的周期
-
新建(New):线程对象被创建后,就进入了新建状态。此时,线程对象已经分配了内存空间,但还没有调用start()方法启动线程。
-
就绪(Runnable):当调用线程对象的start()方法后,线程进入就绪状态。此时,线程对象已经具备了运行条件,等待系统为其分配CPU资源。在就绪状态下的线程有可能立即获得CPU资源并开始执行,也可能因为其他线程占用了CPU资源而暂时无法执行。
-
运行(Running):当线程获得CPU资源并开始执行时,线程进入运行状态。此时,线程正在执行其run()方法中的代码。
-
阻塞(Blocked):线程在运行过程中可能会遇到某些条件不满足的情况,导致线程进入阻塞状态。例如,线程在等待I/O操作完成、等待获取锁等情况下会进入阻塞状态。在阻塞状态下,线程暂时无法继续执行。
-
等待(Waiting):线程在某些情况下需要主动放弃对共享资源的占用权,进入等待状态。例如,线程在调用Object类的wait()方法或Thread类的join()方法时会进入等待状态。在等待状态下,线程暂时无法继续执行,直到其他线程唤醒它或者超时。
-
超时等待(Timed Waiting):与等待状态类似,但等待时间有限。当等待超过指定的时间后,线程会自动返回到等待队列中重新竞争资源。
-
终止(Terminated):当线程执行完run()方法中的代码或者因为异常而终止时,线程进入终止状态。此时,线程已经结束运行,不再占用系统资源。
Java多线程的优点
- 提高系统吞吐率:多线程编程可以使一个进程有多个并发的操作,从而提高系统的处理能力。
- 更好地利用系统资源:采用多线程技术的应用程序可以更充分地利用CPU的空闲时间片,以更少的时间响应用户请求,从而提高进程的整体运行效率。
- 增强应用程序的灵活性:由于同一进程的所有线程共享同一内存,不需要特殊的数据传送机制,也不需要建立共享存储区或共享文件,从而使得不同任务之间的协调操作与运行、数据的交互、资源的分配等问题更加易于解决。
- 简化程序设计:在某些情况下,多线程程序设计可能比单线程程序设计更简单。
Java多线程的使用
-
创建线程:Java中可以通过两种方式创建线程,一种是通过实现Runnable接口来创建线程,另一种是通过继承Thread类来创建线程。
-
启动线程:创建线程后,需要调用start()方法来启动线程,该方法会调用线程的run()方法。
-
控制线程:Java提供了一些方法来控制线程的执行,例如sleep()方法可以让线程暂停执行一段时间,join()方法可以让当前线程等待另一个线程执行完毕后再继续执行。
-
同步线程:在多线程环境下,多个线程可能会同时访问共享资源,这可能会导致数据不一致的问题。为了避免这种情况,可以使用synchronized关键字来同步线程,确保同一时间只有一个线程能够访问共享资源。
-
结束线程:当线程完成任务后,需要调用stop()方法来结束线程。但需要注意的是,由于stop()方法是过期的API,因此不推荐使用。更好的做法是设置一个标志位,让线程在某个条件满足时自行退出循环并结束。
如何创建线程
- 实现Runnable接口:创建一个类,实现Runnable接口,并重写run()方法。然后在主程序中创建该类的实例,并将其作为参数传递给Thread类的构造函数来创建线程。
class MyRunnable implements Runnable {
public void run() {
System.out.println("This is a thread.");
}
}
public class Main {
public static void main(String[] args) {
MyRunnable myRunnable = new MyRunnable();
Thread thread = new Thread(myRunnable);
thread.start();
}
}
- 继承Thread类:创建一个类,继承Thread类,并重写run()方法。然后在主程序中创建该类的实例,调用start()方法来启动线程。
class MyThread extends Thread {
public void run() {
System.out.println("This is a thread.");
}
}
public class Main {
public static void main(String[] args) {
MyThread myThread = new MyThread();
myThread.start();
}
}
两种方式的对比
-
实现方式不同:继承Thread类需要重写run()方法,而实现Runnable接口需要重写run()方法。
-
适用场景不同:继承Thread类适合于单继承的情况,因为Java不支持多重继承;而实现Runnable接口适合于多继承的情况,因为Java支持多重继承。
-
资源消耗不同:由于Java不支持多重继承,因此继承Thread类的子类不能再继承其他类;而实现Runnable接口的类可以继续继承其他类。此外,由于Java不支持多重继承,因此使用继承Thread类的方式创建线程时,每个线程都会占用一定的系统资源(比如内存),而使用实现Runnable接口的方式创建线程时,每个线程只会占用很少的系统资源。
-
代码可读性不同:由于实现Runnable接口的方式更加灵活,可以方便地创建多个线程,因此这种方式的代码可读性更好。
线程安全
什么是线程安全
线程安全是指在多线程环境下,多个线程同时访问共享资源时,程序的行为仍然能够按照预期的方式进行,不会出现数据竞争、死锁等异常情况。在多线程编程中,由于多个线程可能会同时访问和修改同一块内存空间,因此需要采取一些措施来保证线程安全。这些措施包括使用同步机制(如synchronized关键字、Lock接口及其实现类等)来保证各个线程都能够正常且准确地执行,或者使用原子操作类(如AtomicInteger、AtomicLong等)来执行无锁的多个操作。此外,也可以通过使用并发容器(如ConcurrentHashMap、CopyOnWriteArrayList等)或volatile关键字来确保线程安全。简而言之,线程安全的最终目标就是正确的结果等于安全。
Java中如何保证线程安全
- 使用synchronized关键字:通过在方法或代码块上添加synchronized关键字,可以确保同一时间只有一个线程能够访问该方法或代码块。
public class SynchronizedExample {
private int count = 0;
// 使用synchronized关键字修饰方法
public synchronized void increment() {
count++;
System.out.println("当前计数值:" + count);
}
public static void main(String[] args) {
SynchronizedExample example = new SynchronizedExample();
// 创建两个线程,分别调用increment方法
Thread thread1 = new Thread(() -> {
for (int i = 0; i < 1000; i++) {
example.increment();
}
});
Thread thread2 = new Thread(() -> {
for (int i = 0; i < 1000; i++) {
example.increment();
}
});
// 启动线程
thread1.start();
thread2.start();
// 等待线程执行完毕
try {
thread1.join();
thread2.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
// 输出2000
System.out.println("最终计数值:" + example.count);
}
}
- 使用Lock接口及其实现类(如ReentrantLock):Lock接口提供了与synchronized关键字类似的功能,但更加灵活。它允许多个线程同时访问共享资源,但需要手动控制锁的获取和释放。
- lock():获取锁,如果锁已经被其他线程持有,则当前线程会阻塞等待。
- unlock():释放锁,只有持有锁的线程才能调用此方法。
- tryLock():尝试获取锁,如果锁已经被其他线程持有,则立即返回false,否则获取锁并返回true。
- lockInterruptibly():与tryLock()类似,但是当锁被其他线程持有时,当前线程会抛出InterruptedException异常。
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class LockExample {
private final Lock lock = new ReentrantLock();
public void doSomething() {
lock.lock(); // 获取锁
try {
// 临界区代码
System.out.println("执行临界区代码");
} finally {
lock.unlock(); // 释放锁
}
}
public static void main(String[] args) {
LockExample example = new LockExample();
example.doSomething();
}
}
- 使用原子操作类(如AtomicInteger、AtomicLong等):原子操作类提供了一种无锁的方式来执行多个操作,从而避免了竞争条件的发生。
- AtomicInteger:原子整数类,提供原子操作的整数值
import java.util.concurrent.atomic.AtomicInteger;
public class AtomicIntegerDemo {
public static void main(String[] args) {
AtomicInteger atomicInteger = new AtomicInteger(0);
int oldValue, newValue;
do {
oldValue = atomicInteger.get();
newValue = oldValue + 1;
} while (!atomicInteger.compareAndSet(oldValue, newValue));
System.out.println("AtomicInteger value: " + atomicInteger.get());
}
}
- AtomicLong:原子长整数类,提供原子操作的长整数值。
import java.util.concurrent.atomic.AtomicLong;
public class AtomicLongDemo {
public static void main(String[] args) {
AtomicLong atomicLong = new AtomicLong(0);
long oldValue, newValue;
do {
oldValue = atomicLong.get();
newValue = oldValue + 1;
} while (!atomicLong.compareAndSet(oldValue, newValue));
System.out.println("AtomicLong value: " + atomicLong.get());
}
}
- AtomicBoolean:原子布尔类,提供原子操作的布尔值。
import java.util.concurrent.atomic.AtomicBoolean;
public class AtomicBooleanDemo {
public static void main(String[] args) {
AtomicBoolean atomicBoolean = new AtomicBoolean(false);
boolean oldValue, newValue;
do {
oldValue = atomicBoolean.get();
newValue = !oldValue;
} while (!atomicBoolean.compareAndSet(oldValue, newValue));
System.out.println("AtomicBoolean value: " + atomicBoolean.get());
}
}
-
使用并发容器(如ConcurrentHashMap、CopyOnWriteArrayList等):并发容器是一种特殊的数据结构,可以在多线程环境下提供高效的并发访问。它们内部使用了各种同步机制来保证线程安全。
-
使用volatile关键字:volatile关键字可以确保变量的可见性,即当一个线程修改了变量的值后,其他线程能够立即看到修改后的值。但它不能保证复合操作的原子性,因此不能替代synchronized关键字。
public class VolatileExample {
private volatile boolean flag = false;
public void setFlag(boolean value) {
this.flag = value;
}
public boolean getFlag() {
return flag;
}
public static void main(String[] args) throws InterruptedException {
VolatileExample example = new VolatileExample();
// 创建两个线程,分别设置和获取flag的值
Thread thread1 = new Thread(() -> {
for (int i = 0; i < 10; i++) {
example.setFlag(true);
System.out.println("Thread 1 set flag to true");
}
});
Thread thread2 = new Thread(() -> {
for (int i = 0; i < 10; i++) {
System.out.println("Thread 2 get flag: " + example.getFlag());
}
});
thread1.start();
thread2.start();
thread1.join();
thread2.join();
}
}
线程的通信
- 共享内存:线程之间共享数据,通过读写这些数据来实现通信。这种方式需要特别注意同步问题,避免出现竞态条件。
public class SharedMemoryExample {
private int count = 0;
public void increment() {
count++;
}
public int getCount() {
return count;
}
}
public class IncrementThread extends Thread {
private SharedMemoryExample sharedMemory;
public IncrementThread(SharedMemoryExample sharedMemory) {
this.sharedMemory = sharedMemory;
}
@Override
public void run() {
for (int i = 0; i < 1000; i++) {
sharedMemory.increment();
}
}
}
public class Main {
public static void main(String[] args) throws InterruptedException {
SharedMemoryExample sharedMemory = new SharedMemoryExample();
IncrementThread thread1 = new IncrementThread(sharedMemory);
IncrementThread thread2 = new IncrementThread(sharedMemory);
thread1.start();
thread2.start();
thread1.join();
thread2.join();
System.out.println("最终计数值:" + sharedMemory.getCount());
}
}
- 消息传递:线程之间通过发送和接收消息来通信。这种方式可以避免同步问题,但需要考虑消息的可靠性和顺序性等问题。
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;
public class MessagePassingExample {
public static void main(String[] args) throws InterruptedException {
BlockingQueue<String> queue = new LinkedBlockingQueue<>();
Producer producer = new Producer(queue);
Consumer consumer = new Consumer(queue);
producer.start();
consumer.start();
producer.join();
consumer.join();
}
}
class Producer extends Thread {
private BlockingQueue<String> queue;
public Producer(BlockingQueue<String> queue) {
this.queue = queue;
}
@Override
public void run() {
try {
for (int i = 0; i < 1000; i++) {
String message = "Message " + i;
queue.put(message);
System.out.println("生产者发送消息:" + message);
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
class Consumer extends Thread {
private BlockingQueue<String> queue;
public Consumer(BlockingQueue<String> queue) {
this.queue = queue;
}
@Override
public void run() {
try {
while (true) {
String message = queue.take();
System.out.println("消费者接收消息:" + message);
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
总结
Java多线程在实际编码应用中比较广泛,可以提高接口响应速度和提升处理数据的速度。当然,在使用Java多线程时,需要注意一些事项,否则会造成不可预估的后果。
- 要避免共享资源的竞争条件,这可能导致数据不一致或程序崩溃。
- 需要避免死锁,即多个线程互相等待对方释放资源而导致的程序停滞
- 要注意线程安全,确保数据在并发访问时的正确性。
- 合理的线程数量也非常重要,避免过多线程导致系统资源过度消耗
下一章将继续介绍线程池的使用