多线程（1）——认识线程

---

在介绍多线程前，先介绍一下操作系统的概念
操作系统是一个管理的软件
1.对下管理各种硬件设备
2.对上给软件提供稳定的运行环境

概念

线程是什么

一个线程就是一个“执行流”，每个线程之间都可以按照顺序执行自己的代码，多个线程之间同时执行着多份代码

线程过多，因为CPU核心书名是有限的，这些线程在CPU上的调度开销会越来越明显，也会影响效率
所以要根据CPU资源合理增加线程数量

为什么要有线程

进程和线程的区别

进程是运行起来的程序，每个进程通过链表连接起来，进程有两种状态 并发（一个CPU核心同时执行一个线程，但因为运行/切换速度极快，可以看做是同时在执行多个线程） 和 并行（两个CPU核心同时执行两个线程） ，而每个进程中 有多个 线程，这些线程共用该进程的资源（内存资源，文件描述符表），每个线程都可以独立执行一段逻辑，并且独立在 CPU 上调度
当进程已经有了，在进程内部再创建新线程，就把申请资源开销省下来了

进程包含线程(一个进程至少有一个线程，对于Java程序中，main方法所在的线程就是主线程)

进程是操作系统资源分配的基本单位
线程是操作系统调度执行的基本单位

Java的线程 和 操作系统线程 的关系

线程是操作系统中的概念. 操作系统内核实现了线程这样的机制, 并且对⽤⼾层提供了⼀些 API（Java内部的方法） 供⽤⼾
使⽤(例如 Linux 的 pthread 库).
Java 标准库中 Thread 类（线程）可以视为是对操作系统提供的 API 进⾏了进⼀步的抽象和封装，而进程封装的很粗糙，多进程变成的很多能力，JVM原生API没有提供，本身Java设计者就不鼓励多进程编程

创建线程

方法1：继承Thread 类

class myThread extends Thread{@Overridepublic void run(){while(true){System.out.println("Hello, Thread!");try {//这里只能用try catch ，因为父类Thread的run方法没有抛出异常，子类myThread的run方法也不能抛出异常//如果这里用throws，父类和子类方法声明就不一致，就不满足重写的要求Thread.sleep(1000);} catch (InterruptedException e) {// TODO Auto-generated catch blocke.printStackTrace();}}}
}public class Demo1 {public static void main(String[] args) throws InterruptedException {Thread thread=new myThread();//thread.start();thread.run();//如果这里调用run方法，就不会启动线程，而是在main线程中执行run方法，不会并行执行while (true) {System.out.println("Hello, main!");Thread.sleep(1000);}}
}

注意，上述线程运行时myThread线程和main线程在操作系统中的调度顺序是无序，不可预测的，是随机的。即可能会先打印 Hello, Thread!，也可能先打印 Hello, main!

run和start方法

在上述方法中，重写的是Thread的run方法，但是在main方法中调用的是start方法，这么做的原因是：
start方法是调用系统的API（Java 本地方法（封装了对系统底层的调用）），它才是真正在操作系统内部创建一个线程
这个新的线程就会以run方法为入口（执行run中的逻辑）
run方法不需要代码中显示调用，run 方法执行完成后线程进入销毁阶段。

如果在main中直接调用thread.run()，就没有创建新的线程，而是直接在main方法所在的 主线程 中执行了run的逻辑。如果在main中调用thread.start()，就会开启一个新线程和main线程并发执行

方法2：实现Runnable 接口

实现Runnable接口的方式，是把线程的任务单独提取出来，放到一个类中，然后再创建线程时，把这个类的实例作为参数传递给Thread的构造方法。这样，线程的任务就被封装到了一个类中，使得代码更加清晰，也便于维护和扩展。

class MyRunnable implements Runnable{@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) throws InterruptedException {/**/Runnable runnable=new MyRunnable();//runnable没有start方法，项启动线程要搭配ThreadThread thread=new Thread(runnable);thread.start();while (true) {System.out.println("hello main");Thread.sleep(1000);}}
}

方法1和方法2的区别

对于第一种写法（继承thread类），描述任务的时候，认为代码是写到Thread子类中的
此时任务内容 和 Thread 类的耦合度更高
第二种方法，任务写到Runnable中，不涉及到线程相关的概念，任务内容和Thread的耦合度很小，几乎没有，这个任务就能放进其他来执行（进程，协程）

耦合度：在编码中，更倾向于写耦合度低的代码，方便修改，使用

方法3：通过匿名内部类继承Thread

Thread thread=new Thread(){//创建了一个没有名字的匿名内部类public void run(){}};

使用举例

public class Demo3 {public static void main(String[] args) {Thread thread=new Thread(){//创建了一个没有名字的匿名内部类//这个类是Thread的子类，子类重写了run方法//同时也创建了子类实例，通过 thread 指向public void run(){while (true) {System.out.println("hello thread");try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}}}};thread.start();}
}

像这样的写法的目的就是为了简化代码

方法4：通过匿名内部类实现Runnable，重写run，搭配Thread

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

方法5：基于Lambda表达式创建Thread

语法：

Thread thread=new Thread(()->{/*此处写run方法内容*/});

lambda表达式，本质上是 匿名方法
直接使用 lambda 作为入口方法

使用举例：

public class Demo5 {public static void main(String[] args) {Thread thread=new Thread(()->{while(true){System.out.println("hello thread");try {Thread.sleep(1000, 0);} catch (InterruptedException e) {e.printStackTrace();}}});thread.start();}
}