Thread 类的基本用法

如何创建线程？

java标准库提供了一个类Thread能够表示一个线程，看下面代码我们不难看出我们都是在重写run方法。
那为什么要重写run方法呢？
因为run方法是我们线程的入口方法，在此方法中完成我们想要执行的逻辑。

 public static void main(String[] args) {
        //方法一 lambda表达式,推荐写法！
        Thread t1=new Thread(()-> {
         //执行体
        });
        //方法二 匿名内部类
        Thread t2= new Thread(new Runnable() {
            @Override
            public void run() {
                ;
            }
        });
        //方法三 继承thread重写run方法
        Thread t3=new A();
        //方法四 实现接口Runnable重写run
        B b=new B();
        Thread t4=new Thread(b);
    }
class A extends Thread{
    @Override
    public void run() {
        System.out.println("哈哈");
    }
}
class B implements Runnable{
    @Override
    public void run() {
        System.out.println("嘻嘻");
    }
}

Thread中start方法说明

start方法的功能是创建新的线程，创建好新的线程我们会执行重写的run方法去执行。

 Thread t=new Thread(()-> {
            System.out.println("XYZ");
        });
        t.start();
        System.out.println("ABC");
        

此时我们通过t.start()就又创建出一个线程，线程和线程之间是并发的，每个线程之间又是一个独立的执行流。

此时上述代码中就有两个线程：
1.main方法所对应的线程（一个进程里至少有一个线程）此线程也称为主线程。
2.通过t.start 创建出来的线程（创建出来的线程会自动调用run方法，run方法结束后会自动销毁进程）;

上述代码的结果是不确定的（可能是先输出XYZ，也可能先执行ABC），因为线程之间是并发执行的。

 public static void main(String[] args) {
        
        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("ABC");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
               e.printStackTrace();
            }
        }

    }
执行结果：
ABC
hello t
hello t
ABC
ABC
hello t
hello t
ABC

结论：我们发现两个线程是交替执行的（此处的交替不是严格意义上的交替），每一秒过后先打印谁是不确定的。

指定线程名字

在第二个参数可以定义该线程的名字

  Thread t=new Thread(()-> {
            while(true){
                System.out.println("hello t");
               
            }
        },"我是一个线程");
        t.start();

Thread基本方法

方法	功能
getId()	获取ID
getName()	获取名称
getState()	获取状态
getPriority()	优先级
isDaemon()	是否为后台线程，true后台，false前台，前台会阻止java程序必须等到线程全都结束才能结束，后台不阻止java程序，无需等到线程结束，java程序都可结束。默认都是前台线程
isAlive	是否存活，线程入口方法执行完毕，对应线程没了为false
isInterrupted	是否被中断

 public static void main(String[] args) {
        //方法一 lambda表达式
        Thread t=new Thread(()-> {

                System.out.println("hello t");


        },"我是一个线程");
        t.start();
        System.out.println(t.getId());
        System.out.println(t.getName());
        System.out.println(t.isAlive());
        System.out.println(t.isDaemon());
        t.interrupt();
        System.out.println("hello main");

    }
15
我是一个线程
true
false
hello t
hello main

start（）和run（）的区别？

作用功能不同：

run方法的作用是描述线程具体要执行的任务；
start方法的作用是真正的去申请系统线程

运行结果不同：

run方法是一个类中的普通方法，主动调用和调用普通方法一样，会顺序执行一次；
start调用方法后, start方法内部会调用Java 本地方法（封装了对系统底层的调用）真正的启动线程，并执行run方法中的代码，run 方法执行完成后线程进入销毁阶段。

中断一个线程

这里的中断就是字面意思，就是让一个线程停下来。
让一个线程终止的方法就有一个办法，那就是让线程的入口方法执行完毕。
如何让入口方法快点执行完呢？
1、给线程中设定一个结束标志位

public static boolean flag=true;
    public static void main(String[] args) {
        //方法一 lambda表达式
        Thread t=new Thread(()-> {
            while(flag) {
                System.out.println("hello t");
            }

        },"我是一个线程");
        t.start();

        System.out.println("hello main");
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        flag=false;
    }

若是将falg改为局部变量可以吗？
不可以，因为变量捕获，lamdba中允许变量捕获但是要求变量全程不能更改，若是更改不可使用；由此可见是不可以的。

2、通过interrupt，设置中断标识位。

   public static void main(String[] args) {
        //方法一 lambda表达式
        Thread t=new Thread(()-> {
           while(!Thread.currentThread().isInterrupted(){//currentThread代表引用t，isInterrupted()默认false
               System.out.println("hello t");
               try {
                   Thread.sleep(1000);
               } catch (InterruptedException e) {
                   e.printStackTrace();
               }
           }

        },"我是一个线程");
        t.start();

        System.out.println("hello main");
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
           e.printStackTrace();
        }
        t.interrupt();//设置标志位为true
    }

此时我们发现抛出异常后，仍在打印这是为什么呢？

如果想结束循环可在catch中添加break结束

等待一个线程

join方法

 public static void main(String[] args) throws InterruptedException {
        //方法一 lambda表达式
        Thread t=new Thread(()-> {
            System.out.println("ABC");

        },"我是一个线程");
        t.start();
        t.join();
        System.out.println("DEF");

    }

此时的效果就是main线程等待t先结束，他在开始执行;此时main就阻塞了，不参与cpu调度了，此时只有t去执行了

join的有参版本

 public static void main(String[] args) throws InterruptedException {
        //方法一 lambda表达式
        Thread t=new Thread(()-> {
            System.out.println("ABC");

        },"我是一个线程");
        t.start();
        t.join(3000);
        System.out.println("DEF");

    }

也就是说，你t先执行三秒后还没执行完，我不等你了，我开始执行。

线程的状态

public static void main(String[] args) throws InterruptedException {
        //方法一 lambda表达式
        Thread t=new Thread(()-> {

            System.out.println("ABC");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

        },"我是一个线程");
        System.out.println(t.getState());
        t.start();
        System.out.println(t.getState());
        Thread.sleep(500);
        System.out.println(t.getState());
        System.out.println("DEF");

        Thread.sleep(3000);

        System.out.println(t.getState());
    }
NEW
RUNNABLE
ABC
TIMED_WAITING
DEF
TERMINATED