Java多线程-线程状态及基本方法的使用

线程状态：

线程状态观测：

Thread.State state=thread.getState();//获得某个线程的状态
System.out.println(state);//输出该线程的状态

        可以观测到的状态有：

                NEW：尚未启动的线程。

                RUNNABLE：在Java虚拟机中执行的线程。

                BLOCKED：被阻塞等待监视器锁定的线程。

                WAITING：正在等待另一个线程执行特定动作的线程。

                TIEMD_WAITING：正在等待另一个线程执行动作到达指定等待时间的线程。

                TERMINATED：已经退出的线程。

线程方法：

setPriority(int newPriority);//更改线程优先级
static void sleep(long millis);//在指定的毫秒数内让当前正在执行的线程休眠，不会释放锁
void join();//等待该线程执行完毕后，再执行其他线程
static void yield();//暂停当前正在执行的线程对象，并执行其他线程。自 Java 14 起的版本中不支持对 'yield' 方法进行非限定调用。
void interrupt();//中断线程，尽量不用这个方式
boolean isAlive();//测试线程是否处于活跃状态

//以下方法只能在同步方法或者同步代码块中使用，否则会抛出异常IIIegalMonitorStateException
//线程通信会用到
void wait();//表示线程一值等待，知道其他线程通知，域sleep不同，会释放锁
void wait(long timeout);//指定等待的毫秒数
void notify();//唤醒一个等待状态的线程
void notifyAll();//唤醒同一个对象上所有调用wait()方法的线程，优先级高的先唤醒

         1:线程停止：

                例子：

//1:建议线程正常停止-->利用次数，不建议死循环
//2:建议使用标志位-->设置一个标志位
//3:不建议使用JDK内的stop，destroy，interrupt
public class TestThread4 implements Runnable {
    public static void main(String[] args) {
        TestThread4 testThread4=new TestThread4();

        new Thread(testThread4).start();

        for (int i = 0; i < 100; i++) {
            System.out.println("main"+i);
            if(i==50){
                //用stop方法切换标志位，让线程停止
                testThread4.stop();
                System.out.println("线程停止了");
            }
        }
    }

    //1:设置一个标志位
    private boolean flag=true;

    @Override
    public void run() {
        int i=0;
        while(flag){
            System.out.println("run....Thread"+i++);
        }
    }

    //2:设置一个公开的方法停止线程，转换标志位
    public void stop(){
        this.flag=false;
    }

}

        2：线程休眠sleep(每个对象都有一个锁，sleep不会释放锁)：

               例子：

public class TestThread5{

    public static void main(String[] args) {
        //打印当前系统时间
        Date startTime=new Date(System.currentTimeMillis());//获取当前时间
        while(true){
            try {
                Thread.sleep(1000);
                System.out.println(new SimpleDateFormat("HH:mm:ss").format(startTime));
                startTime=new Date(System.currentTimeMillis());//更新当前时间
            }catch (InterruptedException e){
                e.printStackTrace();
            }
        }
    }

    //模拟倒计时
    public static void Daojs() throws InterruptedException {
        int num=10;
        while(true){
            Thread.sleep(1000);
            System.out.println(num--);
            if (num<=0){
                break;
            }
        }
    }
}

        3:线程暂停yield(礼让，从运行态转为就绪态，重新等待CPU调度，所以礼让不一定成功)。

        4:合并线程join：

                join()方法：使异步执行的线程变成同步执行。使用join方法后，直到这个线程退出(执行完毕)，程序才会往下执行，可以理解位插队，少用。

public class TestThread6 implements Runnable{
    public static void main(String[] args) throws InterruptedException {
        //插队线程
        TestThread6 testThread6=new TestThread6();
        Thread thread=new Thread(testThread6);
        thread.start();

        //主线程
        for (int i = 0; i < 100; i++) {
            if(i==20){
                thread.join();//插队
            }
            System.out.println("main"+i);
        }
    }

    @Override
    public void run() {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        for (int i = 0; i < 1000; i++) {
            System.out.println("插队的来了"+i);
        }
    }
}

守护线程：

        线程可以分为：

                ①：用户线程：虚拟机必须确保用户线程执行完毕。

                ②：守护(后台)线程：虚拟机不用等待守护线程执行完毕。任务是为其他线程提供服务。JVM垃圾回收线程就是典型后台线程。后台线程有一个非常明显的特征：如果所有前台线程都死亡，它就会自动死亡。

        设置方法：

Thread.setDaemon(true);//默认为false，就是用户线程，true就是后台线程