学习JavaEE的日子 Day29 yield，join，线程的中断，守护线程，线程局部变量共享，线程生命周期

Day29

多线程

12. 线程的礼让

Thread.yield();

理解：此方法为静态方法，此方法写在哪个线程中，哪个线程就礼让

注意：所谓的礼让是指当前线程退出CPU资源，并转到就绪状态，接着再抢

需求：创建两个线程A,B，分别各打印1-100的数字，其中B一个线程，每打印一次，就礼让一次，观察实验结果

public class Test01 {public static void main(String[] args) {A a = new A();B b = new B();a.start();b.start();}
}

public class A extends Thread{@Overridepublic void run() {for (int i = 1; i <= 100; i++) {System.out.println("A：" + i);}}
}

public class B extends Thread{@Overridepublic void run() {for (int i = 1; i <= 100; i++) {System.out.println("B：" + i);//礼让：让当前线程退出CPU资源，当前线程退出后立刻转入抢资源的状态，可能又会抢到CPU资源Thread.yield();}}
}

13. 线程的合并

t.join(); 合并方法

需求：主线程和子线程各打印200次，从1开始每次增加1，当主线程打印到10之后，让子线程先打印完再打印主线程

public class Test01 {public static void main(String[] args) throws InterruptedException {MyThread t = new MyThread();t.start();for (int i = 1; i <=200; i++) {System.out.println("主线程：" + i);if(i == 10){//让t线程加入到当前线程t.join();}}}
}

public class MyThread extends Thread{@Overridepublic void run() {for (int i = 1; i <=200; i++) {System.out.println("子线程：" + i);}}
}

14.线程的中断

14.1 线程的中断1

面试题：下列代码的子线程开启后，是否会在3000毫秒就被销毁？
答：不一定，因为3000毫秒后主线程才休眠结束，这时会抢CPU资源
如果立刻抢到，那么子线程就是3000毫秒后销毁
如果没有抢到CPU资源，那么子线程会继续运行，直到主线程抢到CPU资源

public class Test01 {public static void main(String[] args) throws InterruptedException {MyThread t = new MyThread();//子线程t.start();//主线程休眠3秒(Main方法就是主线程)Thread.sleep(3000);//过时了t.stop();//立刻停止（缺点：可能会导致功能缺失）	}}

public class MyThread extends Thread{@Overridepublic void run() {while(true){ //死循环System.out.println("111");System.out.println("222");System.out.println("333");System.out.println("444");}}
}

14.2 线程的中断2

另外一种写法：

该方法一定会执行到444结束，不像上面一种立马停止，可能在222或者333结束

public class Test01 {public static void main(String[] args) throws InterruptedException {MyThread t = new MyThread();t.start();Thread.sleep(3000);t.setFlag(false);}}

public class MyThread extends Thread{private boolean flag = true;public void setFlag(boolean flag) {this.flag = flag;}@Overridepublic void run() {while(flag){System.out.println("111");System.out.println("222");System.out.println("333");System.out.println("444");}}
}

14.3 线程的中断3

public class Test01 {public static void main(String[] args) throws InterruptedException {MyThread t = new MyThread();t.start();Thread.sleep(3000);//改变线程状态t.interrupt();}}

public class MyThread extends Thread{@Overridepublic void run() {//获取线程状态（是否消亡）
//		System.out.println(Thread.currentThread().isInterrupted());while(!Thread.currentThread().isInterrupted()){System.out.println("111");System.out.println("222");System.out.println("333");System.out.println("444");}}
}

15.守护线程/后台线程

守护线程默默守护着前台线程，当所有的前台线程都消亡后，守护线程会自动消亡

注意：垃圾回收器就是守护线程

t.setDaemon(true);

public class Test01 {public static void main(String[] args) throws InterruptedException {MyThread t = new MyThread();t.setDaemon(true);//将当前线程设置为守护线程t.start();for (int i = 1; i <= 5; i++) {System.out.println("主线程：" + i);Thread.sleep(1000);}}
}

public class MyThread extends Thread{@Overridepublic void run() {while(true){System.out.println("后台线程默默守护着前台线程");try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}}}
}

十六、线程局部变量（实现线程范围内的共享变量）-- ThreadLocal

16.1 共享单个数据

public class Test01 {public static final ConcurrentHashMap<Thread, Integer> map = new ConcurrentHashMap<>();public static void main(String[] args) {new Thread(new Runnable() {@Overridepublic void run() {int i = 10;//存数据map.put(Thread.currentThread(), i);A a = new A();B b = new B();a.println();//10b.println();//10}},"线程1").start();new Thread(new Runnable() {@Overridepublic void run() {int i = 20;//存数据map.put(Thread.currentThread(), i);A a = new A();B b = new B();a.println();//20b.println();//20}}, "线程2").start();}
}

public class A {public void println(){Thread t = Thread.currentThread();Integer value = Test01.map.get(t);System.out.println(t.getName() + "里的A类对象获取了数据：" + value);}
}

public class B {public void println(){Thread t = Thread.currentThread();Integer value = Test01.map.get(t);System.out.println(t.getName() + "里的B类对象获取了数据：" + value);}
}

16.2 共享多个数据-- ThreadLocal

存数据
local.set(data)底层原理：
1.获取当前线程对象
2.通过当前线程对象获取ThreadLocalMap<ThreadLocal,T>
3.map.put(this,t) * 获取数据

local.get()底层原理：
1.获取当前线程对象
2.通过当前线程对象获取ThreadLocalMap<ThreadLocal,T>
3.map.getEntry(this) -> Entry对象
4.entry.getValue()

public class Test01 {public static final ThreadLocal<Data> local = new ThreadLocal<>();public static void main(String[] args) {new Thread(new Runnable() {@Overridepublic void run() {Data data = Data.getInstance(10,"xxx");/*** 存数据* local.set(data)底层原理：* 		1.获取当前线程对象* 		2.通过当前线程对象获取ThreadLocalMap<ThreadLocal,T>* 		3.map.put(this,t)*/local.set(data);A a = new A();B b = new B();a.println();//10b.println();//10}},"线程1").start();new Thread(new Runnable() {@Overridepublic void run() {Data data = Data.getInstance(20,"yyy");data = Data.getInstance(30,"zzz");//存数据local.set(data);A a = new A();B b = new B();a.println();//20b.println();//20}}, "线程2").start();}
}

数据包类

//数据包类
public class Data {private int i;private String str;//有参构造，无参构造，get，set方法省略//保证每个线程里只有一个Data包对象public static Data getInstance(int i,String str){Data data = Test01.local.get();//获取当前线程的Data对象if(data == null){data = new Data(i, str);Test01.local.set(data);}else{data.setI(i);data.setStr(str);}return data;}@Overridepublic String toString() {return "Data [i=" + i + ", str=" + str + "]";}
}

public class A {public void println(){Thread t = Thread.currentThread();/*** 获取数据* local.get()底层原理：* 		1.获取当前线程对象* 		2.通过当前线程对象获取ThreadLocalMap<ThreadLocal,T>* 		3.map.getEntry(this) -> Entry对象* 		4.entry.getValue()*/Data value = Test01.local.get();System.out.println(t.getName() + "里的A类对象获取了数据：" + value);}
}

public class B {public void println(){Thread t = Thread.currentThread();Data value = Test01.local.get();System.out.println(t.getName() + "里的B类对象获取了数据：" + value);}
}

17.线程的生命周期

1、新建状态

i. 在程序中用构造方法创建了一个线程对象后，新的线程对象便处于新建状态，此时，它已经有了相应的内存空间和其它资源，但还处于不可运行状态。新建一个线程对象可采用线程构造方法来实现。

ii. 例如：Thread thread=new Thread();

2、就绪状态

i. 新建线程对象后，调用该线程的start()方法就可以启动线程。当线程启动时，线程进入就绪状态。此时，线程将进入线程队列排队，等待CPU调用，这表明它已经具备了运行条件。

3、运行状态

i. 当就绪状态的线程被调用并获得处理器资源时，线程就进入了运行状态。此时，自动调用该线程对象的run()方法。run()方法定义了该线程的操作和功能。

4、阻塞状态

i. 一个正在执行的线程在某些特殊情况下，如被人为挂起，将让出CPU并暂时中止自己的执行，进入阻塞状态。在可执行状态下，如果调用sleep(2000)、wait()等方法，线程都将进入阻塞状态。阻塞时，线程不能进入排队队列，只有当引起阻塞的原因被消除后，线程才可以转入就绪状态。

5、死亡状态

i. 线程调用stop()方法时或run()方法执行结束后，线程即处于死亡状态。处于死亡状态的线程不具有继续运行的能力。

在这里插入图片描述

总结

1.线程的礼让 – yield

2.线程的合并 – join

3.线程的中断

4.守护线程

5.线程局部变量共享 – 重要

用，这表明它已经具备了运行条件。

3、运行状态

i. 当就绪状态的线程被调用并获得处理器资源时，线程就进入了运行状态。此时，自动调用该线程对象的run()方法。run()方法定义了该线程的操作和功能。

4、阻塞状态

i. 一个正在执行的线程在某些特殊情况下，如被人为挂起，将让出CPU并暂时中止自己的执行，进入阻塞状态。在可执行状态下，如果调用sleep(2000)、wait()等方法，线程都将进入阻塞状态。阻塞时，线程不能进入排队队列，只有当引起阻塞的原因被消除后，线程才可以转入就绪状态。

5、死亡状态

i. 线程调用stop()方法时或run()方法执行结束后，线程即处于死亡状态。处于死亡状态的线程不具有继续运行的能力。

在这里插入图片描述

简答题

1.Thread类中的yield方法有什么作用？

Yield方法可以暂停当前正在执行的线程对象，让其它有相同优先级的线程执行。它是一个静态方法而且

只保证当前线程放弃CPU占用而不能保证使其它线程一定能占用CPU，执行yield()的线程有可能在进入

到暂停状态后马上又被执行。

2.sleep()和wait() 有什么区别？

对于sleep()方法，我们首先要知道该方法是属于Thread类中的。而wait()方法，则是属于Object类中的。

sleep()方法导致了程序暂停执行指定的时间，让出cpu该其他线程，但是他的监控状态依然保持着，当指定的时间到了又会自动恢复运行状态。在调用sleep()方法的过程中，线程不会释放对象锁。

当调用wait()方法的时候，线程会放弃对象锁，进入等待此对象的等待锁定池，只有针对此对象调用 notify()方法后本线程才进入对象锁定池准备，获取对象锁进入运行状态。

3.有三个线程T1,T2,T3,如何保证顺序执行？

在多线程中有多种方法让线程按特定顺序执行，你可以用线程类的join()方法在一个线程中启动另一个线程，另外一个线程完成该线程继续执行。为了确保三个线程的顺序你应该先启动最后一个(T3调用 T2，T2调用T1)，这样T1就会先完成而T3最后完成。实际上先启动三个线程中哪一个都行，因为在每个线程的run方法中用join方法限定了三个线程的执行顺序。

public class JoinTest2 {// 1.现在有T1、T2、T3三个线程，你怎样保证T2在T1执行完后执行，T3在T2执行完后执行public static void main(String[] args) {final Thread t1 = new Thread(new Runnable() {@Overridepublic void run() {System.out.println("t1");}});final Thread t2 = new Thread(new Runnable() {@Overridepublic void run() {try {// 引用t1线程，等待t1线程执行完t1.join();} catch (InterruptedException e) {e.printStackTrace();}System.out.println("t2");}});Thread t3 = new Thread(new Runnable() {@Overridepublic void run() {try {// 引用t2线程，等待t2线程执行完t2.join();} catch (InterruptedException e) {e.printStackTrace();}System.out.println("t3");}});t3.start();//这里三个线程的启动顺序可以任意，大家可以试下！t2.start();t1.start();}
}

简答题

如何停止一个正在运行的线程

1、使用退出标志，使线程正常退出，也就是当run方法完成后线程终止。

2、使用stop方法强行终止，但是不推荐这个方法，因为stop和suspend一样都是过期作废的方法。

3、使用interrupt方法中断线程。

class MyThread extends Thread {
volatile boolean stop = false;
public void run() {
while (!stop) {
System.out.println(getName() + " is running");
try {
sleep(1000);
} catch (InterruptedException e) {
System.out.println("week up from blcok...");
stop = true; // 在异常处理代码中修改共享变量的状态
}
}
System.out.println(getName() + " is exiting...");
}
}
class InterruptThreadDemo3 {
public static void main(String[] args) throws InterruptedException {
MyThread m1 = new MyThread();
System.out.println("Starting thread...");
m1.start();
Thread.sleep(3000);
System.out.println("Interrupt thread...: " + m1.getName());
m1.stop = true; // 设置共享变量为true
m1.interrupt(); // 阻塞时退出阻塞状态
Thread.sleep(3000); // 主线程休眠3秒以便观察线程m1的中断情况
System.out.println("Stopping application...");
}
}