多线程学习-基础（四）常用函数说明：sleep-join-yield
一、常用函数的使用
（1）Thread.sleep(long millis)：在指定的毫秒内让当前正在执行的线程休眠（暂停执行），休眠时不会释放当前所持有的对象的锁。
（2）join():主线程等待子线程终止后才可以终止
使用方式：
join()是Thread的一个方法，启动线程后可以直接调用，即join()的作用是：“等待该线程终止”，这里需要解释的是“该线程终止”是指主线程等待子线程的终止。
Thread t = new AThread();
t.start();
t.join();
为什么要用join()方法：
在很多情况下，主线程生成并启动了子线程，如果子线程要进行大量的耗时运算，主线程往往在子线程之前结束，但是如果主线程处理完其他事务后，需要用到子线程的处理结果，也就是说主线程需要等待子线程结束之后才可以结束，这个时候就需要用到join()方法了。
测试案例：
不加join()方法
package com.jason.comfuns.join;
/**
* 多线程学习
* @function 不使用Thread.join()方法：测试在主线程中启动子线程时：主子线程的执行顺序
* @author 小风微凉
* @time 2018-4-21 下午12:56:31
*/
public class Thread_join_Action extends Thread {
private String thname;
public Thread_join_Action(String name){
super(name);
this.thname=name;
}
public void run(){
System.out.println(Thread.currentThread().getName()+"线程运行开始！");
for(int i=0;i<5;i++){
System.out.println("子线程"+thname+"运行:"+i);
try {
sleep((int)Math.random()*10);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println(Thread.currentThread().getName()+"线程运行结束！");
}
/**
* 启动测试程序
* @param args
*/
public static void main(String[] args) {
System.out.println(Thread.currentThread().getName()+"主线程运行开始！");
Thread_join_Action thread1=new Thread_join_Action("A");
Thread_join_Action thread2=new Thread_join_Action("B");
thread1.start();
thread2.start();
System.out.println(Thread.currentThread().getName()+"主线程运行结束！");
}
}
运行结果：（主线程：main在子线程A和子线程B之前结束了）
main主线程运行开始！
main主线程运行结束！
A线程运行开始！
子线程A运行:0
B线程运行开始！
子线程B运行:0
子线程A运行:1
子线程B运行:1
子线程A运行:2
子线程B运行:2
子线程A运行:3
子线程B运行:3
子线程A运行:4
子线程B运行:4
A线程运行结束！
B线程运行结束！
加入join():（所有子线程都调用join()）
测试案例：
package com.jason.comfuns.join;
/**
* 多线程学习
* @function 不使用Thread.join()方法：测试在主线程中启动子线程时：主子线程的执行顺序
* @author 小风微凉
* @time 2018-4-21 下午12:56:31
*/
public class Thread_join_Action extends Thread {
private String thname;
public Thread_join_Action(String name){
super(name);
this.thname=name;
}
public void run(){
System.out.println(Thread.currentThread().getName()+"线程运行开始！");
for(int i=0;i<5;i++){
System.out.println("子线程"+thname+"运行:"+i);
try {
sleep((int)Math.random()*10);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println(Thread.currentThread().getName()+"线程运行结束！");
}
/**
* 启动测试程序
* @param args
*/
public static void main(String[] args) {
System.out.println(Thread.currentThread().getName()+"主线程运行开始！");
Thread_join_Action thread1=new Thread_join_Action("A");
Thread_join_Action thread2=new Thread_join_Action("B");
thread1.start();
thread2.start();
//开始调用子线程thread1的join()
try {
thread1.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
//开始调用子线程thread2的join()
try {
thread2.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"主线程运行结束！");
}
}
运行结果：
执行结果：（主线程main，在子线程A和子线程B执行结束之后，才结束，前提：子线程A和子线程B都必须调用join()）
main主线程运行开始！
A线程运行开始！
B线程运行开始！
子线程B运行:0
子线程A运行:0
子线程B运行:1
子线程A运行:1
子线程B运行:2
子线程B运行:3
子线程A运行:2
子线程B运行:4
子线程A运行:3
B线程运行结束！
子线程A运行:4
A线程运行结束！
main主线程运行结束！
加入join():（部分子线程都调用join()）
测试案例：
package com.jason.comfuns.join;
/**
* 多线程学习
* @function 不使用Thread.join()方法：测试在主线程中启动子线程时：主子线程的执行顺序
* @author 小风微凉
* @time 2018-4-21 下午12:56:31
*/
public class Thread_join_Action extends Thread {
private String thname;
public Thread_join_Action(String name){
super(name);
this.thname=name;
}
public void run(){
System.out.println(Thread.currentThread().getName()+"线程运行开始！");
for(int i=0;i<5;i++){
System.out.println("子线程"+thname+"运行:"+i);
try {
sleep((int)Math.random()*10);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println(Thread.currentThread().getName()+"线程运行结束！");
}
/**
* 启动测试程序
* @param args
*/
public static void main(String[] args) {
System.out.println(Thread.currentThread().getName()+"主程序运行开始！");
Thread_join_Action thread1=new Thread_join_Action("A");
Thread_join_Action thread2=new Thread_join_Action("B");
thread1.start();
thread2.start();
//开始调用子线程thread1的join()------只有子线程A调用join()
try {
thread1.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"主程序运行结束！");
}
}
运行结果：（只有在主线程中的调用了join()方法的子线程运行结束，主线程才会结束，没有调用join()方法的子线程不在此列）
main主程序运行开始！
B线程运行开始！
A线程运行开始！
子线程A运行:0
子线程B运行:0
子线程A运行:1
子线程B运行:1
子线程A运行:2
子线程B运行:2
子线程A运行:3
子线程B运行:3
子线程A运行:4
子线程B运行:4
A线程运行结束！
main主程序运行结束！
B线程运行结束！
（3）yield():暂停当前正在执行的线程，并执行其他线程。
Thread.yield()：暂停当前正在执行的线程，并执行其他线程。
yield()方法应该做的是让当前行线程回到可运行状态（就绪状态），以允许其他相同优先级或更高优先级的线程获得运行机会。因此，使用yield()方法的目的是让相同优先级的线程之间能够适当的轮转执行。但是，实际上无法保证yield()达到让步目的，因为让步线程（yield()的调用对象线程）还有可能被线程调度程序再次选中。
结论：
yield()从未导致：线程转到等待、休眠、阻塞状态。在大多数情况下，yield()将导致线程从运行状态转到可运行状态（就绪状态），但是有可能没效果。
简单案例： （测试2个同优先级别的线程：在调用yield()方法时的执行情况）
package com.jason.comfuns.yield;
/**
* 多线程学习
* @function
* @author 小风微凉
* @time 2018-4-21 下午1:53:37
* 总结：
* 当一个线程调用yield()，那么当前运行线程会让出cpu执行权限，供自己其他同优先级别活更高的优先级别的线程抢夺。
* 谁(线程)抢到，谁开始运行。
*/
public class Thread_yield_Action extends Thread{
private String thname;
public Thread_yield_Action(String name){
super(name);
this.thname=name;
}
public void run(){
System.out.println(Thread.currentThread().getName()+"线程运行开始");
for(int i=0;i<10;i++){
System.out.println(Thread.currentThread().getName()+"线程运行："+i);
if(i==5){//当i为5时，该线程会让出CPU的执行机会，让其他或自己的线程执行。（简单来说：谁抢到CPU的权限谁执行）
System.out.println(Thread.currentThread().getName()+"让出CPU权限-------------");
Thread.yield();//或者this.yield()
}
}
System.out.println(Thread.currentThread().getName()+"线程运行结束");
}
public static void main(String[] args) {
Thread_yield_Action thread1=new Thread_yield_Action("A");
Thread_yield_Action thread2=new Thread_yield_Action("B");
thread1.start();
thread2.start();
}
}
运行结果：
运行结果：（当一个线程执行yield()后就让出cpu执行权限，供其他同优先级或自己的线程竞争抢夺）
B线程运行开始
A线程运行开始
A线程运行：0
A线程运行：1
A线程运行：2
B线程运行：0
A线程运行：3
A线程运行：4
A线程运行：5
A让出CPU权限-------------
B线程运行：1
B线程运行：2
B线程运行：3
B线程运行：4
B线程运行：5
A线程运行：6
A线程运行：7
A线程运行：8
A线程运行：9
B让出CPU权限-------------
A线程运行结束
B线程运行：6
B线程运行：7
B线程运行：8
B线程运行：9
B线程运行结束
简单案例：（测试：2个线程，一个优先级10 ， 一个优先级5，让优先级10的线程主动让出CPU的执行权限，检测执行情况）
package com.jason.comfuns.yield;
/**
* 多线程学习
* @function 测试： yield()方法
* @author 小风微凉
* @time 2018-4-21 下午1:53:37
* 总结：
* 当一个线程调用yield()，那么当前运行线程会让出cpu执行权限，供自己其他同优先级别活更高的优先级别的线程抢夺。
* 谁(线程)抢到，谁开始运行。
*/
public class Thread_yield_Action extends Thread{
private String thname;
public Thread_yield_Action(String name){
super(name);
this.thname=name;
}
public void run(){
System.out.println(Thread.currentThread().getName()+"线程运行开始");
for(int i=0;i<10;i++){
System.out.println(Thread.currentThread().getName()+"线程运行："+i);
if(i==5){//当i为5时，该线程会让出CPU的执行机会，让其他或自己的线程执行。（简单来说：谁抢到CPU的权限谁执行）
if("A".equals(Thread.currentThread().getName())){//如果是优先级大的则yield执行一次退让
System.out.println(Thread.currentThread().getName()+"让出CPU权限-------------");
Thread.yield();//或者this.yield()
}
}
}
System.out.println(Thread.currentThread().getName()+"线程运行结束");
}
public static void main(String[] args) {
Thread_yield_Action thread1=new Thread_yield_Action("A");
Thread_yield_Action thread2=new Thread_yield_Action("B");
thread1.setPriority(MAX_PRIORITY);//优先级：10
thread1.start();
thread2.setPriority(MIN_PRIORITY);//优先级：5
thread2.start();
}
}
运行结果：（总结：A的优先级为10级，B的优先级为5级，即使A的线程调用了yield()方法，让出了cpu的执行权，从执行状态退到了可执行状态，但是由于目前之后线程A和线程B,还是会优先调度线程A）
A线程运行开始
A线程运行：0
A线程运行：1
A线程运行：2
B线程运行开始
A线程运行：3
A线程运行：4
A线程运行：5
A让出CPU权限-------------
B线程运行：0
A线程运行：6
A线程运行：7
A线程运行：8
A线程运行：9
A线程运行结束
B线程运行：1
B线程运行：2
B线程运行：3
B线程运行：4
B线程运行：5
B线程运行：6
B线程运行：7
B线程运行：8
B线程运行：9
B线程运行结束
简单案例：（测试：2个线程，一个优先级10 ， 一个优先级5，让优先级5的线程主动让出CPU的执行权限，检测执行情况）
修改上面部分代码：
public static void main(String[] args) {
Thread_yield_Action thread1=new Thread_yield_Action("A");
Thread_yield_Action thread2=new Thread_yield_Action("B");
Thread_yield_Action thread3=new Thread_yield_Action("C");
thread1.setPriority(MIN_PRIORITY);//5级
thread1.start();
thread2.setPriority(MAX_PRIORITY);//10级
thread2.start();
thread3.setPriority(2);//2级
thread3.start();
}
运行结果：（总结：A的优先级为5级，B的优先级为10级，此时由于B的优先级高于A,B已经先行执行完毕了，然后A的线程调用了yield()方法，让出了cpu的执行权，此时只剩下A线程和C线程，由于A线程优先级别高于C线程，则仍然会优先执行A线程，最后C线程）
B线程运行开始
B线程运行：0
B线程运行：1
B线程运行：2
B线程运行：3
B线程运行：4
B线程运行：5
B线程运行：6
B线程运行：7
B线程运行：8
B线程运行：9
B线程运行结束
A线程运行开始
A线程运行：0
A线程运行：1
A线程运行：2
A线程运行：3
A线程运行：4
A线程运行：5
A让出CPU权限-------------
A线程运行：6
A线程运行：7
A线程运行：8
A线程运行：9
A线程运行结束
C线程运行开始
C线程运行：0
C线程运行：1
C线程运行：2
C线程运行：3
C线程运行：4
C线程运行：5
C线程运行：6
C线程运行：7
C线程运行：8
C线程运行：9
C线程运行结束
最新文章
- Linux学习之路—Linux文件与目录管理
- maven nexus私服搭建，特别痛苦！！
- 独立成分分析（ICA）在fMRI数据处理时timecourse的理解
- 设计模式学习之备忘录模式（Memento，行为型模式）（19）
- WorkbookDesigner mvc里面返回file
- 学习C++11的一些思考和心得(1):lambda,function,bind和委托
- Shell: extract more from listener.log(分析监听日志)
- 鸟哥的linux私房菜——第12章 正则表达式与文件格式化处理
- Session深入理解
- Emacs学习阶段小结-Emacs常用快捷键总结
- C++拷贝构造函数详解
- 在VC++中使用Tab Control控件
- JQuery打印
- jquery学习笔记2——jq效果
- rips中如何使用PHP虚拟机自带函数--token_get_all
- POJ 2828 Buy Tickets 线段树 倒序插入 节点空位预留（思路巧妙）
- Spring Cloud学习笔记-006
- FFMPEG结构体分析：AVPacket
- “《编程珠玑》（第2版）第2章”：A题（二分搜索）
- Apache Hadoop 2.9.2 完全分布式部署