【JavaEE初阶】认识线程（Thread）

目录

🌾 前言

🌾 了解线程

🌈1.1 线程是什么？

🌈1.2 一些基本问题 

🌾2、创建线程的方式

🌈 2.1 继承Thread类

🌈 2.2 实现Runnable接口并重写run()方法

🌈 注意：多个线程的写法

🌾3、多线程编程的意义

🌾4、线程的类与常用方法

 🌈 4.1 构造方法

 🌈 4.2 Thread类的几个常见属性

 🌾5、线程的状态

---

🌾 前言

        在学习之前，我们先简单的了解一下计算机中的常见的概念。

         1、冯诺依曼结构体系

        现代的计算机大多遵循冯诺依曼体系结构。主要由运算器，控制器，存储器，输入设备，输出设备组成。

        2、操作系统

        操作系统是一组做计算机资源管理系统的统称。常见的操作系统由Windows系列，Linux系列，OSX系列，ISO系列，Android系列。操作系统的作用主要有：（1）向上为应用程序提供一个稳定的运行环境；（2）向下管理所有的硬件设备；（3）为用户提供一个人机交互的界面。

        3、进程

        每一个运行起来的程序(软件)，操作系统都会以进程的形式将他们管理起来。在操作系统中，每一个进程被描述为一个PCB（进程控制块抽象）。一个PCB中主要包括：PID，内存指针，文件描述符表，进程的优先级，进程的状态，上下文信息和记账信息。

        CPU分配 -> 进程调度：假设大部分场景下都是单CPU单核的计算机。操作系统对于CPU资源的分配，采用的是时间模式：不同的进程在不同的时间段去使用CPU资源。

        内存分配 ->内存管理：操作系统对内存资源的分配，采用的是空间模式：不同的进程使用内存中的不同区域，互相之间不会干扰。

        4、虚拟内存空间

        进程启动之后会申请内存空间，正常情况下是没有问题的。但是可能会出现一些特殊情况，比如C++中的野指针等。因此实际中，操作系统中有一个模块叫做MMU，MMU会给每个进程分配一个虚拟内存地址，这个地址和真实的物理内存之间建立映射关系。当进程越界访问内存空间时，MMU直接会进行拦截，起到了一个校验的作用，不会对真实的物理内存造成影响。

        存在的问题：但是由于MMU的限制，导致不同进程之间不能够互相访问内存，所以如何实现进程之间的数据共享，从而达到“信息交换”的需求？针对这一问题，进程间通信的需求应运而生。目前，主流操作系统提供的进程通信机制主要有：管道，共享内存，文件，网络，信号量，信号。

   问题：并发与并行的区别？

        在一个处理器上不停横向的轮动叫做并发，在多个处理器上执行叫做并行。通俗解释就是：并发是：一会干这件事，一会干那件事，但其实同一时刻只能干一件事；并行是：一边干这件事，一边干那件事，在同一时刻干多件事，真正意义上的同时进行，在编程方面，我们统一称为并发编程。

---

🌾 了解线程

      🌈1.1 线程是什么？

        一般多进程用来处理一个很大或者很复杂的任务。当进程启动的时候，需要申请内存，申请文件资源，将PCB加入到链表中；当进程结束的时候，需要释放文件，释放内存，从链表中删除PCB。但是在这个过程中申请和释放资源的操作是十分耗时的。因此为了解决资源消耗的问题，提出了一个轻量级进程的概念（线程）。在创建线程的时候使用的是进程创建时申请到的所有资源，线程只需要关注要处理的任务即可。

        举个例子：比如张三设计了一些皮包，他要去开一个工厂。他需要做以下一些事情：、

（1）去工业园区申请地皮，水电，仓库等(花了一个月的时间和几十万的钱)；

（2）修建厂房和基础设施（花了几个月和几十万的钱）；   

（3）购买生产设备和原材料，招工（花了一周和几万块钱）；

（4）开始生产。 

        主要关注两者之间的对应关系！

        🌈1.2 一些基本问题 

       ❓ 问题1：进程与线程之间的区别？（面试题）

        （1）对于一个进程而言，必然会有一个线程（主线程）；

        （2）进程是申请系统资源的最小单位，线程是CPU调度的最小单位；

        （3）进程之间互不影响，线程使用的是进程统一申请来的资源，线程之间可以相互影响。

       ❓ 问题2：  使用多线程编程的原因？       

        （1）为了充分利用CPU的资源       

        （2）利用轻量级进程的特性来减少系统性能的开销:            

                 线程创建的效率比进程高; 

                 线程销毁的效率比进程高； 

                 线程调度的效率比进程高

        ❓ 问题3：使用多线程存在的问题？

        当线程数量增大到一定程度之后，可能会给CPU调度带来负担，出现资源抢夺的问题，就会出现一些线程不安全的现象。

                

---

🌾2、创建线程的方式

    🌈 2.1 继承Thread类

        三部曲：继承Thread来创建一个线程类 -> 创建MyThread的实例 -> 使用start()方法启动线程

        (1)正常写法

public class Demo1_createThread {public static void main(String[] args) {Thread t = new MyThread();t.start();while (true){System.out.println("main thread");try {Thread.sleep(1000);} catch (InterruptedException e) {throw new RuntimeException(e);}}}
}
class MyThread extends Thread{@Overridepublic void run() {while (true){System.out.println("这里是线程运行的代码");try {Thread.sleep(1000);} catch (InterruptedException e) {throw new RuntimeException(e);}}}
}

 （2）使用匿名内部类的写法

    public static void main(String[] args) {//匿名内部类的形式Thread t = new Thread(){@Overridepublic void run() {while (true){System.out.println("生产生产生产...金币金币金币...+1+1+1");try {Thread.sleep(1000);} catch (InterruptedException e) {throw new RuntimeException(e);}}}};//启动进程t.start();}

🌈 2.2 实现Runnable接口并重写run()方法

 三部曲：实现Runnable接口 -> 创建Thread类实例，将Runnable对象作为其目标参数 -> 使用start()方法启动线程

注意:在调用start()方法后，JVM会调用系统API，并在系统中生成一个PCB来执行run()方法中的代码。

（1）正常写法

public class Demo2_createRunnable {public static void main(String[] args) {MyRunnable myRunnable = new MyRunnable();Thread t = new Thread(myRunnable);t.start();while (true){System.out.println("main thread");try {Thread.sleep(1000);} catch (InterruptedException e) {throw new RuntimeException(e);}}}
}
class MyRunnable implements Runnable{@Overridepublic void run() {while (true){System.out.println("这是线程运行的代码");try {Thread.sleep(1000);} catch (InterruptedException e) {throw new RuntimeException(e);}}}
}

注意：两个线程并不是有序的交替运行，因为CPU的调度是随机的。线程的执行是“抢占式执行”。

（2）使用匿名内部类的写法

     public static void main(String[] args) {Thread t = new Thread(new Runnable() {@Overridepublic void run() {while (true){System.out.println("生产皮包，金币+1");try {Thread.sleep(1000);} catch (InterruptedException e) {throw new RuntimeException(e);}}}});//开启线程t.start();}

（3）使用Lambda写法

public static void main(String[] args) {//Lambda表达式的使用条件就是该接口必须是一个函数式接口//比如Runnable接口就是一个 FunctionalInterface：所谓的函数式接口就是里面只有一个方法。比如(Runnable接口)中只有一个run();//怎么用Lambda表达式呢？()里写run方法的所有参数名，不需要参数类型，然后一个->即可。后面是正常的函数的功能实现Thread t = new Thread(()->{while (true){System.out.println("生产皮包，金币+1");try {Thread.sleep(1000);} catch (InterruptedException e) {throw new RuntimeException(e);}}});//开启线程t.start();}

❓ 问题：使用Runnable  定义任务的好处？

（1）解耦，将定义线程与定义任务分开。（其中解耦的意思就是将不同的功能都给分开，如果要修改或者查找相应的功能的时候可以在指定的位置找）

（2）将创建线程与定义任务分开，以便修改代码时，可以统一修改。

🌈 注意：多个线程的写法

public class Demo3_multiRunnable {public static void main(String[] args) {//创建任务的对象MyRunnable1 myrunnable1 = new MyRunnable1();MyRunnable2 myrunnable2 = new MyRunnable2();//创建生产皮包的线程Thread t1 = new Thread(myrunnable1);Thread t2 = new Thread(myrunnable1);//创建生产皮鞋的线程Thread t3 = new Thread(myrunnable2);//启动线程t1.start();t2.start();t3.start();}
}
//描述生产皮包的任务
class MyRunnable1 implements Runnable{@Overridepublic void run() {System.out.println("生产皮包，金币+1");try {Thread.sleep(1000);} catch (InterruptedException e) {throw new RuntimeException(e);}}
}
//描述生产皮鞋的任务
class MyRunnable2 implements Runnable{@Overridepublic void run() {System.out.println("生产皮鞋，金币+1");try {Thread.sleep(1000);} catch (InterruptedException e) {throw new RuntimeException(e);}}
}

---

🌾3、多线程编程的意义

        使用多线程编程主要是为了充分利用CPU资源，提高程序的运行效率。

        🌰：现在我们分别对两个变量进行10亿次的自增，分别使用两种方式：串行和并行。观察一下它们之间的时间差异。理论上来讲，并行应该是串行时间的一半。接下来我们俩看一下实际上是不是这样~

 结论：从上可以看出并行时间确实小于串行时间，但并不是严格意义上的一半，这主要是因为每创建一个线程都是要消耗时间和资源的。同样的，我们将计算量变小一些，可以看到反而串行时间小于并行时间。因此我们要知道并不是所有的场景下使用多线程第一可以提升效率，具体是否需要使用多线程主要根据计算量来决定。

---

🌾4、线程的类与常用方法

 🌈 4.1 构造方法

       Thread类是JVM用来管理线程的一个类。

 🌈 4.2 Thread类的几个常见属性

（1） 获取线程名：Thread.currentThread().getName();

（2）是否后台线程：isDaemon()

        isDaemon() 默认为false（前台线程），如果要创建后台线程则传入true，手动设置为后台线程。其中在main方法结束之后，线程会自动结束。

❓ 问题：前台线程与后台线程的区别？

        应用程度的主线程以及使用new Thread方式构造的线程都默认是前台线程。通过BeginXXX方法运行的线程都是后台线程，托管线程池中的线程都是后台线程。

        前台线程与后台线程的主要区别就是：进程会等待所有的前台线程完成后再结束工作，但是如果只剩下后台线程，则会直接结束工作。如果程序定义了一个不会完成的前台线程，主程序不会正常结束。

       比如银行转账的业务，一定要用前台线程；统计微信步数这种处理容错率比较高的业务或者辅助功能等，就可以使用后台线程。

后台线程演示： 

     public static void main(String[] args) throws InterruptedException {Thread thread = new Thread(()->{while (true){System.out.println("hello thread");try {Thread.sleep(1000);} catch (InterruptedException e) {throw new RuntimeException(e);}}});//第一次：在线程启动之前 设置线程为后台,观察线程的存活状态thread.setDaemon(true);System.out.println("在线程start之前设置为后台线程，此时的存活状态是："+ thread.isAlive());//启动线程thread.start();//此时休眠是因为start之后，系统要去创建PCB，给系统一点时间能够创建成功Thread.sleep(2000);//第二次：在start线程之后，观察线程的存活状态System.out.println("在线程start之后观察线程的存活状态："+thread.isAlive());System.out.println("main线程执行完成");System.out.println("此时线程是否存活:"+thread.isAlive());}

（3）是否存活 isAlive()指的是系统的线程PCB是否存活，并不是说我们new出来的Thread对象。

（4）是否被中断：停止或者终止当前现成的任务

        方式1：通过设置中断标识:主要注意代码中的while(!isQuit) 和 isQuit = true这两点。

          方式2：通过调用Thread类提供的interruped()方法来中断线程。isInterrupted()默认为false不中断。

        注意看下面的写法：有两处改动，但是会抛出异常。

        这主要是因为上面的两处改动都针对的是runnable状态中的异常处理，所以我们还要对 Sleep状态做处理：在catch中处理：有三种方式：

（5）等待一个线程 join()：等待线程结束

（6）获取当前线程引用：Thread thread = Thread.currentThread();

（7）start()方法

❓  问题：start()方法与run()方法的区别？（面试题）
        start()：申请一个真正的系统线程

        run() :定义线程要执行的任务。

        直接调用run方法，并不会去申请一个真正的系统线程(PCB)，只是一个普通的方法调用，是单独的调用对象的方法。调用start方法，JVM会调用本地方法去系统中真正的申请一个线程(PCB),并执行run方法中 的逻辑。

---

 🌾5、线程的状态

注意：线程的状态指的是Thread对象（有自己的生命周期）的状态，并不是PCB的状态。主要有以下几种：

1、NEW ：java对象创建好了，但是还没有调用start方法创建PCB。

2、RUNNABLE : 就绪和运行状态。可以随时调度到CPU中执行。

3、TERMINATED: 线程任务执行完成，PCB在操作系统中已经销毁，但是java对象还存在。 

4、TIMED_WATING ：等待一段时间，这个时间是有时间限制的等待（过时不候)。比如sleep()，常见的访问超时。

5、WAITING：没有时间限制的等待。

6、BLOCK：等待锁的时候进入的阻塞状态。

        最后，知道 在系统中针对线程的两个调度是用两个队列来实现的。准备执行的线程在就绪队列中，随时等待CPU调度。当调用sleep,wait,join方法时，就会被移动到阻塞队列中。当休眠时间到了之后，就会被移动回就绪队列，重新参与CPU调度。

---