Thread类的介绍

线程是操作系统中的概念，操作系统中的内核实现了线程这种机制，同时，操作系统也提供了一些关于线程的API让程序员来创建和使用线程。

在JAVA中，Thread类就可以被视为是对操作系统中提供一些关于线程的API的的进一步的封装。

多线程程序的特点

1.每一个线程都是一个执行流

2.CPU对线程的执行是并发执行，同时对线程的执行也是随机调度的。

1.创建线程

1. 通过Thread类创建线程

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

我们通过创建一个Thread类的子类MyThread，重写Thread类中的run方法，并通过MyThread子类来创建一个线程的实例化对象，run方法是线程的入口函数。而在主函数中的start方法，表示创建一个线程，且一个线程只能start一次。

当我们运行上面代码，发现打印的内容的顺序会变换，这是因为多线程的影响，上面代码中有两个线程，分别位t线程和主线程，由于线程在CPU上是并发执行的，且又因为CPU对线程又是随机调度的，这就导致我们两个线程的执行顺序会改变，自然而然打印的顺序也会改变。

2.通过Runnable接口来创建线程

class MyRunnable implements Runnable{ @Override public void run() { while (true){ System.out.println("hello t"); 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(); } }

3. 通过匿名内部类来创建线程

匿名内部类的写法本质完成了3件事

1.创建了一个Thread的子类，不知到该子类的名字，所以为匿名。

2.{ }代码块里面可以编写子类的定义代码，需要哪些属性，需要重写哪些父类的方法等等。

3. 创建了匿名内部类的实例，并将该实例传给了t1.

3.1 Thread

public static void main(String[] args) throws InterruptedException { Thread t1=new Thread(){ @Override public void run() { while(true){ System.out.println("hello t"); try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } } } }; t1.start(); while (true){ System.out.println("hello main"); Thread.sleep(1000); } }

3.2 Runnable接口

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

4.通过Lambda表达式式创建线程-----()->{}

由于Java中，方法必须依附于类的体系中，由于Lambda表达式本质就是一个回调函数，所以，为了快速实现这个回调函数，在Java中，就创建了一个函数式接口-----()->{ },{ }代码块可以写上回调函数所需要功能的代码。

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

5.实现Callable接口与FutureTask

java.util.concurrent.Callable接口类似于Runnable，但Callable的call()方法可以有返回值并且可以抛出异常。要执行Callable任务，需将它包装进一个FutureTask，因为Thread类的构造器只接受Runnable参数，而FutureTask实现了Runnable接口。

package com.xzt.thread; import java.util.concurrent.Callable; import java.util.concurrent.ExecutionException; import java.util.concurrent.FutureTask; class MyCallable implements Callable<Integer>{ @Override public Integer call() throws Exception { int sum=0; for(int i=0;i<101;i++){ sum+=i; } return sum; } } public class demo4 { public static void main(String[] args) throws ExecutionException, InterruptedException { MyCallable task=new MyCallable(); FutureTask<Integer> futureTask = new FutureTask<>(task); Thread t=new Thread(futureTask); t.start(); Integer result=futureTask.get(); System.out.println("result:"+result); } }

6.使用线程池（Executor框架）

从Java 5开始引入的java.util.concurrent.ExecutorService和相关类提供了线程池的支持，这是一种更高效的线程管理方式，避免了频繁创建和销毁线程的开销。可以通过Executors类的静态方法创建不同类型的线程池。

class Task implements Runnable{ @Override public void run() { String threadName = Thread.currentThread().getName(); System.out.println("线程：" + threadName + " 输出：1111"); } } public class demo5 { public static void main(String[] args) { ExecutorService executor= Executors.newFixedThreadPool(10); for (int i=0;i<100;i++){ executor.submit(new Task()); } executor.shutdown(); } }

缺点：程池增加了程序的复杂度，特别是当涉及线程池参数调整和故障排查时。错误的配置可能导致死锁、资源耗尽等问题，这些问题的诊断和修复可能较为复杂。

优点：线程池可以重用预先创建的线程，避免了线程创建和销毁的开销，显著提高了程序的性能。对于需要快速响应的并发请求，线程池可以迅速提供线程来处理任务，减少等待时间。并且，线程池能够有效控制运行的线程数量，防止因创建过多线程导致的系统资源耗尽（如内存溢出）。通过合理配置线程池大小，可以最大化CPU利用率和系统吞吐量。

2.Thread类及常见方法

Thread类是JVM用来管理线程的一个类，也就是说，每个线程都有唯一的Thread类对象与之相关联。在Java中，每一个执行流（线程）都要用一个对象来表示，而Thread类对象就可以用来表示一个线程执行流，JVM会将这些Thread类对象组织起来，进行线程调度和线程管理。

2.1 Thread类常见的构造方法

注释：关于线程的名字，我们可以通过Jconsole来观察。

2.2 Thread的几个常见属性

1.ID是线程的唯一标识，不同线程的ID不会重复

2.名称是各种调试工具用到

3.状态表示线程当前所处的一个状态

4.优先级高的线程理论上更容易被CPU调度到

5.关于后台线程：线程分为后台线程（守护线程）和前台线程（用户线程）。我们需要记住一点：JVM会在一个线程中的所有的前台线程结束之后，JVM才会选择退出（程序终止执行）。也就是说，后台线程的存在不会阻止JVM的终止，相反，前台线程的存在会阻止JVM的终止，即使主线程已经结束。在Java中，线程在默认情况下是后台线程，例如垃圾回收机制就是一种后台线程。但是我们可以通过调用setDaemon(true)方法将一个线程设置为后台线程。

6.是否存活，可以简单理解为run方法是否运行结束。

2.3 如何启动一个线程----start()

一个线程对象被创建出来并不意味着线程就开始运行了。我们需要去调用start方法，接着线程中的run方法就会自动执行，只有run方法执行以后，一个线程才是真正运行起来。而调用了start方法，才是真正的在操作系统的层面建立了一个线程。

如下图：

run方法和start方法的区别：

1.功能作用不同：

a. run方法的作用是描述线程具体要执行的任务

b. start方法的作用是真正的在操作系统层面建立一个线程

2.运行结果不同：

a. run方法是一个类中的普通方法，主动调用和调用pt方法一样，会顺序执行一次

b. start方法被调用后，start方法内部会调用Java本地方法（封装了对系统底层的调用）真正得启动线程，并执行run方法中得代码，run方法执行完成后，线程进入销毁阶段。

2.4 中断一个线程

中断一个线程就是让该线程直接停止掉，不会再回复。中断一个线程就是让该线程的run方法（入口方法）尽快结束掉。

目前常见终止线程的方式有以下两种方式：

1.通过共享的标记来沟通

2.调用interrupt()方法来通知

1.通过共享的标记来沟通

该方法是通过设计一个外部成员变量来终止一个线程。

如以下代码

public class Demo9 { public static boolean isFinished=false;//共享标记 public static void main(String[] args) throws InterruptedException { Thread t=new Thread(()->{ while (!isFinished){ System.out.println("hello t"); try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } } }); t.start(); Thread.sleep(3000); System.out.println("main尝试终止线程t"); isFinished=true; } }

我们通过isFinished 这个外部成员变量的值来通知操作系统是否终止t线程。

运行结果

注意事项：我们不能将该外部成员变量设置成一个局部变量。否则会报出以下错误

原因解释：

这就涉及到变量捕获的问题 。简单来说，就是lambda表达式希望可以使用外面的变量，触发“变量捕获”的语法。由于lambda是一个回调函数，执行时机是很久以后，当操作系统真正创建出线程之后，才会执行。很有可能在创建线程的过程中，main线程就已经运行结束了,自然而然，身为局部变量的isFinished就会被销毁了。

为了解决这个问题，Java中的做法是，将被捕获的变量拷贝一份到lambda里面，外面变量的是否销毁，就不影响lambda里面的执行了。拷贝就以为着该变量就不适合被修改，尽管你在外面修改了这一变量的值，也不会影响拷贝到内部的值（本质上，被拷贝的变量和拷贝的变量是两个变量）

这种一边变，一边不变，可能给程序员带来更多的疑惑。所以在Java中就规定了，拷贝的变量就压根不允许被改变。所以后面修改isFinished的值时会报一个isFinished should be final or effectively final 的错，因为在Java中，被final修饰的变量是无法被修改的。

那为什么将isFinished设置为成员变量会没事呢？

因为当isFinished是一个成员变量时，此时触发的语法不在是“变量捕获”，而是切换成“内部类访问外部类的成员”的语法。

那是lambda表达式本质上是一个函数式接口，也相当于是一个内部类。isFinished本身就是一个外部类成员，内部类本来就能够访问外部类的成员。由于成员变量的生命周期是让GC（垃圾回收）来管理的，GC可以自动识别不在被引用的的对象，并将其占用的内存空间释放掉。所以在lambda里面就不必担心变量生命周期失效的问题，也就不必拷贝，也就不必有被final修饰的限制。

2.使用interrupt()方法来通知

Java的Thread类中提供了现成的方法直接进行判定线程方法是否被终止，不需要我们自己在创建了。

thread收到通知的方式有两种：

1.如果线程因为调用wait/join/sleep等方法而阻塞挂起，则以InterruedException异常的形式通知，清楚中断标志 ，当出现InterruedException的时候，要不要结束进程取决于catch中代码的写法，可以忽略该异常，也可以跳出循环结束进程。

2.否则，只是内部的一个中断标志位被设置了，可以通过isInterrupted()方法判断中断标志是否被设置，不清除中断标志，这种方法通知收到的更及时，即使线程在sleep也可以马上收到。

public class Demo10 { public static void main(String[] args) throws InterruptedException { Thread t=new Thread(()->{ while (!Thread.currentThread().isInterrupted()){ System.out.println("hello t"); try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace();//报异常，清楚中断标志 //break;//跳出循环，结束进程 //啥都不写，忽略异常，进程继续执行 } } }); t.start(); Thread.sleep(3000); System.out.println("main尝试终止线程t"); t.interrupt(); } }

注意事项：针对上述代码由于每次循环，线程大部分时间在处sleep状态，当主线程调用interrup()方法时，会大概率唤醒sleep方法， sleep方法就会报InterruedException异常。

正常来说，调用interrupt()方法就会将isInterrupted()方法内部的标志位改为true，但是上述代码，能够把sleep()方法唤醒，sleep方法在唤醒之后就会将isInterrupted()方法内部的标志位的值重新改为false。因此在进程不结束的情况下，如果继续执行到循环的条件判断，就会发现能够继续执行循环中的代码。

2.5 等待一个线程-----join()

有时我们需要等到一个线程完成它的所有操作后，才进行下一步操作。这时候就用到了join()方法。

public class Demo11 { public static void main(String[] args) throws InterruptedException { Thread t=new Thread(()->{ for(int i=0;i<3;i++){ System.out.println("hello t"); try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } } }); t.start(); System.out.println("main线程在等t线程结束"); t.join(); System.out.println("t线程结束，main线程结束"); } }

上面的代码中，主线程中线程对象t调用了join方法，这就意味着main线程必须要先等待t线程结束后，才会执行main线程里面的内容。

运行代码

如果调用的是join(long millis)版本，则会表示main线程只会等待t线程millis秒，不管t线程在这段时间内是否终止，main线程不会在等待t线程，而是继续执行自己的任务。

public class Demo11 { public static void main(String[] args) throws InterruptedException { Thread t=new Thread(()->{ for(int i=0;i<3;i++){ System.out.println("hello t"); try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } } }); t.start(); System.out.println("main线程在等t2秒"); t.join(2000); System.out.println("2秒内t线程没有结束，main线程不在等待，执行main线程"); } }

2.6 获取当前线程引用

2.7 休眠当前线程-----sleep()

关于sleep方法，有一点我们需要记得，因为线程调度是不可控的，所以，sleep方法只能保证实际休眠时间是大于等于参数设置的休眠时间的。

这是因为调用sleep方法，相当于让当前线程，让出cpu的资源。后续休眠时间结束的时候，该线程需要操作系统内核时，操作系统会将该线程重新调度到cpu上，该线程才能继续执行。

换言之，sleep的时间到了，意味着该线程可以被调度，而不是立即执行，所以实际休眠时间会大于等于参数设置的休眠时间。

特殊用法：sleep(0)

sleep(0)意味着让当前线程立刻放弃CPU资源，等待操作系统重新调度。

3.线程状态

从操作系统的角度来看，进程的有就绪和阻塞的两种状态。

Java线程也是对操作系统中的线程的重新封装。所以，针对线程的状态，Java中也重新进行了封装。