廖雪峰Java11多线程编程-1线程的概念-3线程的状态

1线程的状态

线程终止的的原因： * run()或call()方法执行完成，线程正常结束 * 线程抛出一个未捕获的Exception或Error * 直接调用该线程的stop()方法来结束该线程——该方法容易导致死锁，通常不推荐使用

1.1对已经死亡的线程调用start()方法使他重新启动，会引发IllegalThreadStateException

class MyThread extends Thread{
    public void run(){
        System.out.println("子线程");
    }
}
public class StartDead {
    public static void main(String[] args) throws InterruptedException{
        Thread t = new MyThread();
        t.start();
        while(t.isAlive()){
            Thread.sleep(200);
        }
        System.out.println(t.isAlive());
        t.start();
    }
}

2 控制线程

2.1 join线程

Thread提供了让一个线程等待另一个线程完成的方法——join()方法。

• join()：等待该线程执行结束，再向下执行
• join(long mills)：等待被join的线程mills毫秒，超时不再等待
• join(long mills, int nanos)：等待最长时间为mills毫秒+nanos毫微秒，很少用

class MyThread extends Thread{
    String name;
    public MyThread(String name){
        this.name = name;
    }
    @Override
    public void run(){
        System.out.println("Hello, "+name+"!");
        try{
            Thread.sleep(2000);
        }catch (InterruptedException ex){
            ex.printStackTrace();
        }finally {
            System.out.println("Bye,"+name+"!");
        }
    }
}
public class StartDead {
    public static void main(String[] args) throws InterruptedException{
        Thread t1 = new MyThread("Bob");
        System.out.println("start");
        t1.start();
        t1.join(1000,10);
        System.out.println("end");
    }
}

2.2后台线程

Java的程序入口就是JVM启动main线程，main线程又可以启动其他线程。当所有的线程都运行结束时，JVM退出。
有一种线程是无限循环，如定时任务。如果这种线程不结束，JVM就不能退出。
问题：由谁来结束这些线程？
有一种线程，他是在后台运行的，它的任务是为其他的线程提供服务，这种线程被成为“后台线程（Daemon Thread）”，又称为“守护线程”或“精灵线程”。JVM的垃圾回收线程就是典型的后台线程。
总之：

• 守护线程为其他线程服务的线程
• 所有非守护线程都执行关闭后，虚拟机退出

特征：

• 如果所有的前台线程都死亡，后台线程会自动死亡。
• 不能持有资源（如打开文件等）当虚拟机退出时，守护线程没有任何机会关闭文件，会导致数据丢失。

创建守护线程：调用Thread的对象的setDaemon(true)方法可以将指定线程设置为后台线程。

public class DaemonThread extends Thread{
    public void run(){
        while(true){
            System.out.println(LocalDateTime.now().format(DateTimeFormatter.ofPattern("HH:mm:ss")));
            try{
                Thread.sleep(1000);
            }catch (InterruptedException e){
                break;
            }

        }
    }
    public static void main(String[] args) throws InterruptedException{
        System.out.println("Main start");
        DaemonThread t = new DaemonThread();
        t.setDaemon(true);
        t.start();
        Thread.sleep(5000);
        System.out.println("Main end");
    }
}

package com.csj2018.lxf;

import org.junit.Ignore;
import org.junit.Test;

class DaemonThread extends Thread{
	public void run() {
		for(int i=0;i<1000;i++) {
			System.out.println(Thread.currentThread().getName()+"	"+i);
			try {
				Thread.sleep(1000);
			}catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
}

public class ThreadTest2{
	@Test
	public void test() {
		Thread t = new DaemonThread();
		t.setDaemon(true);//setDaemon(true)必须在start()方法之前调用，否则会引发IllegalThreadStatsException
		t.start();
		for(int i=0;i<3;i++) {
			System.out.println(Thread.currentThread().getName()+"	"+i);
			try {
				Thread.sleep(1000);
			}catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
}

2.3线程睡眠

如果需要让正在执行的线程暂停一段时间，并进入阻塞状态，可以调用Thread类的静态方法sleep实现。当前线程调用sleep进入阻塞状态后，在其睡眠时间内，该线程不会获得执行的机会，即使系统中没有其他可执行的线程，处于sleep中的线程，依然不会执行。因此sleep常用于程序的执行。

• static void sleep(long mills)：让当前正在执行的线程暂停mills毫秒，并进入阻塞状态
• static void sleep(long mills, int nanos)：让当前正在执行的线程暂停mills毫秒+nanos毫微秒，并进入阻塞状态，第二种很少用

import java.util.Date;

public class SleepTest extends Thread {
    public static void main(String[] args) throws InterruptedException{
        for(int i=0;i<10;i++){
            System.out.println("当前时间："+new Date());
            Thread.sleep(1000);
        }
    }
}

### 2.4线程让步: yield yield让当前正在执行的线程暂停，但不会阻塞该线程，它只是将该线程转入就绪状态。yield()只是让当前线程暂停一下，让系统的线程调度器重新调度一次，完全可能的情况：某个线程调用yield方法暂停后，线程调度器又将其调度出来重新执行。 当某个线程用了yield方法暂停之后，只有优先级与当前线程相同，或者优先级比当前线程更高处于就绪状态的线程才会获得执行的机会。 ```#java public class YieldTest extends Thread{ public YieldTest(String name){ super(name); } public void run(){ for(int i=0;i<10;i++){ System.out.println(Thread.currentThread().getName()+" "+i); if(i==5){ Thread.yield(); } } } public static void main(String[] args) throws InterruptedException{ YieldTest yt1 = new YieldTest("高级"); yt1.setPriority(Thread.MAX_PRIORITY); yt1.start();

    YieldTest yt2 = new YieldTest("低级");
    yt2.setPriority(MIN_PRIORITY);
    yt2.start();
}

}

<img src="https://img2018.cnblogs.com/blog/1418970/201906/1418970-20190609175309658-2035292882.png" width="370" />
sleep和yield的区别：
*    sleep暂停当前线程后，会给其他线程执行机会，不会理会其他线程的优先级；但yield只会给优先级相同或更高的线程执行机会
*    sleep将线程转入阻塞状态；yield将线程转入就绪状态
*    sleep抛出InterruptedException异常；yield不会
*    sleep比yield有更好的移植性

##    3总结：
*    Java线程对象Thread的状态包括：New/Runnable/Blocked/Waiting/Timed Waiting/Terminated
*    通过对另一个线程对象调用join()方法可以等待其执行结束
*    可以指定等待时间，超过等待时间线程仍然没有结束就不再等待
*    对已经运行结束的线程调用join()方法会立刻返回
*    守护线程是为其他线程服务的线程
*    所有非守护线程都执行完毕后，虚拟机退出
*    守护线程不能持有资源（如打开文件等）