Day39-CSDN博客

本文链接：https://blog.csdn.net/qq_50065571/article/details/108850879

本文详细介绍了Java中的线程控制方法，包括yield()用于线程礼让，join()实现线程合并及等待，以及如何观察线程的状态。通过示例代码展示了它们在实际操作中的应用，如线程的并发执行和同步。同时，讨论了线程的不同状态，如NEW、RUNNABLE、TIMED_WAITING和TERMINATED，并提供了检查活跃线程数的示例。

摘要由CSDN通过智能技术生成

yield

yield也是暂停线程

礼让线程，让当前正在执行的线程暂停

不是阻塞线程，而是将线程从运行状态转入就绪状态

让出cpu的调度，避免占用过久

yield和sleep方法一样也是静态方法，直接写在线程体中

package com.sxt.state;

/**
 * yield 礼让线程  暂停线程 直接进入就绪状态不是堵塞状态
 */
public class YieldDemo01 {
    public static void main(String[] args) {
        MyYield my = new MyYield();
        new Thread(my,"A").start();
        new Thread(my,"B").start();
    }
}

class MyYield implements Runnable {

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + "--->start");
        Thread.yield();//礼让
        System.out.println(Thread.currentThread().getName() + "--->end");
    }
}

主线程线程礼让

利用lambda方法简化线程

package com.sxt.state;

/**
 * yield 礼让线程  暂停线程 直接进入就绪状态不是堵塞状态
 */
public class YieldDemo02{
    public static void main(String[] args) {
       new Thread(()->{
           for (int i = 0; i <100 ; i++) {
               System.out.println("lambda..."+i);
           }
       }).start();

        for (int i = 0; i < 100; i++) {
            if (i%20==0){
                Thread.yield();//main礼让
            }
            System.out.println("main..."+i);

        }
    }
}

join

join是合并线程，待此线程执行完成后，在执行其他线程，其他线程堵塞

join是个成员方法，需要Tread对象.join 调用的是对象的方法

package com.sxt.state;

/**
 * join合并线程，插队线程
 */
public class BlockedJoin01 {
    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(() -> {
            for (int i = 0; i < 100; i++) {
                System.out.println("lambda..." + i);
            }
        });
        t.start();

        for (int i = 0; i < 100; i++) {
            if (i ==20 ) {
                t.join();//插队 main被堵塞了
            }
            System.out.println("main..." + i);

        }
    }
}

儿子给爸爸买烟的这件事就用到了join方法，爸爸拿到烟以后的事一定是儿子把烟买回来给爸爸已经发生的，这里就用用到join，堵塞线程，等其他线程执行完了，最后再执行，也可以设置多少秒后堵塞结束

package com.sxt.state;

/**
 * join合并线程，插队线程
 */
public class BlockedJoin02 {
    public static void main(String[] args) throws InterruptedException {
        System.out.println("爸爸和儿子买烟的故事");
        new Thread(new Father()).start();
    }
}
class Father extends Thread{
    @Override
    public void run() {
        System.out.println("想抽烟，发现没了");
        System.out.println("让儿子去买中华");
        Thread t = new Thread(new Son());
        t.start();
        try {
            t.join();//Father被阻塞
            System.out.println("老爸接过烟，把零钱给了儿子");
        } catch (InterruptedException e) {
            e.printStackTrace();
            System.out.println("孩子走丢了，老爸去找孩子了");
        }

    }
}
class Son extends Thread{
    @Override
    public void run() {
        System.out.println("接过老爸的钱，去买烟了");
        System.out.println("路边有个游戏厅，玩了10秒");
        for (int i = 0; i < 10; i++) {
            System.out.println(i+"秒过去了");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("赶紧去买烟");
        System.out.println("手拿一包中华回家了");
    }
}
/**
爸爸和儿子买烟的故事
想抽烟，发现没了
让儿子去买中华
接过老爸的钱，去买烟了
路边有个游戏厅，玩了10秒
0秒过去了
1秒过去了
2秒过去了
3秒过去了
4秒过去了
5秒过去了
6秒过去了
7秒过去了
8秒过去了
9秒过去了
赶紧去买烟
手拿一包中华回家了
老爸接过烟，把零钱给了儿子
*/

深度观察状态

四个状态：

NEW 新生

RUNNABLE 运行

TIMED&&TIMED_WAITING 等待堵塞

TERMINATED 结束

Thread.activeCount();活跃的线程数

package com.sxt.state;
/**
 * 观察线程状态
 */
public class AllState {
    public static  void main(String[] args) {
        Thread t = new Thread(() -> {
            for (int i = 0; i < 5; i++) {
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("......");
            }
        });
        //观察状态
        Thread.State state = t.getState();
        System.out.println(state);//NEW

        t.start();
        state =t.getState();
        System.out.println(state);//RUNNABLE

       /* while (state!=Thread.State.TERMINATED){
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            state=t.getState();
            System.out.println(state);//TIMED_WAITING(阻塞的一种)
        }
        state=t.getState();
        System.out.println(state);//TERMINATED
        */

        while (true) {
            //活动的线程数，主循环是最后一个线程
            int num = Thread.activeCount();
            System.out.println(num);
            if (num == 2) {
                break;
            }
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            state=t.getState();
            System.out.println(state);//TIMED_WAITING(阻塞的一种)
        }
    }
}