【JavaEE 初阶（一）】初识线程

❣博主主页: 33的博客❣
▶️文章专栏分类:JavaEE◀️
🚚我的代码仓库: 33的代码仓库🚚
🫵🫵🫵关注我带你了解更多线程知识

在这里插入图片描述

1.前言
2.进程
3.线程
4.线程和进程的区别
5.Thread创建线程
- 5.1继承Thread创建线程
- 5.2实现Runnable接口
- 5.3lambda表达式
6.Thread常见方法
- 6.1Thread常见属性
- 6.2 中段一个线程- interrupt()
- 6.3等待线程-jion（）
7.线程的状态
- 2.1代码实现
- 2.2运行结果

1.前言

我们设想：一家公司要去银行办理业务，既要进行财务转账，又要进行福利发放，还得进行缴社保。如果只有张三一个会计就会忙不过来，耗费的时间特别长。为了让业务更快的办理好，张三又找来两位同事李四、王五一起来帮助他，三个人分别负责一个事情，分别申请一个号码进行排队，自此就有了三个执行流共同完成任务，但本质上他们都是为了办理一家公司的业务。此时，我们就把这种情况称为多线程，那么在Java中该如何实现多线程呢？我们一起来学习吧！！

2.进程

提到线程，我们就不得不先了解进程了，那么什么是进程呢？进程就是运行起来的一个个程序。引入进程有什么作用呢？是为了实现并发编程。但进程有很多，系统是如何管理它们的呢？那就是"先描述，再组织"。

描述:使用PCB结构表示进程的各种属性。
PCB中的重要特性: 1.pid（进程标识符）2.内存指针（表示进程持有的内存资源，比如内存空间具体在哪里，有哪些部分组成，每个部分干啥的等等）3.文件描述表（表示进程持有的硬盘资源，类似于顺序表）4.CPU资源（状态、优先级、上下文、记账消息，这些都主要来完成进程调度）

组织：利用双显链表，把PCB的这些结构串起来。
进程是资源分配的基本单元，创建进程需要给他分配内存和硬盘资源需要消耗的时间太多，销毁一个进程销毁的时间很多，调度一个进程消耗的时间也很多，如果频繁的创建或者销毁一个资源，这个时候的开销就是非常大的，为了解决这个问题，我们引入了线程（Thread）。

3.线程

线程也叫做“轻量级进程”，创建线程，销毁线程，调度线程都比进程更快。但线程不能独立存在，要依附于进程，即一个进程至少包含一个线程！但每一个线程都是独立执行的，一个进程，最开始的时候必须要包含一个线程，这个线程负责完成执行代码的工作，也可以创建出多个线程，完成并发执行的效果。

线程的特点：
1.每一个线程都可以独立的去cpu上执行
2.同一个进程的多个线程之间公用一份内存空间和文件资源
3.同一个进程中，采用多线程的方式能提高效率，但有一定限度，如果无限度的引入线程可能是调度开销增大，导致效率反而降低
4.同一个进程中，一个线程抛出异常，如果没有妥善处理可能会导致整个进程崩溃。

4.线程和进程的区别

1.一个进程包含一个或多个线程
2.进程和线程都是用来实现并发编程的，但线程比进程更轻量，更高效
3.进程和进程之间具有独立性，如果一个进程异常不会影响到其他进程，但线程和线程之间可能会相互影响
4.进程是资源分配的基本单位，线程是调度执行的基本单位

5.Thread创建线程

线程是操作系统的概念，操作系统提供了一些API可以操作线程，Java对系统API进行了封装，使用Thread类就可以创建出一个线程.

5.1继承Thread创建线程

方法1:

java">package Thread;
class MyThread extends Thread{@Override//线程的入口public void run() {while (true) {System.out.println("hello thread");//隔1s轮转try {Thread.sleep(1000);//1s} catch (InterruptedException e) {e.printStackTrace();}}}
}
public class Demo1 {public static void main(String[] args) throws InterruptedException {Thread t=new MyThread();//start和run都是Thread的成员//run只是描述线程的入口，线程主要做什么//start则是真正的调用了系统API创建了线程，让线程再调用run（）t.start();while (true){System.out.println("hello main");Thread.sleep(1000);}}
}

方法2：匿名内部类

java">package thread;
public class Demo3 {public static void main(String[] args) {Thread t = new Thread() {//匿名内部类@Overridepublic void run() {while (true) {System.out.println("hello thread");try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}}}};t.start();while (true) {System.out.println("hello main");try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}}}
}

注意
1.Thread在java.lang这个包下并不用导包
2.start方法内部会调用系统的API生成一个线程再调用run函数，和run函数的效果类似，但本质区别为：是否会创建一个线程

5.2实现Runnable接口

方法1：

java">package 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) {Runnable runnable = new MyRunnable();Thread t = new Thread(runnable);t.start();while (true) {System.out.println("hello main");try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}}}
}

方法2：匿名内部类

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

5.3lambda表达式

java">package thread;
public class Demo6 {public static void main(String[] args) {//lambda表达式Thread t = new Thread(() -> {while (true) {System.out.println("hello thread");try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}}},"第一个线程");t.start();while (true) {System.out.println("hello main");try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}}}
}

6.Thread常见方法

6.1Thread常见属性

属性	获取方法
ID	getId
名称	getName
状态	getState
优先级	getPriority
是否后台线程	isDaemon
是否存活	isAlive
是否被中断	isInterrupted

ID 是线程的唯一标识，不同线程不会重复
名称是各种调试工具用到
状态表示线程当前所处的一个情况，下面我们会进一步说明
优先级高的线程理论上来说更容易被调度到
后台线程：守护线程，后台线程结束与否不影响整个程序，但如果前台线程没有结束，进程也不会结束。
是否存活：判断内核线程是否已经销毁

6.2 中段一个线程- interrupt()

首先我们要知道，一个线程如果时间特别长，那么大概率在线程的内部有循环再一直执行。如果想要中断此线程，那么我们就想办法尽快让run函数执行完成，那么怎么能让循环快速执行完呢？其实我们只需要在循环处添加一个条件，条件不成立就结束了。
例如：

java">public class Demo7 {public static boolean  flag=false;public static void main(String[] args) throws InterruptedException {Thread t=new Thread(()->{while (!flag){System.out.println("t进程");try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}}System.out.println("工作完毕");});t.start();Thread.sleep(5000);flag=true;System.out.println("打断进程");}
}

注意
定义flag的时候只能定义为成员变量，不能定义为局部变量，因为在lambda有一个语法规则：变量捕获。把当前作用域的变量在lambda中复制了一份，在变量捕获时有一个前提限制：必须只能捕获final修饰的变量或者变量不能做任何修改。如果把flag设置为成员变量，就不再是变量捕获的与法律，而是内部类访问外部类的属性。

但是如果我们每次都专门定义一个标志位来打断线程是非常麻烦的，而且当处于睡眠模式下还不能立即就想应，在Thread类中有有一个标志位isInterupted来判定线程是否被打断。

java">public class Demo8 {public static void main(String[] args) throws InterruptedException {Thread t=new Thread(()->{while (!Thread.currentThread().isInterrupted()){System.out.println("t进程");try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();//唤醒sleep有3种操作//1.不管它，继续执行t线程//2.立即执行打断break;//3.进行一些其他操作}}});t.start();System.out.println("main进程");Thread.sleep(5000);System.out.println("t进程打断");t.interrupt();//打断}
}

说明
1.Thread.currentThread()表示当前线程即t线程
2.在正常情况下，sleep休眠时间完成才会被唤醒，如果调用interrupt()那么就提提前唤醒它触发InterruptedException异常
观察下图：虽然打断了t线程并且触发了InterruptedException异常，但t线程依然在执行。
在这里插入图片描述
出现上述情况是因为：interr唤醒sleep之后会抛出异常当同时也会清除标志位，这就使打断效果像没有生效一样。Java期望当线程收到“要中断”的信号使，由本身来决定接下来该怎么做。

6.3等待线程-jion（）

等待一个线程即使指，当一个线程执行完毕时才能执行另外一个线程。

java">public class Demo9 {public static void main(String[] args) throws InterruptedException {Thread t=new Thread(()->{for (int i=0;i<5;i++){System.out.println("t线程正在执行");}});t.start();//等待t线程执行结束再执行main线程t.join();System.out.println("t线程执行结束");System.out.println("main线程");}
}

7.线程的状态

在进程中最核心的状态就是就绪和阻塞状态，在线程中同样适用，同时java又赋予了线程一些其他的状态：

NEW:创建Thread对象安排了工作，但没有启动。
RUNNABLE：指就绪状态，即线程正在执行或者线程等待执行
TERMINATED: 工作完成了
TIMWD_WAITING:阻塞，由于sleep这种固定的时间方式而阻塞
WAITING: 阻塞，由于wat这种不固定的时间方式而阻塞
BLOCKED: 阻塞，由于锁竞争导致的阻塞
在Java中可以通过getState()方法来查看此时线程的状态。

2.1代码实现

java">public class Demo10 {public static void main(String[] args) throws InterruptedException {Thread t=new Thread(()->{for (int i=0;i<3;i++){System.out.println("t线程在执行");}});System.out.println(t.getState());t.start();System.out.println(t.getState());Thread.sleep(3000);System.out.println(t.getState());}
}