线程的创建和使用(二)_创建线程调用-CSDN博客

本文链接：https://blog.csdn.net/m0_53714343/article/details/131293703

1、线程的类和方法

Thread类是JVM用来管理线程的一个类，换句话说，每个线程都有唯一一个的Thread对象与之关联。

1.1、Thread的常见方法

方法	说明
Thread()	创建线程对象
Thread(Runnable target)	使用Runnable对象创建线程对象
Thread(String name)	创建线程对象并命名
Thread(Runnable target,String name)	使用Runnable对象创建线程对象，并命名
【不常用】Thread (ThreadGroup group，Runnable target)	线程可以用来分组管理，分好的组即为线程组

Thread t1=new Thread();

Thread t2=new Thread(new MyRunnable());

Thread t3=new Thread("线程的名字");

Thread t4=new Thread(new MyRunnable(),"线程的名字");

1.2、Thread的几个常见属性

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

Thread类是JAVA中的类，我们通过java代码创建Thread对象是java中的对象，调用start方法后，通过JVM去申请操作系统中的线程PCB，线程的对象是与PCB是一一对应的关系，但是他们的生命周期是不同的。

2、示例

2.1、后台线程的演示


public class Exe_02 {
    public static void main(String[] args) {
        //创建一个线程
        Thread thread=new Thread(()->{
            while(true){
                System.out.println("你干嘛,哎呦");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        //设置成后台线程
        thread.setDaemon(true);
        //启动线程
        thread.start();
        //查看线程是否存活
        System.out.println("是否存活"+thread.isAlive());
        System.out.println("main方法执行完成");
    }
}

设置为后台线程时，mian方法执行完成之后，，整个线程就退出了

1、线程在创建的时候，默认是一个前台线程

2、前台线程是可以组织线程退出的

3、后台线程不阻止影响进程的退出

2.2、线程是否存活


/**
 * 演示线程是否存活
 */
public class Exe_03 {
    public static void main(String[] args) throws InterruptedException {
        //创建线程
        Thread thread=new Thread(()->{
           int count=0;
           while(true) {
               System.out.println("小黑子" + count++);
               try {
                   Thread.sleep(1000);
               } catch (InterruptedException e) {
                   e.printStackTrace();
               }
               //运行五次退出
               if(count>=5){
                   break;
               }
           }
        });
        //启动之前查看是否存活
        System.out.println("启动之前是否存活->"+thread.isAlive());
        //启动线程
        thread.start();
        //等待一秒让系统创建线程，确保线程创建完成开始执行
        Thread.sleep(1000);
        System.out.println("启动之后是否存活"+thread.isAlive());
        //等待线程执行完成
        thread.join();
        System.out.println("线程执行完成是否存活"+thread.isAlive());
    }
}

2.3、线程的各个属性


/**
 * 线程的属性
 */
public class Exe_04 {
    public static void main(String[] args) {
        Thread thread=new Thread(()->{
            while(true){
                System.out.println("hello,iKun");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"鸽鸽");
        //启动线程
        thread.start();
        System.out.println("线程id="+thread.getId());
        System.out.println("线程名="+thread.getName());
        System.out.println("进程状态="+thread.getState());
        System.out.println("进程优先级="+thread.getPriority());
        System.out.println("线程是否后台="+thread.isDaemon());
        System.out.println("线程是否存活="+thread.isAlive());
        System.out.println("线程是否中断="+thread.isInterrupted());
    }
}

2.4、start()和run()方法的区别

分别调用这两个方法的现象？

start()方法：它调用系统API，去申请一个系统层面的PCB，也就是说真正的申请系统的线程。

run()方法：是在描述线程中具体要执行的任务。

*单独调用run方法，只是对一个普通的java对象的普通方法调用而已，跟String的equals()方法一样，它并没有真正的去启动一个线程。

/*
start()方法是真正意义上调用系统API，申请系统层面的PCB,申请了系统创建线程的资源，真正创建了线程，可以进行多线程的调用
run()描述了线程任务，并不能进行多线程的调用，就跟普通的方法是一样的
 */
public class Exe_05 {
    public static void main(String[] args) throws InterruptedException {
        Thread thread=new Thread(()->{
           while(true){
               System.out.println("只因坤坤爱坤坤");
               try {
                   Thread.sleep(1000);
               } catch (InterruptedException e) {
                   e.printStackTrace();
               }
           }
        });
        thread.start();
        //调用run方法
        thread.run();
        //主线程打印一句话
        while(true){
            System.out.println("main");
            Thread.sleep(1000);
        }
    }
}

2.5、线程中断

线程执行一半的时候需要停下来，提前结束。

目前常见的有以下两种方式：
1. 通过共享的标记来进行沟通
2. 通过thread调用 interrupted() 方法来通知

方式一：


/**
 * 通过标志位完成线程中断
 */
public class Exe_06 {
    //设置标志符
    private static Boolean isQuit=false;
    public static void main(String[] args) throws InterruptedException {
        Thread thread=new Thread(() ->{
            //每次执行都要判断是否中断标志位
            while(!isQuit){
                System.out.println("再多一眼看一眼就会爆炸");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("线程执行完成");
        });
        System.out.println("线程启动前的状态="+thread.getState());
        System.out.println("线程启动前是否存活="+thread.isAlive());
        //启动线程
        thread.start();
        System.out.println("线程启动后的状态="+thread.getState());
        System.out.println("线程启动后是否存活="+thread.isAlive());
        //等待5秒
        Thread.sleep(4000);
        //修改标志位
        isQuit=true;
        Thread.sleep(4000);
        System.out.println("线程中断之后的状态="+thread.getState());
        System.out.println("线程中断之后是否存活="+thread.isAlive());
    }
}

方式二:


public class Exe_07 {
    public static void main(String[] args) throws InterruptedException {
        Thread thread=new Thread(() ->{
            //判断当前线程内部维护的中断标识
            while(Thread.currentThread().isInterrupted()){
                System.out.println("练习时长两年半");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                    //中断唤醒线程睡眠状态，会抛出异常
                    //处理中断逻辑
                    //方式一；什么也不干，不去理会
                    //方式二：一会处理
                    //方式三：真正的中断操作
                    break;
                }
            }
            System.out.println("线程执行完成");
        });
        //启动线程
        thread.start();
        System.out.println("启动之前线程状态"+thread.getState());
        System.out.println("启动之前是否存活"+thread.isAlive());
        //先让这个线程执行一会
        Thread.sleep(3000);
        //中断线程
        thread.isInterrupted();//调用本地方法让PCB完成中断
        //等待线程销毁
        Thread.sleep(3000);
        System.out.println("中断之后线程状态"+thread.getState());
        System.out.println("中断之后是否存活"+thread.isAlive());
    }
}

调用Interrupted()方法后，会有两种情况注意：

1、线程正在RUNNABLE状态，那么不抛出异常，会直接中断。

2、线程在TIMED_WAITING状态，这时线程被唤醒配置并抛出异常，那么处理逻辑就要以catch语句块进行处理

3、处理中断能否正确执行，有两个地方需要判断，一个式while循环条件，处理情况1，异常中处理情况2。

2.6、线程等待


public class Exe_08 {
    public static void main(String[] args) {
        //创建线程
        Thread thread=new Thread(() ->{
            for (int i = 0; i < 5; i++) {
                System.out.println("hello,thread!!!");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("线程执行完成！");
        });
        //启动线程
        thread.start();
        System.out.println("join之前线程状态" + thread.getState());
        System.out.println("join之前是否存活" + thread.isAlive());
        //使用join等待thread线程结束
        try {
            thread.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("join之后线程状态" + thread.getState());
        System.out.println("join之后是否存活" + thread.isAlive());
        System.out.println("主线程执行完成！！");
    }
}

2.7、休眠当前线程

2.8、获取当前线程

方法	说明
public static Thread currentThread();	返回当前线程对象的引用

3、线程的状态

线程的状态是一个枚举类型 Thread.State

*NEW: 安排了工作, 还未开始行动
*RUNNABLE: 可工作的. 又可以分成正在工作中和即将开始工作.
*BLOCKED: 这几个都表示排队等着其他事情
*WAITING: 这几个都表示排队等着其他事情
*TIMED_WAITING: 这几个都表示排队等着其他事情
*TERMINATED: 工作完成了.