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构造方法。