接着上篇博客我们已经学习了进程的相关概念，了解到进程里面的相关重要属性，那么这篇博客呢我们要学习一个新的知识点——线程！

一、引入进程的目的

首先引入进程这个概念，是为了解决“并发编程”这样的问题。因为CPU 再往小了做,比较困难了，这是因为 CPU 进入了多核心的时代，要想进一步提高程序的执行速度,就需要充分的利用 CPU 的多核资源。
但是呢,多进程编程,已经可以解决并发编程的问题了已经可以利用起来 cpu 多核资源了。

弊端：

进程太重了!(消耗资源多 & 速度慢)。
1、创建一个进程,开销比较大。
2、销毁一个进程,开销也比较大。

3、调度一个进程，开销也比较大。
说进程重,主要就是重在”资源分配/回收。

线程：

所以我们的线程也就应运而生.线程也叫做“轻量级进程"。
目的就是解决并发编程问题的前提下,让创建,销毁,调度的速度,更快一些!
轻的原因：主要是"把申请资源/释放资源"的操作给省下了。

二、多线程的优点

假设小帅开了一家工厂，他在这个工厂里买了一台机器用来生产空调，小帅发现自己的产品销量不错，于是他想加大生产力度，那可以通过什么方法来提高生产效率呢？

方案一：在这个工厂旁边再开一家工厂购买一台机器用来生产空调(多进程的解决方案)

方案二 ：在原本的工厂内再购买一台机器用来生产空调(多线程的解决方案)

那么很显然第二种解决方案更划算，场地和空间都是复用之前的，共用一套资源。

1.线程和进程的关系：进程包含线程！

只有第一个线程启动的时候,开销是比较大的.后续线程就省事了个进程可以包含一个线程,也可以包含多个线程.(不能没有)。你线程1 new 的对象在线程2,3,4 里都可以直接使用。线程1 打开的文在线程2,3,4 里都可以直接使用。
同一个进程里的多个线程之间,共用了进程的同一份资源(主要指的是 内存 和 文件描述符表）。
注：操作系统,实际调度的时候是以线程为单位进行调度的.
如果每个进程有多个线程了，每个线程是独立在 CPU 上调度的。

线程是操作系统调度执行的基本单位，每个线程也都有自己的执行逻辑 (执行流)。

2.面试题：进程和线程之间的区别与联系。

1.进程包含线程! 一个进程里面可以有一个线程,也可以有多个线程。

2.进程线程都能解决并发编程问题场景.但是进程在频繁创建和销毁中,开销更高.线程开销更低，(线程比进程更轻量)。

3.进程是系统分配资源(内存,文件资源....) 的基本单位。线程是系统调度执行的基本单位(CPU)。

4进程之间是相互独立的各自有各自的虚拟地址空间,同一个进程内部的多个线程之间,共用同一个内存空间以及文件资源,一个进程挂了其他进程一般都没事。但是一个线程挂了，很可能把整个进程都带走！

三、第一个多线程程序

那么在Java中进行多线程编程的话如何实现呢？

在 Java 标准库中,就提供了一个 Thread 类,来表示/操作线程。
Thread 类也可以视为是 Java 标准库提供的 API。

即创建好的 Thread 实例,其实和操作系统中的线程是一一对应的关系。
操作系统,提供了一组关于线程的 API(C 语言风),Java 对于这组 API 进一步封装了一下,就成了 Thread 类。

（一）、Thread类的基本用法

写法一：继承自Thread，重写run()

那么通过Thread类创建线程有很多种方法，其中最简单的就是创建子类继承自Thread，重写run()方法。

class MyThread extends Thread{@Overridepublic void run() {System.out.println("hello Thread");}
}

注意，run()方法体中描述了这个线程内部要执行哪些代码。因为每个线程都是并发执行的.(各自执行各自的代码)因此就需要告知这个线程,你执行的代码是什么。
run()方法中的逻辑，是在新创建出来的线程中,被执行的代码，意思就是并不是我一定义这个类,一写 run 方法,线程就创建出来了，相当于领导已经把任务安排好了，我还没开始干呢！

public class demo1 {public static void main(String[] args) {Thread t = new MyThread();t.start();}
}

需要调用这里的start()方法，才是真正在系统中创建了线程，才开始真正执行上面的run操作。

那么我们再写一个程序来仔细观察一下线程的执行情况，我们这里通过一个while循环来打印一个语句，通过sleep方法来控制打印的速度。

class MyThread2 extends Thread{@Overridepublic void run() {while (true){System.out.println("hello thread!");try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}}}
}
public class demo2 {public static void main(String[] args) {Thread t = new MyThread2();t.start();while (true){System.out.println("hello main");try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}}}
}

那么我们知道，在一个进程中,至少会有一个线程。
在一个java 进程中,也是至少会有一个调用 main 方法的线程(这个线程不是你手动搞出来的)。
自己创建的 t 线程和 自动创建的 main 线程,就是并发执行的关系(宏观上看起来是同时执行)。
此处的"并发 = 并行+并发"宏观上是区分不了并行和并发的.都取决于系统内部的调度

我们可以发现现在两个线程,都是打印一条,就休眠个1s。
当 1s 时间到了之后,系统先唤醒谁呢?
通过运行结果看起来这个顺序不是完全确定(随机的)。
每一轮,1s 时间到了之后,到底是先唤醒 main 还是 thread，这是随机的，对于操作系统来说,内部对于线程之间的调度顺序,在宏观上可以认为是随机的，即所谓的——抢占式执行！
那么对于这个随机性,会给多线程编程带来很多其他的麻烦！！

写法二:

创建一个类，实现Runnable接口，再创建Runnable实例传给Thread实例，通过Runnable来描述任务的内容。

class MyRunnable implements Runnable{@Overridepublic void run() {System.out.println("hello java");}
}
public class demo3 {public static void main(String[] args) {Thread t = new Thread(new MyRunnable());t.start();}
}

写法三：匿名内部类

也就是上面两种写法的翻版，通过一个匿名内部类来实现:

public class demo4 {public static void main(String[] args) {Thread t = new Thread(){@Overridepublic void run() {System.out.println("hello javaEE");}};t.start();}
}

* 通过匿名内部类来实现。
 * 创建一个匿名内部类，继承自Thread类。
 * 同时重写run方法。
 * 同时再new出这个匿名内部类的实例。

写法四：匿名内部类的方法2

* new 的 Runnable，针对这个创建的匿名内部类 同时new出的Runnable实例传给Thread的构造方法。
 * 通常认为这种写法好一点 能够做到让线程和线程执行的任务，更好的进行解耦。写代码追求高内聚，低耦合。
 * Runnable 单纯的只是描述了一个任务 至于这个任务是要通过一个进程来执行，还是线程池来执行 Runnable本身并不关心。

public class demo5 {public static void main(String[] args) {Thread t = new Thread(new Runnable() {@Overridepublic void run() {System.out.println("hello 多线程");}});t.start();}
}

写法五：Lambda（可以代替内部类的方式）！

public class demo6 {public static void main(String[] args) {Thread t = new Thread(() -> {System.out.println("hello Thread");});t.start();}
}

创建多线程的方式还有很多种，以上五种必须熟练掌握