展览展会网站建设品牌定位

博客结尾包含此篇博客的全部代码！！！

一、进程

1.1 进程的定义

• 进程（Process）是计算机操作系统中的一个核心概念，它是程序在计算机上的一次动态执行实例。换句话说，进程是程序运行时的活动表现形式。它包含了程序代码、数据、运行状态以及系统资源的分配情况。进程相当于一个正在运行的程序。
• 进程也是系统分配资源的基本单位。

1.2 进程和线程的联系

首先，并发编程成为我们的需求！每个客户端给服务器发送请求，服务器就需要给客户端提供服务。在90年代，多进程是一种解决方案！！！

那么既然有解决方法，为什么还要引入线程？
线程：线程是轻量级的进程！！！

线程相比于进程：

• 创建线程比创建进程更快。
• 销毁线程比销毁进程更快。
• 调度线程比调度进程更快。

举个例子：

假设这个任务是“消灭”桌子上的两只鸡，在一个房间中有一个桌子，桌子上放了两只鸡。
进程的解决方法：再创建一个房间，将这两只鸡分开，分别“消灭”。

线程的解决方法：在这个房间中“消灭”这两只鸡。

这两个对比你发现：相同的人数，进程需要再创建一个房间（开销很大），而线程则啥都不需要添加。

二、线程

2.1 JConsole工具

在创建线程之前，先给大家介绍一下JConsole 工具， JConsole是JDK 自带的一款图形化监控和管理工具，基于 JMX（Java Management Extensions）技术实现。它能够连接到本地或远程的 Java 虚拟机（JVM），并实时监控和管理 Java 应用程序的性能和资源使用情况。
这里我们就用它来监控我们的线程！
JConsole：找到我们的JDK安装的安装路径，像我这里安装的JDK17–>bin–>jconsole.exe

如何使用？
测试代码：代码运行起来才能观察到，如果线程结束就观察不到。

class MyThread extends Thread {@Overridepublic void run() {while (true) {System.out.println(" hello Thread");}}
}public class Demo1 {public static void main(String[] args) {MyThread t1 = new MyThread();t1.start();}
}

刚进去出现不安全连接，由于是我是自己练习，所以点不安全连接。

2.2 创建线程

2.2.1 Thread类，start（），run（）

• Thread类：线程，是操作系统的概念，操作系统定义了一些api（应用程序编程接口）来供程序员使用，而java中将这些api封装成Thread类来供使用！Thread类在java.long这个包中，所以用的时候不需要导包。
• start（）：用于启动一个新线程，线程调度器会调用 run() 方法。start() 方法只能被调用一次。如果尝试多次调用 start()，会抛出 IllegalThreadStateException 异常。
• run（）：定义线程的执行逻辑，但不会启动新线程。如果需要启动新线程，必须通过 start() 方法。相当于线程的入口。

2.2.2 继承Thread类

代码：

class MyThread extends Thread {@Overridepublic void run() {while (true) {System.out.println(" hello Thread");}}
}public class Demo1 {public static void main(String[] args) {MyThread t1 = new MyThread();t1.start();while(true) {System.out.println(" hello main");}}
}

2.2.3 实现Runnable接口

实现Runnable接口的MyRunnnable类，将new MyRunnable()当作一个对象传给Thread的构造函数。
代码：

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

2.2.4 匿名内部类

public class Demo3 {public static void main(String[] args) {Thread thread = new Thread(){@Overridepublic void run() {System.out.println("Hello Thread");}};thread.start();System.out.println("Hello main");}
}

2.2.5 使用Runnable接口的匿名内部类

public class Demo4 {public static void main(String[] args) {Thread t1 = new Thread(new Runnable(){@Overridepublic void run() {System.out.println("Hello Thread");}});t1.start();}
}

2.2.6 使用lambda表达式

public class Demo5 {public static void main(String[] args) {Thread thread = new Thread(()->{while(true){System.out.println("Hello Thread");}});thread.start();while(true){System.out.println("Hello main");}}
}

2.3 Thread类及常用方法

2.3.1 Thread类的构造方法

解释一下第四个Thread（Runnable target，String name）!

public class Demo6 {public static void main(String[] args) {Thread thread = new Thread(new Runnable() {@Overridepublic void run() {while (true) {System.out.println("Hello Thread");}}}, "Thread1");thread.start();while (true) {System.out.println("Hello main");}}
}

2.3.2 Thread类的常见属性

• ID 是线程的唯⼀标识，不同线程不会重复
• 获取线程的名称
• 获取线程的当前状态，如新建、就绪、运行、阻塞、等待、终止等
• 优先级⾼的线程理论上来说更容易被调度到
• 关于后台线程，需要记住⼀点：JVM会在⼀个进程的所有⾮后台线程结束后，才会结束运⾏。
• 是否存活，即简单的理解，为 run ⽅法是否运⾏结束了
• 判断线程是否被中断。线程的中断状态可以通过调用 interrupt() 方法来设置，该方法会改变线程的中断状态，但不会停止线程的执行

2.4 线程状态

public class Demo7 {public static void main(String[] args) {for(Thread.State state: Thread.State.values()) {System.out.println(state);}}
}

获取线程的所有状态：

• NEW:

• 当线程对象被创建，但尚未调用 start() 方法时，线程处于新建状态。
• 在这个状态下，线程尚未开始执行。

public class Demo7 {public static void main(String[] args) {Thread thread=new Thread(()->{System.out.println("Hello Thread");});System.out.println(thread.getState());thread.start();}
}

• RUNNABLE:

• 当调用线程的 start() 方法后，线程进入就绪状态。
• 在这个状态下，线程已经准备好运行，等待 CPU 时间片以便执行。
• 就绪状态的线程可能正在 JVM 中运行，也可能正在等待操作系统调度。

public class Demo7 {public static void main(String[] args) throws InterruptedException {Thread thread=new Thread(()->{for(int i=0;i<3;i++) {System.out.println("Hello Thread");}});System.out.println(thread.getState());thread.start();System.out.println(thread.getState());}
}

• BLOCKED: 由锁导致的，后面会出一篇关于线程安全问题，到时候会详细介绍，这里就不过多介绍了

• 当线程等待获取一个排他锁，如同步块或同步方法中的锁时，线程进入阻塞状态。
• 线程在等待锁释放后才能继续执行。
• 阻塞状态的线程不会被分配 CPU 时间片。

• WAITING:
时间阻塞（这个等待是没时间上限的）

• 当线程执行 wait()、join() 或 LockSupport.park() 方法后，线程进入等待状态。
• 在这个状态下，线程需要等待其他线程执行特定的操作（如通知或中断）才能继续。
• 等待状态的线程不会被分配 CPU 时间片。

public class Demo7 {public static void main(String[] args) throws InterruptedException {Thread thread=new Thread(()->{while(true) {}});System.out.println(thread.getState());thread.start();thread.join();}
}

发现main线程是waiting。

• TIMED_WAITING:
时间阻塞（这个等待是有时间上限的），不参与CPU调度

public class Demo7 {public static void main(String[] args) throws InterruptedException {Thread thread=new Thread(()->{while(true) {try {Thread.sleep(2000);} catch (InterruptedException e) {throw new RuntimeException(e);}}});System.out.println(thread.getState());thread.start();Thread.sleep(1000);System.out.println(thread.getState());}
}

• TERMINATED:

• 当线程的 run() 方法执行完毕，或者线程被 stop() 方法（已废弃）强制停止，或者线程抛出未捕获的异常导致运行结束时，线程进入终止状态。
• 在这个状态下，线程已经结束执行，不再消耗任何资源。

public class Demo7 {public static void main(String[] args) throws InterruptedException {Thread thread=new Thread(()->{for(int i=0;i<3;i++) {System.out.println("Hello Thread");}});System.out.println(thread.getState());thread.start();Thread.sleep(6000);System.out.println(thread.getState());}
}

2.5 后台线程和前台线程

前台线程：一般我们创建的线程都是前台线程，只要前台线程不结束，JVM就不会退出。
后台线程：也称守护线程，后台线程一般都是辅助性的任务，如果前台线程全部结束，即使还有后台线程在运行，JAM也会退出。

public class Demo8 {public static void main(String[] args) {Thread thread1=new Thread(()->{for(int i=0;i<2;i++){System.out.println("Hello Thread");}});thread1.start();System.out.println(thread1.isDaemon());//false 说明他不是守护线程Thread thread2=new Thread(()->{for(int i=0;i<2;i++){System.out.println("Hello Thread");}});thread2.setDaemon(true);thread2.start();System.out.println(thread2.isDaemon());//true}
}

2.6 休眠线程

下面那个可以达到纳秒级别，这种适用于军工，航天等之类，一把情况下用不到。

这里还有一个需要注意的是：由于 Runnable 接口的 run 方法没有 throws 子句，所以这里只能用try-catch 来捕获异常。

2.7 线程等待

public class Demo10 {public static void main(String[] args) throws InterruptedException {Thread thread = new Thread(()->{for (int i = 0; i < 3; i++){System.out.println("Hello Thread");}});thread.start();thread.join();System.out.println("Hello main");}
}

先执行thread线程，thread线程执行完，再执行main线程。为了防止死等，也可以设置等待时间。

2.8 终止线程

让run方法尽快结束。

2.8.1 自定义标志位终止线程

public class Demo11 {public static  boolean flag=true;public static void main(String[] args) throws InterruptedException {Thread thread = new Thread(()->{while(flag){System.out.println("Hello Thread");}System.out.println("Bye Bye Thread");});thread.start();Thread.sleep(1000);flag=false;}
}

将flag设置为全局变量，这里就是匿名内部类访问外部类，而不是变量捕获。
为什么不可以将flag设置为局部变量？

很有可能是main线程已经执行完，已经将flag销毁了，但是Thread线程中还没执行到while(flag)…

2.8.2 使用自带标志位终止线程

Java自带标志位来结束终止线程。先使用Thread.currentThread()来获取当前线程，在.isInterrupted()获取标志位。然后再主进程中调用interrupte()方法来将标志位值修改为true。

public class Demo12 {public static void main(String[] args) throws InterruptedException {Thread thread = new Thread(() -> {while (!Thread.currentThread().interrupted()) {System.out.println("Hello Thread");}System.out.println("Bye Bye Thread");});thread.start();Thread.sleep(1000);thread.interrupt();}
}

调用interrupte()方法，不仅会设置标志位，还会提前唤起sleep阻塞

public class Demo12 {public static void main(String[] args) throws InterruptedException {Thread thread = new Thread(() ->{while (!Thread.currentThread().isInterrupted()) {System.out.println("hahah");try {Thread.sleep(1000);} catch (InterruptedException e) {//1.不操作继续执行线程（因为sleep唤醒后会又将标志位改为true）e.printStackTrace();//2.结束线程break;//3.进行其它操作}}});thread.start();Thread.sleep(1000);thread.interrupt();}
}

此篇博客的全部代码！！！