1.认识线程
我们在之前认识了什么是多进程，今天我们来了解线程。
一个线程就是一个 "执行流". 每个线程之间都可以按照顺讯执行自己的代码. 多个线程之间 "同时" 执行 着多份代码.
引入进程这个概念，主要是为了解决并发编程这样的问题。因为cpu进入了多核心的时代，要想进一步提高程序的执行速度,就需要充分的利用CPU的多核资源。
其实多进程编程，已经可以解决并发编程的问题了，它已经可以利用起来cpu多核资源了，但是问题是：
进程太重了（消耗资源多、速度慢）创建一个进程，开销比较大。
销毁一个进程，开销也比较大。
调度一个进程，开销还比较大。
说进程重，主要就是重在资源分配/回收上。
线程应运而生，线程也叫做"轻量级进程"，
解决并发编程问题的前提下，让创建，销毁，调度的速度更快一些
线程为啥更"轻"，把申请资源/释放资源的操作给省下了。
1.1 进程和线程的区别
进程是包含线程的。每个进程至少有一个线程存在，即主线程。
进程和进程之间不共享内存空间。同一个进程的线程之间共享同一个内存空间。
进程是系统分配资源的最小单位，线程是系统调度的最小单位。
光靠文字可能有点抽象，我们举个例子：
多进程：
多线程：
在多进程中，启用了两套院子，那么启用的成本是比较大的，耗费的时间也是比较多的，但是在第二套中，院子和运输材料的通道都是公用的，那么就节省了成本。
在启动一个新的生产线时，就不需要重新启动一个院子，而是在原来的院子里启用，节省了许多的成本。
线程和进程的关系，是进程包含线程，
一个进程可以包含一个线程,也可以包含多个线程，但是不能没有。
对比下来，主要的优势在于：
只有第一个线程启动的时候，开销是比较大的，但是后续线程就省事了.，不论是启动还是关闭，耗费的资源都比启动/关闭一个进程要小。同一个进程里的多个线程之间,共用了进程的同一份资源(主要指的是内存和文件描述符表)。这样这一部分资源就不需要重新启动或关闭。
操作系统,实际调度的时候,是以线程为单位进行调度的。
之前介绍的,，PCB里的状态，上下文，优先级，记账信息，都是每个线程有自己的。各自记录各自的但是同一个进程里的PCB之间, ，pid是一样的，内存指针和文件描述符表也是一样的。
那么既然线程这么好，可不可以无限制的在一个进程中增加线程呢？
并不可以，线程如果太多，核心数量有限，那么不少的开销就会浪费在线程调度上了，但是在多进程中就不会出现这样的状况。
线程模型,天然就是资源共享的.多线程争抢同一个资源(同一个变量)非常容易触发的.
进程模型,天然是资源隔离的.不容易触发.进行进程间通信的时候,多个进程访问同一个资源,可能会出问题.
1.2 多线程编程
本身关于线程的操作，操作系统提供的API，我们只需要学习Java提供的API就好了。
Java操作多线程,最核心的类 ：Thread
先在src下创建一个包，接着再创建一个类
创建好主函数后，我们新建一个Thread的对象
Thread t = new Thread();但是我们还需要一个类，新建一个Mythread类，并且重写run方法
class MyThread extends Thread{
@Override
public void run() {
System.out.println("hello world");
}
}然后在main中，开始启动一个特殊的方法：
t.start;完整的代码：
class MyThread extends Thread{
@Override
public void run() {
System.out.println("hello world");
}
}
public class ThreadDemo1 {
public static void main(String[] args) {
Thread t = new MyThread();
t.start();
System.out.println("hello main");
}
}这样一个代码，就新启动了一个线程，使得打印hello world和打印hello main是以完全不同的方式来完成的。
start这里的工作，就是创建了一个新的线程，新的线程负责执行重写过后的t.run。
具体的执行方法，就是start这个方法会调用操作系统的API，通过操作系统内核创建新线程的PCB，并且把要执行的指令交给PCB，当PCB被调度到CPU上执行的时候，也就执行到了线程run方法中的代码了。
通过具体的结果，，两个线程是同时进行的，并且可以看做是一次运行时无序，可能先打印world，也可能先打印main。
但是运行的时候不一定谁先谁后，
操作系统调度线程的时候,"抢占式执行"，具体哪个线程先上,哪个线程后上,不确定,取决于操作系统调度器具体实现策略.
虽然有优先级,但是在应用程序层面上无法修改.
从应用程序(代码)的角度,看到的效果,就好像是线程之间的调度顺序是"随机"的一样.
内核里本身并非是随机.但是干预因素太多,并且应用程序这一层也无法感知到细节,就只能认为是随机的了。
为啥会有线程安全问题?罪魁祸首，万恶之源,就是这里的抢占式执行，随机调度。
start和run的区别
start是真正创建了一个线程(从系统这里创建的)，线程是独立的执行流。
run 只是描述了线程要干的活是啥，如果直接再main中调用run，此时没有创建新线程，全是main线程一个人干活。相当于还是单线程。
可以使用jdk自带的工具jconsole查看当前的java进程中的所有线程.
这里面就可以看到进程。同时进程中还有很多个线程。除了我们使用的，其他的都是JVM自带的
1.3 多线程的五种创建方法
1.继承Thread，重写run方法
class MyThread extends Thread{
@Override
public void run() {
System.out.println("hello world");
}
}
public class ThreadDemo1 {
public static void main(String[] args) {
Thread t = new MyThread();
t.start();
System.out.println("hello main");
}
}也就是上面详细介绍的方法。
2.实现 Runnable 接口
class MyRunnable implements Runnable{
@Override
public void run() {
System.out.println("hello thread");
}
}
public class ThreadDemo2 {
public static void main(String[] args) {
Runnable runnable = new MyRunnable();
Thread t = new Thread(runnable);
t.start();
}
}
Runnable 作用，是描述一个“要执行的任务”，然后把这个任务交给Thread来执行。
好处就是这样写可以解耦合，让线程和线程之间干的活要分开。
3.使用匿名内部类,继承 Thread
public class ThreadDemo3 {
public static void main(String[] args) {
Thread t = new Thread(){
@Override
public void run() {
System.out.println("hello");
}
};
t.start();
}
}
这里面创建了一个Thread的子类，并且创建了子类的实例，让 t 引用指向该实例。
4.使用匿名内部类,实现 Runable
public class ThreadDemo4 {
public static void main(String[] args) {
Thread t = new Thread(new Runnable() {
@Override
public void run() {
System.out.println("hello demo4");
}
});
t.start();
}
}
这个写法和2本质相同，只不过是把Runnable任务交给匿名内部类的语法。
此处是创建了一个类，实现Runnable，同时创建了类的实例，并且传给Thread的构造方法。
5.使用 Lambda 表达式（推荐）
public class ThreadDemo5 {
public static void main(String[] args) {
Thread t = new Thread(() -> {
System.out.println("hello demo5");
});
t.start();
}
}使用lambda表达式来描述，直接把lambda传给Thread构造方法。
