DaiXT：线程初识-CSDN博客

本文链接：https://blog.csdn.net/Dai_XT/article/details/126388977

线程的五种状态新建状态、就绪状态、运行状态、阻塞状态、死亡状态
在这里插入图片描述

新建状态使用new关键字和Thread类或其子类创建一个线程对象后，该线程处于新建状态，该状态一直持续到调用start方法。

就绪状态当线程对象调用start()方法之后，该线程就进入就绪状态。就绪状态的线程处于就绪队列当中，要等待JVM线程调度器的调度。

运行状态如果就绪状态的线程获取CPU资源，就可以执行run（），此时线程便处于运行状态。处于运行状态。处于运行状态的线程最为复杂，它可以变为阻塞状态、就绪状态、死亡状态。

阻塞状态如果一个线程执行了sleep（）、suspend（）等方法，失去所占用的资源后，线程便由运行状态变为了阻塞状态。在睡眠时间已到或获得设备资源后可以重新进入就绪状态，可分为三种，

等待阻塞：运行状态中的线程执行了wait（）方法，使线程进入到等待阻塞状态。
同步阻塞：线程在获取synchronized同步锁（同步锁被其他线程占用）。
其他阻塞：通过调用线程的sleep（）或join（）发出I/O请求时候，线程就会进入到阻塞状态。当sleep（）状态超时，join（）等待线程终止或超时，或者I/O处理完毕，线程重新进入就绪状态。

等待获取一个排它锁，如果其线程释放了锁就会结束此状态。

死亡状态：

一个运行状态的线程完成任务或者其他终止条件发生时，该线程就切换到终止状态。

线程的优先级：

Java 线程的优先级是一个整数，其取值范围是 1 （Thread.MIN_PRIORITY ） - 10 （Thread.MAX_PRIORITY ）。默认情况下，每一个线程都会分配一个优先级 NORM_PRIORITY（5）。

优先级只能影响处理器分配资源的顺序，并不能保证线程执行的顺序，而且非常依赖于平台。

创建线程的三种方式：

通过实现Runnable接口；
通过继承Thread类本身；
通过Callable和Future创建线程；

线程名称的获取

通过getName()方法、通过toString()方法()。toString方法返回此线程的字符串表示，包括线程的名称，优先级和线程组。而线程的优先级可以通过setPriority()方法进行设置。

通过如上三种方法创建线程的代码如下

package Main;
import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;

/***
 *
 * @Author: daiXT
 * @Date: 2022-08-17 14:36
 * @param： null
 * @return: null
 * 线程的三种创建方式：通过实现Callable接口、通过实现Runnable接口、通过继承Thread类
 **/

public class test {
//    利用内部类的方式继承Thread
class ReThread extends Thread{
    @Override
    public void run() {

    }
}
    public static void main(String[] args) throws InterruptedException {
        //利用匿名内部类的方式实现Callable接口
        FutureTask<Integer> futureTask = new FutureTask<>(new Callable<Integer>() {
            @Override
            public Integer call() throws Exception {
                return 1;
            }
        });
        Thread thread1 = new Thread(futureTask,"使用匿名内部类实现Callable接口创建线程");
        //简写方式
        Thread thread1_1  = new Thread(new FutureTask<Integer>(()->{
            return 2;
        }),"Callable简写的方式");

        thread1.start();
        thread1_1.start();
        thread1.join();
        System.out.println(thread1.getName()+"--此时的线程状态为:"+thread1.getState());



        //    利用匿名内部类的方式实现Runnable接口
        Thread thread2 = new Thread(new Runnable() {
            @Override
            public void run() {

            }
        },"使用匿名内部类的方式实现Runnable接口创建线程");
        //简写方式
        Thread thread2_2 = new Thread(()->{

        },"Runnable简写方式");

        thread2.start();
        thread2_2.start();
        thread2_2.join();
        System.out.println(thread2.getName()+"--此时的线程状态为:"+thread2.getState());


        //使用内部类的方式创建线程
        test.ReThread ts = new test().new ReThread();
        ts.setName("使用内部类继承Thread的方式创建的线程");
        ts.start();
        ts.join();
        System.out.println(ts.getName()+"--此时的线程状态为"+ts.getState());
    }
}

运行结果如下：

使用匿名内部类实现Callable接口创建线程--此时的线程状态为:TERMINATED
使用匿名内部类的方式实现Runnable接口创建线程--此时的线程状态为:TERMINATED
使用内部类继承Thread的方式创建的线程--此时的线程状态为TERMINATED