Java多线程-第20章
1.创建线程
Java是一种支持多线程编程的编程语言。多线程是指在同一程序中同时执行多个独立任务的能力。在Java中,线程是一种轻量级的子进程,它是程序中的最小执行单元。Java的多线程编程可以通过两种方式实现:继承Thread类或实现Runnable接口。
-
class MyThread extends Thread { public void run() { // 线程执行的代码 } }
MyThread myThread = new MyThread(); myThread.start(); // 启动线程
-
class MyRunnable implements Runnable { public void run() { // 线程执行的代码 } }
MyRunnable myRunnable = new MyRunnable(); Thread thread = new Thread(myRunnable); thread.start(); // 启动线程
所有的程序都是通过main
方法开始执行的。当一个Java程序启动时,JVM(Java虚拟机)会自动创建一个主线程,该线程负责执行main
方法。在多线程编程中,你可以创建额外的线程来执行其他任务。
Java提供了一些关键字和方法来控制线程的执行,其中一些关键字包括:
synchronized
:用于控制多个线程访问共享资源时的同步问题。wait()
、notify()
、notifyAll()
:用于实现线程间的通信和协调。sleep(long milliseconds)
:让线程休眠一段时间。join()
:等待一个线程终止。yield()
:让出CPU执行权,让其他线程执行。
多线程编程的主要挑战之一是避免竞态条件(Race Condition)和死锁(Deadlock)。竞态条件发生在多个线程试图同时访问和修改共享数据时,而死锁则是线程相互等待对方释放资源,导致所有线程都无法继续执行的情况。
- 新建(New): 线程已经创建,但还没有开始执行。
- 就绪(Runnable): 线程可以开始执行,等待CPU时间片。
- 运行(Running): 线程正在执行。
- 阻塞(Blocked): 线程被阻塞,等待某个事件的发生。
- 死亡(Terminated): 线程执行完成。
请注意,Java的多线程编程也有一些高级的概念和工具,如线程池、Callable和Future等,用于更灵活地处理多线程任务。
2.线程的生命周期
Java线程的生命周期描述了一个线程从创建到运行再到结束的整个过程,它包括多个状态,每个状态代表了线程在不同阶段的状态。Java线程的生命周期可以分为以下几个状态:
- 新建状态(New):
- 就绪状态(Runnable):
- 运行状态(Running):
- 阻塞状态(Blocked):
- 等待状态(Waiting):
- 超时等待状态(Timed Waiting):
- 终止状态(Terminated):
New -> Runnable -> (Running) -> Blocked -> (Runnable) -> (Terminated)
-> Waiting -> (Runnable) -> (Terminated)
-> Timed Waiting -> (Runnable) -> (Terminated)
注意,生命周期中的括号表示这些状态可能是短暂的,线程可能在运行、等待、超时等待等状态间切换。在实际的多线程应用中,正确地管理线程生命周期是至关重要的,以避免潜在的问题,如死锁、竞态条件等。
3.操作线程的方法
4.1线程的休眠
线程休眠是通过Thread.sleep(long milliseconds)
方法实现的。这个方法让当前正在执行的线程在指定的时间内进入休眠状态(即暂停执行),单位是毫秒。在指定时间过去或者线程被中断时,线程将恢复执行。
方法签名为:
public static native void sleep(long millis) throws InterruptedException;
注意,sleep
方法可能抛出InterruptedException
异常,因为线程在休眠时可以被其他线程中断。在处理中断时,可以选择捕获该异常并处理,或者将异常继续传播出去。
4.2线程的加入
在Java中,可以使用join()
方法来等待一个线程完成其执行。join()
方法的作用是使当前线程等待调用join()
方法的线程执行结束,然后再继续执行当前线程。
方法签名为:
public final void join() throws InterruptedException;
或者可以使用带有超时参数的join(long millis)
方法:
javaCopy code
public final synchronized void join(long millis) throws InterruptedException;
class MyThread extends Thread {
public void run() {
for (int i = 1; i <= 5; i++) {
System.out.println("Task " + i + " in progress by " + Thread.currentThread().getName());
try {
// 模拟任务执行时间
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
public class JoinExample {
public static void main(String[] args) {
MyThread thread1 = new MyThread();
MyThread thread2 = new MyThread();
// 启动线程1
thread1.start();
try {
// 等待线程1执行完成,然后再继续执行主线程
thread1.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
// 启动线程2
thread2.start();
// 主线程继续执行
System.out.println("Main thread continues its work.");
}
}
在这个例子中,主线程启动了thread1
,然后调用thread1.join()
等待thread1
执行完成,接着启动了thread2
。由于join()
方法会使主线程等待被调用的线程执行完成,所以在这个例子中主线程会等待thread1
执行完成后再启动thread2
。
4.3线程的中断
线程的中断是一种线程间的协作机制,它允许一个线程通知另一个线程,以请求它停止正在执行的任务。线程的中断通过调用interrupt()
方法来触发。
-
中断线程:
-
检查中断状态:
-
处理中断:
-
在线程的执行过程中,可以通过检查中断状态来决定是否停止执行。
public void run() { while (!Thread.interrupted()) { // 执行任务 } }
-
或者在抛出
InterruptedException
异常的地方处理中断。public void run() { try { while (true) { // 执行任务 if (Thread.interrupted()) { throw new InterruptedException(); } } } catch (InterruptedException e) { // 处理中断异常 } }
-
在处理中断时,可以选择终止线程的执行,或者采取其他适当的措施。
-
中断通常用于优雅地停止线程,而不是强制终止线程。这种协作的方式允许线程在中断请求到来时,完成正在进行的工作,并进行清理工作,提高程序的健壮性。
4.4线程的礼让
线程的礼让是指一个线程表明自己愿意让出当前的CPU执行时间,以便让其他线程有机会执行。我们可以使用Thread.yield()
方法来实现线程的礼让。
方法签名为:
public static native void yield();
Thread.yield()
方法是一个静态方法,调用它的线程会让出一些时间片,以便其他具有相同或更高优先级的线程有机会执行。然而,yield()
方法并不能保证线程会让出CPU执行权,它只是向调度器发出一个提示。
5.线程的优先级
线程调度器使用线程的优先级来决定哪个线程应该优先执行。线程的优先级是一个整数值,范围从Thread.MIN_PRIORITY
(1)到Thread.MAX_PRIORITY
(10)。默认情况下,每个线程的优先级都是Thread.NORM_PRIORITY
(5)。
线程的优先级可以通过setPriority(int priority)
方法进行设置。该方法必须在启动线程之前调用。
class MyThread extends Thread {
public void run() {
for (int i = 1; i <= 5; i++) {
System.out.println("Task " + i + " in progress by " + Thread.currentThread().getName());
}
}
}
public class PriorityExample {
public static void main(String[] args) {
MyThread thread1 = new MyThread();
MyThread thread2 = new MyThread();
// 设置线程1的优先级为最高
thread1.setPriority(Thread.MAX_PRIORITY);
// 启动线程1
thread1.start();
// 启动线程2
thread2.start();
}
}
在这个例子中,thread1
的优先级被设置为最高(Thread.MAX_PRIORITY
),而thread2
使用默认的优先级。在运行时,具有更高优先级的线程更有可能被调度执行,但并不能保证绝对顺序。
注意,线程优先级的调整并不是在所有平台上都能生效的,而且过度依赖线程优先级可能导致可移植性问题。在实际应用中,更重要的是编写稳健的多线程代码,而不是过分关注线程优先级。
6.线程同步
线程同步是一种机制,用于防止多个线程同时访问共享资源,从而避免数据不一致性和竞态条件。在Java中,主要的线程同步机制包括使用synchronized
关键字、wait()
、notify()
和notifyAll()
方法、以及Lock
和Condition
接口等。
6.1线程安全
线程安全是指多个线程访问某个共享资源时,不会出现不确定的结果或导致不一致性的情况。在多线程环境中,如果没有适当的同步机制,共享的数据结构可能会被多个线程同时修改,从而导致数据不一致或其他问题。确保线程安全是多线程编程中非常重要的一个方面。
以下是一些确保线程安全的常见方式:
-
使用同步方法: 在方法上使用
synchronized
关键字,确保一次只有一个线程可以执行该方法。public synchronized void synchronizedMethod() { // 同步的代码块 }
-
使用同步代码块: 在代码块中使用
synchronized
关键字,确保一次只有一个线程可以执行同步代码块。public void someMethod() { // 非同步代码 synchronized (lockObject) { // 同步的代码块 } // 非同步代码 }
-
使用
java.util.concurrent
包中的线程安全类: Java提供了一些线程安全的数据结构,如ConcurrentHashMap
、CopyOnWriteArrayList
等。Map<String, String> concurrentMap = new ConcurrentHashMap<>(); List<String> copyOnWriteList = new CopyOnWriteArrayList<>();
-
使用
Lock
和Condition
: 使用Lock
接口及其实现类来提供更细粒度的同步控制。Lock lock = new ReentrantLock(); Condition condition = lock.newCondition(); lock.lock(); try { // 临界区的代码 } finally { lock.unlock(); }
-
使用
volatile
关键字:volatile
关键字可以保证变量的可见性,但不能解决复合操作的原子性问题。private volatile boolean flag = false;
-
使用原子类:
java.util.concurrent.atomic
包中提供了一些原子类,如AtomicInteger
、AtomicLong
等,用于执行原子操作。AtomicInteger atomicInt = new AtomicInteger(0); atomicInt.incrementAndGet();
确保线程安全是一个综合性的问题,需要在设计阶段考虑,并采用适当的同步措施。选择合适的同步机制取决于具体的应用场景和性能要求。在设计和实现多线程程序时,充分了解并考虑线程安全性是至关重要的。
6.2线程同步机制
线程同步机制是一组用于确保多个线程访问共享资源时不会发生竞态条件和数据不一致的技术。以下是一些常见的线程同步机制:
-
// 同步方法 public synchronized void synchronizedMethod() { // 同步的代码块 } // 同步代码块 public void someMethod() { // 非同步代码 synchronized (lockObject) { // 同步的代码块 } // 非同步代码 }
-
Lock 和 Condition 接口:
Lock
接口提供了比synchronized
更灵活的锁定机制。通过ReentrantLock
实现类,可以使用lock()
和unlock()
方法来控制临界区的访问。Condition
接口用于在Lock
上创建条件变量,通过await()
、signal()
和signalAll()
方法实现更灵活的线程通信。
Lock lock = new ReentrantLock(); Condition condition = lock.newCondition(); lock.lock(); try { // 临界区的代码 } finally { lock.unlock(); }
-
volatile 关键字:
private volatile boolean flag = false;
-
Atomic 类:
AtomicInteger atomicInt = new AtomicInteger(0); atomicInt.incrementAndGet();
-
ReadWriteLock 接口:
ReadWriteLock rwLock = new ReentrantReadWriteLock(); rwLock.readLock().lock(); // 读取共享资源的操作 rwLock.readLock().unlock(); rwLock.writeLock().lock(); // 写入共享资源的操作 rwLock.writeLock().unlock();
这些机制可以根据具体的应用场景选择使用,每种机制都有其适用的情况。合理选择同步机制可以提高多线程程序的性能和可维护性,避免潜在的并发问题。
原文地址:https://blog.csdn.net/Sion_one/article/details/134683563
本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。
如若转载,请注明出处:http://www.7code.cn/show_18185.html
如若内容造成侵权/违法违规/事实不符,请联系代码007邮箱:suwngjj01@126.com进行投诉反馈,一经查实,立即删除!