前进前进…
进程与线程
操作系统(OS)
一.概念
计算机系统包含基本程序的集合,称为操作系统(OS),我们可以笼统地理解为操作系统包含内核(进程管理、内存管理、文件管理以及驱动管理等)和其他程序(如函数库和shell程序)
二.定位
整个有关计算机软硬件的架构中,操作系统的定位是搞管理的软件,具体怎么理解呢,通过下图可以对OS有个清晰的认知:
1.按照管理者的任务可以分为两类:硬件管理和软件管理
2.按照目标对象分为两种:对内管理和对外业务管理
进程
一.进程是什么?
对于操作系统而言,一个任务就是一个进程(Process);基于课本中的概念,可以将进程看作一个执行的实例或者一个正在执行的程序;基于内核观点,进程是担当分配资源(CPU时间、内存)的的实体,是操作系统分配资源的最小单位。
二.时间片怎么理解?
现在的操作系统都是支持多任务的,也就是说系统支持同时运行多个任务。操作系统对任务的调度采用“时间片轮转”的调度方式,当一个任务执行一小段时间后强制暂停然后去执行下一个任务,每个任务轮流执行。
任务执行的一小段时间称为时间片;任务正在执行的状态为运行状态;任务执行一段时间后强制暂停后去执行下一个任务,被暂停的任务处于就绪状态等待下一个属于它的时间片的到来。
三.并发与并行的理解
由于任务数量远远超过CPU核心数量,因此操作系统会自动把任务调度到每个核心上执行。
并发:多个进程在一个CPU下采用时间片轮转方式,在一段时间内,让多个进程得以推进,类似“雨露均沾”思想,一个CPU在短时间内会自动调度不同任务。
并行:多个任务在多个CPU分别同时运行,这称之为并行。
操作系统中将并发性与并行性做明显区分,主要从微观角度而言:
并发性:单处理机情况下,多个进程在同一时间间隔运行
并行性:多处理机情况下,多个进程同时运行
举个例子理解并发与并行机制:
客户去银行办理业务
并发性:为了让银行服务人员更好地服务客户,规定每个客户的业务办理时间(防止其他客户长时间等待),银行服务人员将时间片轮转思想应用到客户业务中,
当该客户业务的办理时间到达规定时间,银行人员暂停当前业务随之去办理下一个客户的业务,该客户等待下一次时间片的到来
。从长时间来看,因为时间片较短,一个银行服务人员被认为可同时服务多个客户,这就可以理解为基于时间片的进程轮转管理机制,就是所谓的并发性
。
并行性:银行如果非常有钱,雇佣了很多的工作人员,此时一个客户就会有一个工作人员对接,所有客户的业务真正实现了同时处理,这种机制就称为并行性。
四.内核态与用户态指的什么?
操作系统对执行权限进行分级:内核态和用户态,其中内核态指的是操作系统内核直接控制硬件设备底层软件,权限最高;用户态指的是用户程序权限最低。
五.进程上下文
进程上下文简单来说就是进程在时间片轮转时,需要进行上下文环境切换。这是什么意思呢?
当一个进程正在执行的时候,CPU中保存了寄存器的值、进程的状态以及堆栈上的内容,基于时间片轮转机制切换该进程时,需要保存该进程当前的内容,当再一次执行该进程时,能够恢复到切换时的状态,从而继续正常地执行。这叫进程的上下文。
六.进程的状态有哪些?
如下图所示,进程地状态有5个,分别是创建、就绪、运行、阻塞、终止。
线程
一.线程的认识
1.概念
线程是系统调度资源的最小单位,可认为是“轻量级进程”。
2.线程优点
线程创建时占用更少的资源,进程中的不同线程之间可以共享资源。其中线程可以共享的资源有:①打开的文件 ②共享的内存(如对象 new Object())。
3.线程与进程的区别是什么?
①进程是操作系统分配资源的最小单位;线程是操作系统调度资源的最小单位。
②进程之间不可以共享资源,而线程之间可以共享资源。
③一个进程中至少包含一个线程(主线程),线程必须依附于进程当中。
④线程是进程执行的最小单位,也是进程执行的实际单位。
⑤进程与线程的区别就像工厂与生产流水线一样,工厂运作的本质是流水线的运行。
二.线程的3类创建方式
1.继承Thread类创建(2种)
第一种:
public class ThreadDemo4 {
static class MyThread extends Thread {
@Override
public void run() {
// 线程业务
System.out.println("线程名称:" +
Thread.currentThread().getName());
}
}
public static void main(String[] args) {
// 创建线程对象
Thread t1 = new MyThread();
// 启动线程
t1.start();
System.out.println("当前线程的名称(主线程):" +
Thread.currentThread().getName());
}
}
===========================================================
第二种:
public class ThreadDemo5 {
public static void main(String[] args) {
Thread thread = new Thread() {
@Override
public void run() {
System.out.println("线程名:" +
Thread.currentThread().getName());
}
};
thread.start();
}
}
2.实现Runnable接口(3种)
第一种:
public class ThreadDemo6 {
static class MyRunnable implements Runnable {
@Override
public void run() {
System.out.println("线程名:" +
Thread.currentThread().getName());
}
}
public static void main(String[] args) {
// 1.创建Runnable对象
MyRunnable runnable = new MyRunnable();
// 2.创建Thread对象
Thread thread = new Thread(runnable);
// 3.启动线程
thread.start();
}
}
==========================================================
第二种:
public class ThreadDemo7 {
public static void main(String[] args) {
// 匿名内部类的方式实现线程
Thread thread = new Thread(new Runnable() {
@Override
public void run() {
System.out.println("线程名:" +
Thread.currentThread().getName());
}
});
thread.start();
}
}
==========================================================
第三种:jdk1.8开始使用
public class ThreadDemo8 {
public static void main(String[] args) {
// lambda + 匿名runnable的实现方式
Thread thread = new Thread(() -> {
System.out.println("线程名:" +
Thread.currentThread().getName());
});
thread.start();
}
}
3.实现Callable接口(1种)
import java.util.Random;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
/**
* 前面两类创建线程的方程线,线程业务都没有返回方法,
* 为了得到线程的执行结果,实现 Callable 接口 + Future 的方式
*/
public class ThreadDemo9 {
// 创建了线程的任务和返回方法
static class MyCallable implements Callable<Integer> {
@Override
public Integer call() throws Exception {
// 生成随机数
int num = new Random().nextInt(10);
System.out.println("子线程:" +
Thread.currentThread().getName() +
",随机数:" + num);
return num;
}
}
public static void main(String[] args) throws ExecutionException, InterruptedException {
// 1.创建Callable对象
MyCallable myCallable = new MyCallable();
// 2.创建FutrueTask对象接收返回值
FutureTask<Integer> futureTask =
new FutureTask<>(myCallable);
// 3.创建Thread对象
Thread thread = new Thread(futureTask);
// 启动线程
thread.start();
// 拿到线程执行的结果
int result = futureTask.get();
System.out.println(String.format("线程名:%s,数字:%d",
Thread.currentThread().getName(), result));
}
}
三.线程的休眠方式
例如:实现主线程休眠1s
1.方式1
Thread.sleep()
public static void main(String[] args) throws InterruptedException {
System.out.println("开始时间:" + new Date());
// 休眠1s
Thread.sleep(1000); //sleep方法传入的时间以毫秒计算
System.out.println("结束时间:" + new Date());
}
2.方式2
TimeUnit.SECONDS.sleep()
public static void main(String[] args) throws InterruptedException {
System.out.println("开始时间:" + new Date());
TimeUnit.SECONDS.sleep(1); // 休眠1s
System.out.println("结束时间:" + new Date());
}
3.方式3
Thread.sleep(TimeUnit.SECONDS.toMillis())
public static void main(String[] args) throws InterruptedException {
System.out.println("开始时间:" + new Date());
Thread.sleep(TimeUnit.SECONDS.toMillis(1)); //休眠1s
System.out.println("结束时间:" + new Date());
}
4.例题:使用两个线程打印“AABBCCDD”
public static void main(String[] args) {
// 创建一个任务
Runnable runnable = new Runnable() {
@Override
public void run() {
String data = "ABCD";
for (char item : data.toCharArray()) {
System.out.print(item);
try {
// 休眠一段时间
Thread.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
};
Thread t1 = new Thread(runnable);
Thread t2 = new Thread(runnable);
t1.start();
t2.start();
}
程序运行结果:
四.线程其他
Thread类是Jvm用来管理线程的类,每个线程都有一个唯一的Thread对象与之关联。Thread类的对象就是用来描述一个线程执行流的,Jvm会将这些对象组织起来用于线程调度和线程管理。
1.Thread类常用构造方法
Thread构造方法 | 构造方法说明 |
---|---|
Thread() | 无参创建对象 |
Thread(Runnable target) | 使用Runnable对象创建线程对象 |
Thread(String name) | 创建线程对象并命名 |
Thread(Runnable target, String name) | 使用Runnable对象创建线程对象并命名 |
2.Thread类常用属性
Thread属性 | 获取方法 |
---|---|
线程ID | getId() |
线程名称 | getName() |
线程状态 | getState() |
优先级 | getPriority() |
是否后台线程 | isDaemon() |
是否存活 | isAlive() |
是否被中断 | isInterrupted() |
线程优先级补充:
3.线程分类
线程分为守护线程(又叫后台线程)和用户线程(默认线程)
(1)守护线程与用户线程的区别
- Java语言中,默认创建的是用户线程。
- 守护线程是用来为用户线程服务的,当一个程序中的所有用户线程结束之后,无论守护线程是否在工作,守护线程都会随用户线程一起结束。
举个例子来说,守护线程的角色就像“服务员”,而用户线程的角色就像“顾客”,当顾客全部走了之后(执行结束),“服务员”就没有了存在的意义,因而整个程序就直接结束运行
。 - 守护线程从业务逻辑层面来看权重比较低,但对于线程调度器来说无论是守护线程还是用户线程,在优先级相同的情况下被执行的概率都是相同的。
(2)如何将线程设置为守护线程?
主线程和默认创建的线程都是用户线程,如下代码所示:
public static void main(String[] args) {
Thread thread = new Thread(new Runnable() {
@Override
public void run() {
System.out.println("我是子线程");
}
});
System.out.println("子线程是否为守护线程:" + thread.isDaemon());
//Thread.currentThread()获取当前执行代码的线程对象
System.out.println("主线程是否为守护线程:" + Thread.currentThread().isDaemon());
}
程序的执行结果:
从结果可以看出主线程和创建的子线程默认都是用户线程,那么我们想让用户线程变为守护线程如何去做呢?
通过setDaemon(true)将用户线程设置为守护线程,如下面代码所示:
public static void main(String[] args) {
Thread thread = new Thread(new Runnable() {
@Override
public void run() {
System.out.println("我是子线程");
}
});
// 设置子线程为守护线程
thread.setDaemon(true);
System.out.println("子线程是否为守护线程:" + thread.isDaemon());
System.out.println("主线程是否为守护线程:" + Thread.currentThread().isDaemon());
}
程序的执行结果:
从结果可以看出,子线程由默认false变为true,表明子线程被设置为守护线程。
(3)守护线程的注意事项
1)设置守护线程setDaemon(true)必须放在启动线程之前start(),否则程序将报错。
2)在守护线程中创建的线程都是守护线程。
3)使用join()方法时会等待线程执行完,无论是用户线程还是守护线程。
通过代码看一下注意事项:
1)将setDaemon(true)放在start()之后
public static void main(String[] args) throws InterruptedException {
Thread thread = new Thread(new Runnable() {
@Override
public void run() {
for (int i = 1; i <= 10; i++) {
// 打印i信息
System.out.println("i:" + i + ",isDaemon:" +
Thread.currentThread().isDaemon());
try {
// 休眠100毫秒
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
});
// 启动线程
thread.start();
// 设置为守护线程
thread.setDaemon(true);
}
程序运行结果:
从结果可以看出,将setDaemon(true)放在start()之后,程序运行报错,此外设置的守护线程也不能生效。
2)守护线程的子线程
public static void main(String[] args) throws InterruptedException {
Thread thread = new Thread(new Runnable() {
@Override
public void run() {
Thread thread2 = new Thread(new Runnable() {
@Override
public void run() {
}
});
System.out.println("守护线程的子线程是否为守护线程:" +
thread2.isDaemon());
}
});
// 设置为守护线程
thread.setDaemon(true);
// 启动线程
thread.start();
Thread.sleep(1000);
}
程序运行结果:
从结果可以看出,守护线程中创建的子线程默认也是守护线程。
3)使用join()方法等待守护线程执行结束
默认情况下,程序运行结束不会等待守护线程执行完,当调用线程的等待方法join()时,程序会等待守护线程执行结束后再结束。
public static void main(String[] args) throws InterruptedException {
Thread thread = new Thread(new Runnable() {
@Override
public void run() {
for (int i = 1; i <= 10; i++) {
// 打印 i 信息
System.out.println("i:" + i);
try {
// 休眠 100 毫秒
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
});
// 设置为守护线程
thread.setDaemon(true);
// 启动线程
thread.start();
// 等待线程执行完
thread.join();
System.out.println("子线程是否为守护线程:" + thread.isDaemon());
System.out.println("主线程是否为守护线程:" + Thread.currentThread().isDaemon());
}
程序运行结果:
从结果我们可以看出,守护线程调用等待方法join(),程序会等待守护线程将任务执行结束后结束进程。
(4)守护线程的使用场景
守护线程的经典使用场景是垃圾回收线程;守护线程中创建的线程默认情况下也是守护线程。
五.面试题:start()和run()的区别
Java中通过实例化Thread类产生线程对象,线程对象调用start()启动线程,Thread还有一个run方法貌似也能启动线程,两者的区别到底是什么?
start():产生线程对象后,调用start()方法启动线程,线程处于运行状态RUNNABLE中的Ready就绪状态中,此时线程等待被CPU调度,调度后再执行run()方法。使用start()方法启动线程,
真正意义上实现了多线程
。
run():run()方法是Thread中一个普通方法,当只存在一个创建的线程对象时,用线程对象调用run()方法,程序被主线程main执行。当程序中有两个新建线程时,调用run()方法,程序会按照顺序执行,没有实现多线程并发
。
public static void main(String[] args) {
Thread t1 = new Thread(new Runnable() {
@Override
public void run() {
System.out.println(Thread.currentThread().getName());
}
},"unstoppbale_t");
t1.start();
}
程序运行结果:
可以看出,调用start()方法启动线程,线程名是子线程名。
public static void main(String[] args) {
Thread t1 = new Thread(new Runnable() {
@Override
public void run() {
System.out.println(Thread.currentThread().getName());
}
},"unstoppbale_t");
t1.run();
}
程序运行结果:
可以看出,调用start()方法启动线程,线程名是主线程名main。
细节补充:
run()方法可调用多次,而start()方法只能调用一次,调用多次将会报错,如下图两图所示:
六.线程的终止方式
1.使用自定义的全局变量终止线程
特点:终止方法比较温柔,在拿到终止指令后,需要执行完当前的任务才会终止线程
public class ThreadDemo {
// 全局自定义变量
private static boolean flag = false;
public static void main(String[] args) throws InterruptedException {
// 转账线程
Thread t1 = new Thread(new Runnable() {
@Override
public void run() {
while (!flag) {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("正在讲话...");
}
System.out.println("停止说话");
}
});
t1.start();
Thread t2 = new Thread(new Runnable() {
@Override
public void run() {
try {
Thread.sleep(310);
} catch (InterruptedException e) {
e.printStackTrace();
}
// 改变变量的值来终止线程
System.out.println("停止说话,有要事发生。");
flag = true;
}
});
t2.start();
t1.join(); //对于用户线程而言,join()可以不写
t2.join();
}
}
程序运行结果:
从运行结果我们可以看出,使用全局变量方式“终止说话”后又有一次“正在说话”,这说明全局变量控制线程终止会让当前任务结束后再进行终止。
2.调用线程终止方法interrupt()终止
特点:在收到终止指令后,立马结束进程的执行
①Thread.interrupted()
public class ThreadDemo {
public static void main(String[] args) throws InterruptedException {
// 转账线程
Thread t1 = new Thread(new Runnable() {
@Override
public void run() {
while (!Thread.interrupted()) {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
System.out.println("终止状态" +
Thread.currentThread().isInterrupted());
break;
}
System.out.println("正在说话...");
}
System.out.println("停止了说话");
}
});
t1.start();
Thread.sleep(310);
// 终止线程
System.out.println("停止说话,有要事发生");
t1.interrupt();
}
}
程序运行结果:
②Thread.currentThread().isInterrupted()
public class ThreadDemo {
public static void main(String[] args) throws InterruptedException {
Thread t1 = new Thread(new Runnable() {
@Override
public void run() {
while (!Thread.currentThread().isInterrupted()) {
System.out.println("正在说话");
}
System.out.println("停止了说话");
}
});
t1.start();
Thread.sleep(3);
System.out.println("停止说话,有要事发生");
t1.interrupt();
}
}
从上面两个图运行结果可以看出,调用interrupt()直接终止正在执行的线程,不管线程是否在执行任务。
那么Thread.interrupted()和Thread.currentThread().isInterrupted()区别是什么呢?通过以下代码运行结果来观察:
①Thread.interrupted()
public class ThreadDemo {
public static void main(String[] args) {
Thread t1 = new Thread(new Runnable() {
@Override
public void run() {
for (int i = 0; i < 10; i++) {
System.out.println(Thread.interrupted());
// System.out.println(Thread.currentThread().isInterrupted());
}
}
});
t1.start();
// 终止线程
t1.interrupt();
}
}
②Thread.currentThread().isInterrupted()
public class ThreadDemo6 {
public static void main(String[] args) {
Thread t1 = new Thread(new Runnable() {
@Override
public void run() {
for (int i = 0; i < 10; i++) {
//System.out.println(Thread.interrupted());
System.out.println(Thread.currentThread().isInterrupted());
}
}
});
t1.start();
// 终止线程
t1.interrupt();
}
}
Thread.interrupted()是全局的方法,执行线程终止状态变为true,之后就会复位为初始默认状态false。Thread.currentThread().isInterrupted()将线程中的终止状态由false变为true,不再复位。
3.使用线程提供的方法stop()终止【已弃用】
七.线程的状态
线程的状态分为六种:
线程状态 | 说明 |
---|---|
NEW | 处于创建状态,此时未调用start() |
RUNNABLE | 线程运行状态(包含Running执行和Ready就绪) |
BLOCKED | 阻塞状态 |
WAITING | 等待状态,没有明确的等待时间,如wait()没有参数 |
TIMED_WAITING | 超时等待状态,有明确的等待时间,比如sleep() |
TERMINATED | 线程结束状态 |
八.*多线程风险:线程安全
1.什么称作线程不安全?
多线程环境中,程序的执行结果与预期结果不相符,这就叫
线程不安全
。
线程不安全举例:
public class ThreadDemo7 {
static class Counter {
// 定义的私有变量
private int num = 0;
// 执行次数
private final int maxSize = 100000;
// num++
public void incrment() {
for (int i = 0; i < maxSize; i++) {
num++;
}
}
// num--
public void decrment() {
for (int i = 0; i < maxSize; i++) {
num--;
}
}
public int getNum() {
return num;
}
}
public static void main(String[] args) throws InterruptedException {
Counter counter = new Counter();
Thread t1 = new Thread(() -> {
counter.incrment();
});
t1.start();
Thread t2 = new Thread(() -> {
counter.decrment();
});
t2.start();
t1.join();
t2.join();
System.out.println("最终的执行结果:" + counter.getNum());
}
}
对于上述代码,我们预期得到的结果为0,然而执行后的结果不为0,这就是线程不安全的例子。
举例分析原因:
使用两个线程对变量count进行一次++和- -。
原因:Jvm中,线程占有两块内存,其中一个是主内存,另外还有线程自己的工作内存,++和- -操作实际上分为三步完成。
2.线程不安全原因有哪些?
(1)CPU抢占执行
(2)非原子性
(3)编译器优化(指令重排) 编译器优化在单线程下执行没问题,多线程下优化会发生混乱
(4)内存的不可见性
(5)多个线程修改了同一个变量
后续更新中。。。