暂停线程执行sleep_yield_join_stop

1.final void join() 调用该方法的线程强制执行完成，其它线程处于阻塞状态，该线程执行完毕，其它线程再执行

public class TestJoin {
    public static void main(String[] args) throws InterruptedException {
        //主线程
        MyThread my=new MyThread();
        Thread t=new Thread(my);
        Thread t2=new Thread(my);
        //启动线程
        t.start();
        t2.start();
        //以下代码为主线程中的循环
        for(int i=0;i<5;i++){
            if(i==2){
                t.join();  //t线程强制执行
            }
            System.out.println("------------"+Thread.currentThread().getName()+"-------->"+i);
        }
    }
    /**
     * 导致调用它的线程进入阻塞状态，而不会导致其它的线程
     * 
     * */
}

main执行到2进入阻塞，等Thread-0和Thread-1执行完毕

--------------------------------------------------------------------------------------------------------------

2.static void sleep(long millis)  使当前正在执行的线程休眠millis毫秒，线程处于阻塞状态

public class MyThread2 implements Runnable {
    @Override
    public void run() {
        try {
            System.out.println("MyThread2.run(),线程开始休眠");
            Thread.sleep(3000);//休眠3秒
            System.out.println("MyThread2.run(),休眠结束");
        } catch (InterruptedException e) {
            System.out.println("MyThread2.run(),产生异常");
        }
    }
}

public class TestSleep2 {
    /**
     * sleep方法会导致线程进入阻塞，写在哪个线程体中就会导致哪个线程进入阻塞状态*/
    public static void main(String[] args) throws InterruptedException {
        MyThread2 my=new MyThread2();
        Thread t=new Thread(my);
        //启动线程
        t.start();
        //以下代码为主线程中的代码
        System.out.println("主线程开始休眠");
        Thread.sleep(2000);
        System.out.println("主线程休眠结束");
    }
}

-------------------------------------------------------------------------------------------------------------------

3.static void yield()  当前正在执行的线程暂停一次(礼让)，允许其他线程执行，不阻塞，线程进入就绪状态，如果没有其他等待执行的线程，这个时候当前线程就会马上恢复执行

public class MyThread3 implements Runnable {
    @Override
    public void run() {
        for(int i=0;i<5;i++){
            if(i==2){
                Thread.yield();//i==2时礼让一次
                System.out.println("当前线程:"+Thread.currentThread().getName()+"线程礼让一次");
            }
            System.out.println("i="+i);
        }
    }
}

public class TestYield {
    public static void main(String[] args) {
        MyThread3 my=new MyThread3();
        new Thread(my).start();//启动线程
        //主线程中的循环
        for(int i=0;i<5;i++){
            if(i==3){
                Thread.yield();//i==3 主线程礼让一次
                System.out.println(Thread.currentThread().getName()+"线程礼让一次");
            }
            System.out.println(Thread.currentThread().getName()+"------------"+i);
        }
    }
}

--------------------------------------------------------------------------------------------------

4.final void stop()  强迫线程停止执行，已过时，不推荐使用

public class MyThread4 implements Runnable {
    @Override
    public void run() {
        for(int i=0;i<5;i++){    
            System.out.println("i="+i);
        }
    }
}

public class TestStop {
    public static void main(String[] args) {
        MyThread4 my=new MyThread4();
        Thread t=new Thread(my);
        t.start();//启动线程
        //主线程中的循环
        for(int i=0;i<5;i++){
            if(i==2){
                t.stop();  //已过时，不建议使用
            }
            System.out.println(Thread.currentThread().getName()+"--->"+i);
        }
        
    }
}

总结

1.sleep：

不会释放锁，Sleep时别的线程也不可以访问锁定对象。

2.yield:

让出CPU的使用权，从运行态直接进入就绪态。让CPU重新挑选哪一个线程进入运行状态。

3.join:

当某个线程等待另一个线程执行结束后，才继续执行时，使调用该方法的线程在此之前执行完毕，也就是等待调用该方法的线程执行完毕后再往下继续执行