Thread常用方法

join

join和FutureTask的get函数一样，只有自身执行完成之后，才会继续向下执行。

Thread t1=new Thread(()->{
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            System.out.println("t1线程");
        });

        t1.start();
        t1.join();
        //主线程会等待t1执行完成才会继续执行
        System.out.println("主线程");

interrupt

执行interrupt，如果t1线程不是休眠状态(t1中执行了sleep或者wait)，是不会抛出异常的。可以通过获取t1线程的打算状态。来通过业务逻辑结束正在运行的业务。
如果t1线程中有sleep，执行interrupt打断函数，打断休眠状态isInterrupted返回的是false，并不是true。sleep会抛出打断异常，可以通过捕获异常在异常处理中再次执行interrupt函数

 Thread t1  = new Thread(()->{
            while (true){
                boolean interrupted = Thread.currentThread().isInterrupted();
                if(interrupted){
                    System.out.println("t1线程被打断了");
                    break;
                }
            }
         });

        t1.start();
        Thread.sleep(2000);
        t1.interrupt();

优雅的结束线程

定义while(true)对打算状态进行时刻监控，什么时候外界调用打算函数，对线程进行业务逻辑方式进行终止
while会对cpu资源造成大量的消耗，所以加上sleep，但是sleep会导致isInterrupted状态重置，sleep会抛出打断异常，可以通过捕获异常在异常处理中再次执行interrupt函数

 private static Thread t1;

    public void start(){
        t1=new Thread(()->{
            //负责监控，什么时候外界调用打算函数，对线程进行业务逻辑方式进行终止
            while (true){
                boolean interrupted = Thread.currentThread().isInterrupted();
                if(interrupted){
                    System.out.println("线程被打断，");
                    break;
                }
                
                //如果不加上sleep，while会对cpu资源造成大量的消耗，但是sleep会导致isInterrupted状态重置
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    //在异常中，重新设置中断状态，让下一次循环的时候，可以进行if判断，结束线程
                    Thread.currentThread().interrupt();
                    throw new RuntimeException(e);
                }
            }
          
        });
        t1.start();
    }
    
    public void stop(){
        t1.interrupt();
    }

不推荐使用的函数

这些方法已过时，容易破坏同步代码块，不释放锁，从而造成线程死锁