浅剖Java进程与线程
开场白：干就完了
进程与线程
- 操作系统（OS）
-
- 一.概念
- 二.定位
- 进程
-
- 一.进程是什么？
- 二.时间片怎么理解？
- 三.并发与并行的理解
- 四.内核态与用户态指的什么？
- 五.进程上下文
- 六.进程的状态有哪些？
- 线程
-
- 一.线程的认识
-
- 1.概念
- 2.线程优点
- 3.线程与进程的区别是什么？
- 二.线程的3类创建方式
-
- 1.继承Thread类创建（2种）
- 2.实现Runable接口（3种）
- 3.实现Callable接口（1种）
- 三.线程的休眠方式
-
- 1.方式1
- 2.方式2
- 3.方式3
- 4.例题：使用两个线程打印“AABBCCDD”
- 四.线程其他
-
- 1.Thread类常用构造方法
- 2.Thread类常用属性
- 3.线程分类
-
- （1）守护线程与用户线程的区别
- （2）如何将线程设置为守护线程？
- （3）守护线程的注意事项
- （4）守护线程的使用场景
- 五.面试题：start()和run()的区别
- 六.线程的终止方式
- 七.线程的状态
- 八.*多线程风险：线程安全
-
- 1.什么称作线程不安全？
- 2.线程不安全原因有哪些？
操作系统（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.实现Runable接口（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(1)
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()方法，会运行在主线程中。因为程序中只有一个主线程，当程序中有两个线程时，直接调用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）多个线程修改了同一个变量
后续更新中。。。