1. 基本说明 587
1.当线程完成任务后，会自动退出。
2.还可以通过使用变量来控制run方法退出的方式停止线程，即通知方式
2. 应用案例 587
需求:启动一个线程t,要求在main线程中去停止线程t,请编程实现.
代码在com.stulzl.exit_.包中
ThreadExit_
package com.stulzl.exit_;
//线程终止案例 587
public class ThreadExit_ {
public static void main(String[] args) throws InterruptedException {
T t1 = new T();
t1.start();
//如果希望main线程去控制t1 线程的终止, 必须可以修改 loop
//让t1 退出run方法，从而终止 t1线程 -> 称为 通知方式
//让主线程休眠 10 秒，再通知 t1线程退出
System.out.println("main线程休眠10秒");
Thread.sleep(10*1000);//这里抛出异常，懒得捕获了
t1.setLoop(false);
}
}
class T extends Thread{
private int count = 0;
//设置一个变量
private boolean loop = true;
@Override
public void run() {
while(loop){
try {
Thread.sleep(50);// 让当前线程休眠50ms
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("T 运行中...." +(++count));
}
}
public void setLoop(boolean loop) {
this.loop = loop;
}
}3. 线程常用方法 588
3.1 常用方法第一组
1. setName //设置线程名称，使之与参数name相同
2. getName //返回该线程的名称
3. start //使该线程开始执行; Java虚拟机底层调用该线程的 startO方法
4. run //调用线程对象run方法;
5. setPriority //更改线程的优先级
6. getPriority //获取线程的优先级
7. sleep //在指定的毫秒数内让当前正在执行的线程休眠(暂停执行)
8. interrupt //中断线程
3.2 注意事项和细节
1. start 底层会创建新的线程，调用run, run 就是一个简单的方法调用，不会启动新线程
2.线程优先级的范围
3. interrupt,中断线程，但并没有真正的结束线程。所以一般用于中断正在休眠线程
4. sleep:线程的静态方法，使当前线程休眠
3.3 案例演示 588
代码在com.stulzl.thread_method01.包中
ThreadMethod01
package com.stulzl.thread_method01;
//线程常用方法注意细节01 588
//1. setName //设置线程名称，使之与参数name相同
//2. getName //返回该线程的名称
//3. start //使该线程开始执行; Java虚拟机底层调用该线程的 startO方法
//4. run //调用线程对象run方法;
//5. setPriority //更改线程的优先级
//6. getPriority //获取线程的优先级
//7. sleep //在指定的毫秒数内让当前正在执行的线程休眠(暂停执行)
//8. interrupt //中断线程
public class ThreadMethod01 {
public static void main(String[] args) throws InterruptedException {
//测试相关方法
T t = new T();
t.setName("旺财");//设置线程名称
t.setPriority(Thread.MIN_PRIORITY);//更改线程的优先级//将线程优先级设置为最低
t.start();//启动子线程
//主线程打印5 hi ,然后我就中断 子线程的休眠
for (int i = 0; i <5; i++) {
Thread.sleep(1000);
System.out.println("hi "+i);
}
System.out.println(t.getName() + " 线程的优先级 =" + t.getPriority());//1//获取线程的优先级
t.interrupt();//中断线程 //当执行到这里，就会中断 t线程的休眠.
}
}
class T extends Thread { //自定义的线程类
@Override
public void run() {
while (true) {
for (int i = 0; i < 100; i++) {
//Thread.currentThread().getName() 获取当前线程的名称
System.out.println(Thread.currentThread().getName() + " 吃包子~~~~" + i);
}
try {
System.out.println(Thread.currentThread().getName() + " 休眠中~~~");
Thread.sleep(20000);//20秒
} catch (InterruptedException e) {
//当该线程执行到一个interrupt 方法时，就会catch 一个 异常, 可以加入自己的业务代码
//InterruptedException 是捕获到一个中断异常.
System.out.println(Thread.currentThread().getName() + "被 interrupt了");
}
}
}
}4. 常用方法第二组 589
1. 。让出cpu,让其他线程执行，但礼让的时间不确定，所以也不一定礼让成功
2. join:线程的插队。插队的线程旦插队成功， 则肯定先执行完插入的线程所有的任务
4.1 yield:线程的礼让和 join:线程的插队案例 589
main线程创建一个子线程 ,每隔1s输出,输出20次，主线程每隔1秒，输出，输出20次,要求:两个线程同时执行，当主线程输出5次后，就让子线程运行完毕，主线程再继续
代码在com.stulzl.thread_method02.包中
ThreadMethod02
package com.stulzl.thread_method02;
// yield:线程的礼让和 join:线程的插队案例 589
public class ThreadMethod02 {
public static void main(String[] args) throws InterruptedException {
T2 t2 = new T2();
t2.start();
for (int i = 1; i <=20; i++) {
Thread.sleep(1000);
System.out.println("主线程(小弟) 吃了"+i+" 包子");
if(i==5){
System.out.println("主线程(小弟) 让 子线程(老大) 先吃");
//join, 线程插队
//t2.join();// 这里相当于让t2 线程先执行完毕
//yield:线程的礼让
Thread.yield();//礼让，不一定成功..,因为cpu资源很充足，只有cpu资源紧缺时才可能成功
System.out.println("线程(老大) 吃完了 主线程(小弟) 接着吃..");
}
}
}
}
class T2 extends Thread {
@Override
public void run() {
for (int i = 1; i <= 20; i++) {
try {
Thread.sleep(1000);//休眠1秒
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("子线程(老大) 吃了 " + i + " 包子");
}
}
}5. 线程常用方法练习 590
1.主线程每隔1s,输出hi,一共10次
2.当输出到hi 5时，启动一个子线程(要求实现Runnable),每隔1s输出hello,等该线程输出10次hello后,退出
3.主线程继续输出hi,直到主线程退出，
4.如图，完成代码其实线程插队..
代码在com.stulzl.thread_method_exercise01.包中
Thread_Method_Exercise01
package com.stulzl.thread_method_exercise01;
//1.主线程每隔1s,输出hi,一共10次 590
//2.当输出到hi 5时，启动一个子线程(要求实现Runnable),每隔1s输出hello,等该线程输出10次hello后,退出
//3.主线程继续输出hi,直到主线程退出，
//4.如图，完成代码其实线程插队..
public class Thread_Method_Exercise01 {
public static void main(String[] args) throws InterruptedException {
T t = new T();
Thread thread = new Thread(t);//创建子线程
for (int i = 1; i <= 10; i++) {
System.out.println("hi "+i);
Thread.sleep(1000);//输出一次hi让主线程休眠1秒
if(i==5){//说明主线程输出了 5 次 hi
thread.start();//启动子线程输出hello
thread.join();//让子线程插队
}
}
}
}
class T implements Runnable{
@Override
public void run() {
for (int i = 1; i <= 10; i++) {
System.out.println("hello "+i);
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
