多线程2（常用的方法：join、interrupt、currentThread、isAlive、setDaemon...）

常用的方法：

1、join()方法：

join()方法：执行该方法的线程进入阻塞状态，直到调用该方法的线程结束后再由阻塞状态转为就绪状态。

示例：

package venus;import java.util.Date;public class Test {public static void main(String[] args) {TimeThread timeThread = new TimeThread();//创建时间线程timeThread.start();//启动时间线程，进入就绪状态CountThread countThread = new CountThread(timeThread);//创建计数线程countThread.start();//启动计数线程，进入就绪状态}
}class CountThread extends Thread{TimeThread timeThread;public CountThread(TimeThread timeThread){this.timeThread = timeThread;}@Overridepublic void run(){for (int i=0; i<5 ; i++){System.out.println("计数###"+i);if(i == 2){try {timeThread.join();/*此处是计数线程执行该方法，所以进入阻塞状态；时间线程调用该方法，所以直到该时间线程结束后，计数线程再由阻塞状态转为就绪状态*/} catch (InterruptedException e) {e.printStackTrace();}}}}
}class TimeThread extends Thread{@Overridepublic void run(){for (int i=0; i<5 ; i++){System.out.println("计数$$$"+i+" "+new Date());}}}

结果：
计数###0
计数###1
计数###2
计数$$$0 Sun Feb 07 15:59:11 GMT+08:00 2021
计数$$$1 Sun Feb 07 15:59:11 GMT+08:00 2021
计数$$$2 Sun Feb 07 15:59:11 GMT+08:00 2021
计数$$$3 Sun Feb 07 15:59:11 GMT+08:00 2021
计数$$$4 Sun Feb 07 15:59:11 GMT+08:00 2021
计数###3
计数###4

👆 上例中，在TimeThread类中的run()方法里加System.out.println("计数$$$"+i+" "+new Date());后面的new Date()是为了让其负担更重，延后执行，能,没有别的意思。

👆 当计数线程执行到i = 2时，由于执行了join()方法，所以进入阻塞状态，让调用join()方法的时间线程执行结束后，才由阻塞状态进入就绪状态准备执行。

2、interrupt()方法：

interrupt()方法：结束线程在调用Object类的wait()方法或该类的join()方法、sleep()方法过程中的阻塞状态，并在调用wait()、join()和sleep()方法处产生InterruptedException异常。

示例：

package venus;import java.util.Date;public class Test {public static void main(String[] args) {TimeThread timeThread = new TimeThread();timeThread.start();CountThread countThread =new CountThread(timeThread);countThread.start();try {Thread.sleep(15000);//15秒} catch (InterruptedException e) {e.printStackTrace();}//计数线程调用`interrupt()`方法countThread.interrupt();}
}class CountThread extends Thread{TimeThread timeThread;public CountThread(TimeThread timeThread){this.timeThread = timeThread;}@Overridepublic void run(){for (int i=0; i<3 ; i++){if (i == 1){try {timeThread.join();} catch (InterruptedException e) {System.out.println("计数线程提前结束阻塞状态");}}System.out.println("计数线程："+i);}}
}
class TimeThread extends Thread{@Overridepublic void run(){for (int i=0; i<3; i++){System.out.println("时间线程："+new Date());try {sleep(10000);//10秒} catch (InterruptedException e) {e.printStackTrace();}}}
}

结果：
计数线程：0
时间线程：Sun Feb 07 16:47:46 GMT+08:00 2021
时间线程：Sun Feb 07 16:47:56 GMT+08:00 2021
计数线程提前结束阻塞状态
计数线程：1
计数线程：2
时间线程：Sun Feb 07 16:48:06 GMT+08:00 2021

👆 我们由上面的join()方法可知计数线程执行join()方法，进入阻塞状态，应该等到调用join()方法的时间线程执行结束后才转入就绪状态准备执行，但由于15秒过后，计数线程调用了interrupt()方法，所以其阻塞状态被迫终止，直接进入就绪状态。

3、currentThread()方法：

currentThread()方法：返回当前正在执行的线程对象。（也就是说 哪个线程执行了该方法，就是那个线程对象）

下面我们来看四个面试题(稍微改动了一下，便于观察)，深入了解一下：

示例1：

package venus;public class Test {public static void main(String[] args) {Thread thread = new TimeThread();//创建时间线程对象System.err.println(thread);thread.start();//启动时间线程，进入就绪状态}
}class TimeThread extends Thread{public TimeThread(){super("时间线程");//意思就是给要创建的线程起个名字}@Overridepublic void run() {Thread thread = Thread.currentThread();System.out.println(thread);}
}

👆 答案：

👆 分析：
       （上面的System.err.println(thread);把out改为err仅仅为了让结果显示的颜色不一样，便于观察分析，没有别的意思。）我们可以看到Test类中 是TimeThread类创建的对象，所以变量thread指代时间线程毫无疑问。下面的run()方法里的currentThread()方法是由TimeThread类创建的时间线程执行的，所以此时的变量thread指代时间线程。

拓展：

上述结果：Thread[时间线程,5,main]第一个参数是线程名，第二个参数是线程优先级，第三个参数是线程组名

示例2：

package venus;import java.text.SimpleDateFormat;
import java.util.Date;public class Test {public static void main(String[] args) {new TimeThread().start();//创建时间线程并启动}
}class TimeThread extends Thread{public TimeThread(){super("时间线程");}@Overridepublic void run() {printTime();}public void printTime(){Thread thread = Thread.currentThread();String time = new SimpleDateFormat("HH:mm:ss").format(new Date());System.out.println(thread.getName()+"，当前时间："+time);}
}

👆 答案：

👆 分析：
       上面是TimeThread类创建的时间线程执行了currentThread()方法，所以结果就是时间线程。


示例3：

package venus;public class Test {public static void main(String[] args) {TimeThread timeThread = new TimeThread();//创建时间线程System.err.println("########"+timeThread);timeThread.start();//启动时间线程，进入就绪状态timeThread.run();}
}class TimeThread extends Thread{public TimeThread(){super("时间线程");}@Overridepublic void run() {Thread thread = Thread.currentThread();System.out.println("@@@@@@@@"+thread);}
}

答案：

分析：
       刚开始是由TimeThread类创建的时间线程，所以刚开始变量thread指代时间线程；
       接着启动时间线程，但主程序里timeThread.run()执行run()方法，也就是此时是主线程执行了currentThread()方法，所以此时的变量thread指代主线程；
       进入就绪状态的时间线程开始执行run()方法，也就执行了currentThread()方法，所以此时的变量thread指代时间线程。

示例4：

package venus;public class Test {public static void main(String[] args) {TimeThread timeThread = new TimeThread();//创建时间线程System.err.println("########"+timeThread);timeThread.start();//启动时间线程timeThread.main();}
}class TimeThread extends Thread{public TimeThread(){super("时间线程");}@Overridepublic void run() {main();}void main(){Thread thread = Thread.currentThread();System.out.println("@@@@@@@@"+thread);}
}

答案：

分析：
       刚开始是由TimeThread类创建的时间线程，所以刚开始变量thread指代时间线程；
       接着启动时间线程，但主程序里timeThread.main()执行main()方法，也就是此时是主线程执行了currentThread()方法，所以此时的变量thread指代主线程；
       进入就绪状态的时间线程开始执行run()方法，也就执行了currentThread()方法，所以此时的变量thread指代时间线程。

4、isAlive()方法：

isAlive()方法：判定该线程是否处于就绪、运行或阻塞状态，如果是则返回true，否则返回false。

示例：

package venus;public class Test {public static void main(String[] args) {Thread thread = Thread.currentThread();new PrintThread(thread).start();//创建打印线程并启动System.out.println("main线程状态："+thread.isAlive());}
}class PrintThread extends Thread{private Thread thread;public PrintThread(Thread thread){this.thread = thread;}@Overridepublic void run() {try {sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}System.err.println("main线程状态："+thread.isAlive());}
}

结果：

分析：
       当打印线程受到sleep(1000)阻塞时，程序一定会先执行main()方法中的输出语句，此时会输出true；
       当打印线程阻塞状态结束，此时的主线程肯定已经结束了，所以主线程此时已经死了，所以输出false。

5、setDaemon()方法：

setDaemon()方法：用于将一个尚未调用线程start()方法的线程设置为守护线程。

• 守护线程会随着最后一个非守护线程的终止而终止；
• 进程中所启动的其他非守护线程不会随着某一个非守护线程的结束而结束；
• 进程随着最后一个非守护线程的结束而结束。

(非守护线程 也叫 时间线程)

示例：

package venus;public class Test {public static void main(String[] args) {CountThread countThread = new CountThread();countThread.setDaemon(true);//此时设置计数线程为守护线程countThread.start();try {Thread.sleep(10);//延长主线程的存活时间} catch (InterruptedException e) {e.printStackTrace();}}
}class CountThread extends Thread{@Overridepublic void run() {int i=0;while (true){System.out.println("计数："+i);i++;}}}

结果：

分析：
       我们发现当设置计数线程为守护线程时，启动后就会执行下去，当主线程（非守护线程）结束时才会结束。

5、其它方法：

• void start()：使该线程开始启动，Java虚拟机负责调用该线程的run()方法。多次启动一个线程是非法的。

• void sleep(long millis)：Thread类静态方法，线程进入阻塞状态，在指定时间（单位为毫秒）到达之后进入就绪状态，而非立即进入执行状态。

• void yield()：静态方法，当前线程放弃占用CPU资源，回到就绪状态（即从Running → Runnable），使其它优先级不低于此线程的线程有机会被执行。（该方法不是很可靠，因为它只是把正在执行的线程拉回到就绪状态，但就绪状态的线程采取的是抢占式）

• void setPriority(int newPriority)：设置当前线程的优先级，线程优先级越高，线程获得执行的次数越多，Java线程的优先级用整数表示，取值范围是 1 ~ 10，Thread类有以下三个静态常量：
  1、static int MAX_PRIORITY 最高优先级值为10；
  2、static int NORM_PRIORITY 默认优先级值为5；
  3、static int MIN_PRIORITY 最低优先级值为1.

注意：
       同一个线程类创建的多个线程，线程优先级越高的线程执行次数极有可能越多；但是不同线程类创建的线程，线程优先级越高，执行次数不一定越高，这与run()方法的代码复杂度有关。

• int getPriority()：获得当前线程的优先级