Thread 几种构造函数介绍

1.Thread（）

代码演示：

 Thread a = new Thread();
 如果想在线程中加入线程执行的任务可以这么写：

2.Thread(Runnable target)

代码演示：

        Runnable a = new Runnable() {
            @Override
            public void run() {
                System.out.println("打印");
            }
        };
        Thread t = new Thread(a);

先创建一个Runnable的实例然后把这个实例的引用传入Thread（）

3.Thread(String name)

这个构造函数的作用是给创建的线程起个名字；

Thread常见的属性

后台线程：线程可以分为前台线程和后台线程，当所有的前台线程运行结束的时候这个进程就会结束后台线程也会一起结束

Thread中几个重要的方法介绍

1.启动一个线程-start();

用start函数来开始启动一个线程

public class t {
    public static void main(String[] args) {
     Thread a = new Thread("haha"){
         @Override
         public void run() {
             while (true){

             }
         }
     };
    System.out.println(a.isAlive());
    }

}

运行结果：

此时没有调用start函数，然后调用isAlive(),判断线程是否存活，可以看见返回的是false；
可以发现没有创建新的线程

public class t {
    public static void main(String[] args) {
     Thread a = new Thread("haha"){
         @Override
         public void run() {
             while (true){

             }
         }

     };
     a.start();
    System.out.println(a.isAlive());
    }

}

此时如果调用start函数
运行结果：

2.中断一个线程

中断一个进程的两种方法：

1. 通过共享的标记来进行沟通
2. 调用 interrupt() 方法来通知
   1.代码演示：

public class t {
    public static boolean Q = true;
    public static void main(String[] args) {
     Thread a = new Thread("haha"){
         @Override
         public void run() {
             while (Q){
                 System.out.println("你好");


             }
         }

     };
     a.start();
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        Q = false;

        
    }

}

运行结果：

在代码中定义了一个全局变量Q；只要改变Q就能控制这个线程的中断

2.代码演示：

public class t {
    public static boolean Q = true;
    public static void main(String[] args) {
     Thread a = new Thread("haha"){
         @Override
         public void run() {
             while (!(Thread.currentThread().isInterrupted())){
             //Thread.currentThread()是用来获取当前线程的引用就相当于类里面的
             //关键字this差不， isInterrupted()用来判断进程是否中断
                  System.out.println("haha");


                 }


             }
         };
     a.start();
        try {
            Thread.sleep(5);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        a.interrupt();//让进程中断使isInterrupted()的返回值改变乘thrue

     };




    }

运行结果：

3.等待一个进程-join();

public class t {
    public static boolean Q = true;
    public static void main(String[] args) {
     Thread a = new Thread("haha"){
         @Override
         public void run() {
             for(int i = 100000000;i>=0;i--){
                 System.out.println("hello");
                 try {
                     Thread.sleep(10);
                 } catch (InterruptedException e) {
                     e.printStackTrace();
                 }


             }

             }
         };
     Thread a2 = new Thread(()->{
         for(int i = 100000000;i>=0;i--){
             System.out.println("haha");
             try {
                 Thread.sleep(10);
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }


         }
     });

     a.start();
     a2.start();




    }




    }

运行结果：

可以看到线程和a1线程是交替进行的；如果在 a.start()和 a2.start(）之间加上join()会发生什么结果如下：

public class t {
    public static boolean Q = true;
    public static void main(String[] args) {
     Thread a = new Thread("haha"){
         @Override
         public void run() {
             for(int i = 100000000;i>=0;i--){
                 System.out.println("hello");
                 try {
                     Thread.sleep(10);
                 } catch (InterruptedException e) {
                     e.printStackTrace();
                 }


             }

             }
         };
     Thread a2 = new Thread(()->{
         for(int i = 100000000;i>=0;i--){
             System.out.println("haha");
             try {
                 Thread.sleep(10);
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }


         }
     });

       a.start();
        try {
            a.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        a2.start();





    }




    }

运行结果：

可以发现一直是a线程在执行 ,a.join();作用就是让此线程等待线程执行完在执行此线程，如果a线程没有执行完此线程将是阻塞状态；

4.获取当前线程的引用 currentThread()

这个方法在Thread类中是静态的

所以调用的的时候直接：

5.休眠当前线程sleep();

在Thread中sleep();方法也是静态的

所以使用方法和join类似；在sleep()中传入相应的数字对应此线程就会相应的阻塞多久