多线程-线程的几个简单方法

下面给大家介绍线程几个简单的方法：

• sleep();
• yield();
• join();

1、sleep();  sleep的意思就是睡眠的意思，当前线程停下来一段时间 ，让给其他的线程去执行，sleep的复活是完全取决于睡眠的时间，睡眠的时间到了自己会自动复活；

2、yield();  yield的意思是当前运行的线程停下来进入等待队列 ，回到等待队列，在系统的调度算法里还是有可能把刚刚放入等待队列的线程拿出来执行，当然更大可能还是拿之前的，所以yield 的意思是我让出一下CPU ，后面能不能抢到就不知道了。

3、join();  join的意思是你在当前执行线程中加入其他的线程，你需要在等你加入的线程执行结束以后，才能继续执行你当前的线程，当然自己join自己没啥意义。

 

话不多说直接上代码，自己去运行，就能体会其中的含义了：

package com.example.demo.threaddemo.juc_001;
/**
 * 介绍一下线程的几个基本方法
 */
public class Sleep_join_yield {
    /**
     * sleep 的意思就是睡眠，当前线程暂停一段时间让给别的线程去执行，sleep是如何复活的呢？
     * 这完全取决于睡眠的时间，当睡眠的时间到了，会自动复活。
     */
    public static void sleep01(){
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(i);
            }
        }).start();
    }

    /**
     * yield 就是当前正在执行的线程停下来进入等待队列，回到等待队列里后，在系统调度算法里还是依然有可能把
     * 刚刚进入等待队列里的线程拿回来继续执行，当然更大可能还是拿之前等待的线程；
     * 所以yield 的意思是我让出一下CPU ，后面能不能抢到就不知道了。
     */
    static void yield01(){
        new Thread(()->{
        for (int i = 0; i < 20; i++) {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+ "----------"+ i);
            if(i%5 == 0)
                Thread.yield();
        }
        }).start();

        new Thread(()->{
            for (int i = 0; i < 20; i++) {
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName()+ "----------"+ i);
                if(i%5 == 0)
                    Thread.yield();
            }
        }).start();
    }

    /**
     * 意思就是在你当前执行的线程加入你调用的join线程，等待你调用的线程执行完了，自己再去继续执行。
     * 例如下面的示例：有t1 t2 两个线程，t2在某一个节点上调用了t1.join()方法，它会跑到t1去执行，执行完了再回来
     * 继续执行（自己join自己没有什么意义）
     */
    public static void join01(){
        Thread t1 = new Thread(()->{
            for (int i = 0; i < 10; i++) {
                System.out.println("A-------------------------"+i);
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });

        Thread t2 = new Thread(()->{
            for (int i = 0; i < 10; i++) {
                System.out.println("B------------------------" + i);
                if(i==5){
                    //使用join方法加入t1线程
                    try {
                        t1.join();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        t1.start();
        t2.start();
    }

    public static void main(String[] args) {
        System.out.println("let us beginning ------------");
//        sleep01();
//        yield01();
        join01();
    }
}