本篇文章为你整理了多线程(三)（多线程三种实现方式的区别）的详细内容，包含有多线程三要素 多线程三种实现方式的区别 多线程三种方式区别 多线程三种实现方式 多线程(三)，希望能帮助你了解 多线程(三)。
注意
优先级高的线程并不一定就比优先级低的先获得cpu资源，只是获得cpu资源的概率比较大，具体还要看cpu的调度算法；
设置优先级案例
public class MyThreadPriority implements Runnable{
@Override
public void run() {
//线程执行的业务方法
System.out.println("子线程执行");
for (int i = 0;i i++){
System.out.println("--- 线程名---："+Thread.currentThread().getName()+"，序号："+i);
public static void main(String[] args) {
//创建线程并设置线程名和优先级
Thread thread1 = new Thread(new MyThreadPriority(),"线程A");
Thread thread2 = new Thread(new MyThreadPriority(),"线程B");
//线程优先级的取值范围：[1,10],默认是5，值越小，优先级越小
//设置线程优先级，只能代表优先级高的线程获取cpu资源的概率较大，单不是绝对优先，它取决于cpu的调度算法
thread1.setPriority(Thread.MAX_PRIORITY);
thread2.setPriority(Thread.MIN_PRIORITY);
//启动线程
thread1.start();
thread2.start();
运行结果
子线程执行
--- 线程名---：线程A，序号：0
--- 线程名---：线程B，序号：0
--- 线程名---：线程A，序号：1
--- 线程名---：线程A，序号：2
--- 线程名---：线程A，序号：3
--- 线程名---：线程A，序号：4
--- 线程名---：线程B，序号：1
--- 线程名---：线程B，序号：2
--- 线程名---：线程B，序号：3
--- 线程名---：线程B，序号：4
2、 sleep(long millis)
线程休眠
//休眠一秒
Thread.sleep(1000); //单位毫秒
//TimeUnit.MILLISECONDS.sleep(1000); //单位毫秒
//TimeUnit.SECONDS.sleep(1); //单位毫秒
3、join()
强制加入子线程，谁调用join的方法，谁加入，当前线程会暂停，等待加入的子线程运行结束才可以继续执行；
join案例
//强制加入执行线程：必须要等调用了join方法的线程执行结束，必然发生
public class MyThreadJoin implements Runnable{
@Override
public void run() {
//线程执行的业务方法
System.out.println("子线程执行");
for (int i = 0;i i++){
System.out.println("--- 线程名---："+Thread.currentThread().getName()+"，序号："+i);
try {
//休眠一秒
// Thread.sleep(1000);
// TimeUnit.MILLISECONDS.sleep(1000);
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
public static void main(String[] args) {
//创建一个子线程对象
Thread thread = new Thread(new MyThreadJoin(), "强制Join线程");
//启动子线程
thread.start();
//主线程
System.out.println("***主线程执行***");
System.out.println("***线程名***："+Thread.currentThread().getName());
try {
System.out.println("---主线程中强制加入子线程，继续执行---");
//强制加入子线程，谁调用join的方法，谁加入，当前线程会暂停，等待加入的子线程运行结束才可以继续执行；
thread.join();
} catch (InterruptedException e) {
e.printStackTrace();
System.out.println("---主线程执行结束---");
运行结果
***主线程执行***
子线程执行
***线程名***：main
---主线程中强制加入子线程，继续执行--- //子线程join后主线程要等子线程执行完成才可以继续执行
--- 线程名---：强制Join线程，序号：0
--- 线程名---：强制Join线程，序号：1
--- 线程名---：强制Join线程，序号：2
---主线程执行结束---
4、yield()
线程礼让：提供一种礼让的可能，但是不能保证绝对礼让，是一个概率事件（可能让，可能不让）；
yield案例
//线程礼让：提供一种礼让的可能，但是不能保证绝对礼让，是一个概率事件
public class MyThreadYield implements Runnable{
@Override
public void run() {
//线程执行的业务方法
System.out.println("子线程执行");
for (int i = 0;i i++){
System.out.println("--- 线程名---："+Thread.currentThread().getName()+"，序号："+i);
//当执行到第6次，执行礼让
if(i ==5){
System.out.println("==="+Thread.currentThread().getName()+"礼让===");
Thread.yield();
//静态方法，通过线程对象调用
public static void main(String[] args) {
MyThreadYield myThreadYield = new MyThreadYield();
//创建子线程并启动
new Thread(myThreadYield,"线程1").start();
new Thread(myThreadYield,"线程2").start();
new Thread(myThreadYield,"线程3").start();
运行结果
子线程执行
子线程执行
子线程执行
--- 线程名---：线程1，序号：0
--- 线程名---：线程2，序号：0
--- 线程名---：线程1，序号：1
--- 线程名---：线程3，序号：0
--- 线程名---：线程1，序号：2
--- 线程名---：线程2，序号：1
--- 线程名---：线程1，序号：3
--- 线程名---：线程3，序号：1
===线程1礼让===
--- 线程名---：线程2，序号：2 //线程3变成了线程2，礼让了
--- 线程名---：线程1，序号：4
--- 线程名---：线程3，序号：2
--- 线程名---：线程1，序号：5
--- 线程名---：线程2，序号：3
--- 线程名---：线程1，序号：6
--- 线程名---：线程3，序号：3
--- 线程名---：线程1，序号：7
===线程2礼让===
--- 线程名---：线程1，序号：8 //还是线程1，没有发生礼让
===线程3礼让===
--- 线程名---：线程1，序号：9 //还是线程1，没有发生礼让
--- 线程名---：线程2，序号：4
--- 线程名---：线程3，序号：4
--- 线程名---：线程2，序号：5
--- 线程名---：线程3，序号：5
--- 线程名---：线程2，序号：6
--- 线程名---：线程3，序号：6
--- 线程名---：线程2，序号：7
--- 线程名---：线程3，序号：7
--- 线程名---：线程2，序号：8
--- 线程名---：线程3，序号：8
--- 线程名---：线程2，序号：9
--- 线程名---：线程3，序号：9
所以线程礼让是一种概率事件；
5、interript()
线程中断；
6、isAlive()
测试线程是否处于活动那个状态；
以上就是多线程(三)（多线程三种实现方式的区别）的详细内容，想要了解更多 多线程(三)的内容，请持续关注盛行IT软件开发工作室。
郑重声明：本文由网友发布，不代表盛行IT的观点，版权归原作者所有，仅为传播更多信息之目的，如有侵权请联系，我们将第一时间修改或删除，多谢。