多线程是一种
同时执行多个线程的机制,它使得程序能够
更有效地利用 CPU 资源,提高系统的响应性。在 Java 中,多线程是一项强大的特性,允许程序在同一时间执行多个独立的任务。
进程和线程
进程(Process)
进程是程序的一次动态执行,需要经历从代码加载,代码执行以及执行完毕的一个完整的过程。由于 CPU
的具备分时机制,也即把 CPU
划分为无数个小的时间片,每个时间片去执行一个进程(程序),让我们感觉程序在同时运行一样。
线程(Thread)
线程是进程中的一个执行单元,负责执行程序中的代码。一个进程可以包含多个线程,它们共享进程的资源。线程之间共享同一份内存,因此线程间通信更加容易。
线程的创建
1)继承 Thread 类
通过继承 Thread
类,可以创建一个线程类,然后重写 run()
方法,该方法包含线程要执行的代码
实例代码:
public class Demo {
public static void main(String[] args) {
// 创建线程
ThreadDemo thread1 = new ThreadDemo();
ThreadDemo thread2 = new ThreadDemo();
// 启动线程
thread1.start();
thread2.start();
}
}
class ThreadDemo extends Thread {
public void run() {
// 线程执行的任务
for (int i = 0; i < 5; i++) {
System.out.println(Thread.currentThread().getId() + " Value " + i);
}
}
}
21 Value 0
20 Value 0
20 Value 1
21 Value 1
21 Value 2
21 Value 3
21 Value 4
20 Value 2
20 Value 3
20 Value 4
2)实现 Runnable 接口
通过实现 Runnable
接口,可以将线程的任务封装在一个类中,然后创建 Thread
对象并将该类的实例传递给 Thread
的构造函数
实例代码:
public class Demo {
public static void main(String[] args) {
// 创建线程
Thread thread1 = new Thread(new RunnableDemo());
Thread thread2 = new Thread(new RunnableDemo());
// 启动线程
thread1.start();
thread2.start();
}
}
class RunnableDemo implements Runnable {
public void run() {
// 线程执行的任务
for (int i = 0; i < 5; i++) {
System.out.println(Thread.currentThread().getId() + " Value " + i);
}
}
}
20 Value 0
20 Value 1
21 Value 0
21 Value 1
21 Value 2
21 Value 3
21 Value 4
20 Value 2
20 Value 3
20 Value 4
3)使用 Lambda 表达式
在 Java 8 及以后的版本,可以使用 Lambda
表达式简化创建线程的代码
实例代码:
public class Demo {
public static void main(String[] args) {
// 使用Lambda表达式创建线程1
Thread thread1 = new Thread(() -> {
for (int i = 0; i < 5; i++) {
System.out.println(Thread.currentThread().getId() + " Value " + i);
}
});
// 使用Lambda表达式创建线程2
Thread thread2 = new Thread(() -> {
for (int i = 0; i < 5; i++) {
System.out.println(Thread.currentThread().getId() + " Value " + i);
}
});
// 启动线程
thread1.start();
thread2.start();
}
}
20 Value 0
21 Value 0
20 Value 1
20 Value 2
20 Value 3
21 Value 1
20 Value 4
21 Value 2
21 Value 3
21 Value 4
4)总结
无论采用哪种方式,都需要调用 start()
方法来启动线程。 start()
方法会在一个新的线程中调用 run()
方法。避免直接调用 run()
方法,因为这样并不会在新线程中执行,而只是在当前线程中作为普通的方法调用。
推荐使用 Runnable
接口的方式,因为 Java 不支持多重继承,而通过实现接口更为灵活可以避免这个限制。 此外,Runnable
接口可以被多个线程共享,提高代码的可复用性。
线程的状态
状态的分类
- 新建(New): 线程被创建但尚未启动。
- 就绪(Runnable): 线程处于就绪状态,等待系统调度执行。
- 运行(Running): 线程正在执行其任务。
- 阻塞(Blocked): 线程被阻塞,等待获取某个锁或等待某个资源。
- 等待(Waiting): 线程无限期等待另一个线程执行特定操作。
- 超时等待(Timed Waiting): 线程等待另一个线程执行特定操作,但具有等待超时时间。
- 终止(Terminated): 线程已经执行完毕或因异常而终止。
示例代码:
public class ThreadStateDemo {
public static void main(String[] args) {
Thread thread = new Thread(() -> {
// 在新建状态
printThreadState("New");
// 启动线程,进入就绪状态
Thread.yield();
printThreadState("Runnable");
// 线程获取锁,进入运行状态
synchronized (ThreadStateDemo.class) {
printThreadState("Running");
// 线程调用wait(),进入等待状态
try {
ThreadStateDemo.class.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
printThreadState("Waiting");
// 等待超时后重新进入运行状态
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
printThreadState("Running");
}
});
// 新建状态
printThreadState("New");
// 启动线程,进入就绪状态
thread.start();
Thread.yield();
printThreadState("Runnable");
// 主线程等待一会儿
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
// 线程被唤醒,进入就绪状态
synchronized (ThreadStateDemo.class) {
ThreadStateDemo.class.notify();
}
Thread.yield();
printThreadState("Runnable");
// 主线程等待线程执行完毕
try {
thread.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
// 终止状态
printThreadState("Terminated");
}
private static void printThreadState(String state) {
long tid = Thread.currentThread().getId();
System.out.println("Thread State: " + state + ", Thread ID: " + tid);
}
}
Thread State: New, Thread ID: 1
Thread State: Runnable, Thread ID: 1
Thread State: New, Thread ID: 20
Thread State: Runnable, Thread ID: 20
Thread State: Running, Thread ID: 20
Thread State: Waiting, Thread ID: 20
Thread State: Runnable, Thread ID: 1
Thread State: Running, Thread ID: 20
Thread State: Terminated, Thread ID: 1
在这个例子中,通过一个新建的线程演示了新建、就绪、运行、等待等状态的转换。注意到在等待状态时,通过notify()
方法唤醒线程,然后等待超时后重新进入运行状态。最后,主线程等待新建的线程执行完毕,线程进入终止状态。这个例子模拟了多线程状态的典型转换过程。
状态间转换
- 新建 -> 就绪: 调用线程的
start()
方法。 - 就绪 -> 运行: 线程被系统调度执行。
- 运行 -> 就绪: 线程调用
yield()
方法,主动让出CPU时间。 - 运行 -> 阻塞: 线程调用阻塞式的IO操作,等待锁,或者调用
sleep()
等方法。 - 阻塞 -> 就绪: 阻塞的原因消失。
- 运行/阻塞 -> 终止: 线程执行完
run()
方法或者因为异常退出了run()
方法。 - 等待 -> 就绪/阻塞: 调用了
notify()
、notifyAll()
方法,或者等待的时间到了。 - 超时等待 -> 就绪/阻塞: 等待时间到了,或者调用
notify()
、notifyAll()
方法。
多线程编程是一门复杂而有趣的艺术,合理的多线程设计能够提高程序的性能和响应性。在进行多线程编程时,了解线程的基本概念、合理使用同步和通信机制,以及注意最佳实践,将有助于编写出高质量、可维护的多线程程序。
原文地址:https://blog.csdn.net/yanyc0411/article/details/134796832
本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。
如若转载,请注明出处:http://www.7code.cn/show_42286.html
如若内容造成侵权/违法违规/事实不符,请联系代码007邮箱:suwngjj01@126.com进行投诉反馈,一经查实,立即删除!