一、多线程概述
现代操作系统(Windows
,macOS
,Linux
)都可以执行多任务。多任务就是同时运行多个任务。例如:播放音乐的同时,浏览器可以进行文件下载,同时可以进行QQ消息的收发。
CPU
执行代码都是一条一条顺序执行的,但是,即使是单核CPU
,也可以同时运行多个任务。因为操作系统执行多任务实际上就是让CPU
对多个任务轮流交替执行。
操作系统轮流让多个任务交替执行,例如,让浏览器执行0.001
秒,让QQ执行0.001
秒,再让音乐播放器执行0.001
秒。在用户使用的体验看来,CPU
就是在同时执行多个任务。
二、进程与线程
2.1.什么是程序?
程序是含有指令和数据的文件,被存储在磁盘或其他的数据存储设备中,可以理解为程序是包含静态代码的文件。例如:浏览器软件、音乐播放器软件等软件的安装目录和文件。
2.2.什么是进程?
进程是程序的一次执行过程,是系统运行程序的基本单位。在Windows
系统中,每一个正在执行的exe
文件或后台服务,都是一个进程,由操作系统统一管理并分配资源,因此进程是动态的。 例如:正在运行中的浏览器就是一个进程,正在运行中的音乐播放器是另一个进程,同理,正在运行中的QQ
和WPS
等都是进程。
操作系统运行一个程序,即是一个进程从创建,运行到消亡的过程。简单来说,一个进程就是一个执行中的程序,它在计算机中一个指令接着一个指令地执行着, 同时,每个进程还占有某些系统资源如 CPU
时间,内存空间,文件,输入输 出设备的使用权等。
2.3.什么是线程?
某些进程内部还需要同时执行多个子任务。例如,我们在使用WPS
时,WPS
可以让我们一边打字,一边进行拼写检查,同时还可以在后台进行自动保存和上传云文档,我们把子任务称为线程。线程是进程划分成的更小的运行单位。
进程和线程的关系就是:一个进程可以包含一个或多个线程,但至少会有一个主线程。
┌──────────┐
│Process │
│┌────────┐│
┌──────────┐││ Thread ││┌──────────┐
│Process ││└────────┘││Process │
│┌────────┐││┌────────┐││┌────────┐│
┌──────────┐││ Thread ││││ Thread ││││ Thread ││
│Process ││└────────┘││└────────┘││└────────┘│
│┌────────┐││┌────────┐││┌────────┐││┌────────┐│
││ Thread ││││ Thread ││││ Thread ││││ Thread ││
│└────────┘││└────────┘││└────────┘││└────────┘│
└──────────┘└──────────┘└──────────┘└──────────┘
┌──────────────────────────────────────────────┐
│ Operating System │
└──────────────────────────────────────────────┘
2.4.进程与线程的区别?
根本区别:进程是操作系统资源分配的基本单位,而线程是处理器任务调度和执行的基本单位;
资源开销:每个进程都有独立的代码副本和数据空间,进程之间的切换,资源开销较大;线程可以看做轻量级的进程,每个线程都有自己独立的运行栈和程序计数器,线程之间切换,资源开销小;
包含关系:一个进程内包含有多个线程,在执行过程,线程的执行不是线性串行的,而是多条线程并行共同完成;
内存分配:同一进程内的所有线程共享本进程的内存空间和资源;进程之间的内存空间和资源相互独立;
影响关系:一个进程崩溃后,在保护模式下不会对其他进程产生影响;一个线程崩溃,会导致整个进程退出。所以多进程要比多线程健壮;
执行过程:每个独立的进程有程序运行的入口和程序出口。但是线程不能独立执行,必须依存在应用程序(进程)中,由应用程序提供多个线程执行控制;
2.5JVM进程
2.5.1JVM进程的内存区域分配
JVM进程启动时,自动创建
Heap
(堆区)和Metaspace
(元空间,JDK1.8
以前叫Method Area
方法区);
多个线程共享
JVM
进程的Heap
(堆区)和Metaspace
(元空间)资源,但每个线程有自己的程序计数器、虚拟机栈和本地方法栈。系统在产生一个线程,或是在各个线程之间作切换工作时,负担要比进程小得多,因此,线程也被称为轻量级进程。
三、线程基本概念
单线程:单线程就是进程中只有一个线程。单线程在程序执行时,所走的程序路径按照连续顺序排下来,前面的必须处理好,后面的才会执行
多线程:由一个以上的线程组成的程序称为多线程程序。Java中,一定是从主线程开始执行(main方法),然后在主线程的某个位置创建并启动新的线程。
四、线程的创建与启动
通过创建Thread
实例,完成线程的创建。
线程的内部实现可以通过继承Thread
类、实现Runnable
接口等方式进行封装。
通过过调用Thread
实例的start()
方法启动新线程。
查看Thread
类的源代码,会看到start()
方法内部调用了一个private native void start0()
方法,native
修饰符表示这个方法是由JVM
虚拟机内部的C
代码实现的本地方法,由JVM
根据当前操作系统进行本地实现。
public class Main {
public static void main(String[] args) {
// Step1: main主线程执行输出
System.out.println("main start...");
// Step2: main主线程,创建子线程sub,输出字母A-Z
Thread sub = new Thread() {
// Step4:子线程被执行时,自动调用run()方法
public void run() {
for(char c='A';c<='Z';c++){
System.out.println("子线程:" + c);
}
}
};
// Step3: main主线程,启动子线程sub
sub.start();
// Step4: main主线程执行输出字母的ASCII码
for(int c ='a';c<='z';c++){
System.out.println("main线程:" + c);
}
System.out.println("main end...");
}
}
五、线程创建的四种方式
5. 1 方式一:继承 java.lang.Thread
类(线程子类)
// 线程子类
public class SubThread extends Thread {
public void run() {
for (int i = 0; i < 10000; i++) {
System.out.println("子线程" + i + " ");
}
}
}
// 主线程main
public class MultiThread {
public static void main(String[] args) {
//创建并启动子线程
SubThread thd = new SubThread();
thd.start();
//主线程继续同时向下执行
for (int i = 0; i < 10000; i++) {
System.out.println("主线程" + i + " ");
}
}
}
5. 2 方式二:实现 java.lang.Runnable
接口(线程执行类)
// 线程执行类
public class SubThread implements Runnable {
public void run() {
for (int i = 0; i < 10000; i++) {
System.out.println("子线程" + i + " ");
}
}
}
// 主线程 main
public class MultiThread {
public static void main(String[] args) {
//创建并启动子线程
Thread t = new Thread(new SubThread());
t.start();
//主线程继续同时向下执行
for (int i = 0; i < 10000; i++) {
System.out.println("主线程" + i + " ");
}
}
}
5. 3 方式三:实现 java.util.concurrent.Callable
接口,允许子线程返回结果、抛出异常
// 实现子线程
public class SubThread implements Callable<Integer>{
private int begin,end;
public SubThread(int begin,int end){
this.begin = begin;
this.end = end;
}
@Override
public Integer call() throws Exception {
int result = 0;
for(int i=begin;i<=end;i++){
result+=i;
}
return result;
}
}
5. 4 方式四:线程池
// 创建固定大小的线程池
ExecutorService threadPool = Executors.newFixedThreadPool(10);
while (true) {
// 提交多个执行任务至线程池,并执行
threadPool.execute(new Runnable() {
@Override
public void run() {
System.out.println("当前运行的线程名为: " + Thread.currentThread().getName());
try {
Thread.sleep(1000);
} catch (Exception e) {
throw new RuntimeException(e);
}
}
});
}
六、线程的命名
调用父类的
setName()
方法或在构造方法中给线程名字赋值;
如果没有为线程命名,系统会默认指定线程名,命名规则是
Thread-N
的形式
七、线程的休眠
在线程中,可以通过调用Thread.sleep(long millis)
,强迫当前线程按照指定毫秒值休眠。
通过调整子线程和main
主线程的休眠时间长短,观察执行结果:
public class Main {
public static void main(String[] args) {
System.out.println("main start...");
Thread t = new Thread() {
public void run() {
System.out.println("thread run...");
try {
Thread.sleep(10); // 子线程休眠10毫秒
} catch (InterruptedException e) {}
System.out.println("thread end.");
}
};
t.start();
try {
Thread.sleep(20); // 主线程休眠20毫秒
} catch (InterruptedException e) {}
System.out.println("main end...");
}
}
八、线程的优先级
在线程中,通过setPriority(int n)
设置线程优先级,范围是1-10,默认为 5
优先级高的线程被操作系统调度的优先级较高(操作系统对高优先级线程,调度更频繁)
注意:并不能代表,通过设置优先级来确保高优先级的线程一定会先执行
public class Main {
public static void main(String[] args) {
// 创建子线程:打印数字1-26
Thread thread1 = new Thread("数字线程") {
@Override
public void run() {
for (int i = 1; i <= 26; i++) {
System.out.println(Thread.currentThread().getName() + "打印=>" + i + "[" + Thread.currentThread().getPriority() + "]");
}
}
};
// 创建子线程:打印字母A-Z
Thread thread2 = new Thread("字母线程") {
@Override
public void run() {
for (char i = 'A'; i <= 'Z'; i++) {
System.out.println(Thread.currentThread().getName() + "打印=>" + i + "[" + Thread.currentThread().getPriority() + "]");
}
}
};
thread1.setPriority(8); // 设置数字线程优先级=8
thread2.setPriority(1); // 设置字母线程优先级=1
// 启动子线程
thread1.start();
thread2.start();
}
}