Java------多线程_终止_暂停sleep_礼让yield_插队join（五）

Java------多线程_插队join
线程停止
1.不使用JDK提供的stop()/destory()方法（他们本身也被JDK废弃）。
2.提供一个boolean型的终止变量，当这个变量置为false，则终止线程。
示例代码：

/**
 * 终止线程
 * 1.线程正常执行完毕--》次数
 * 2.外部干涉，加入标识，不要使用stop、destory，
 */
public class ThreadStop implements Runnable{
    private  boolean flag = true;
    private  String name;

    @Override
    public void run() {
        int i = 0;
        while (flag){
            System.out.println(name+"---"+i++);
        }
    }
    public void terminte(){
        this.flag = false;
    }

    public static void main(String[] args) {
        ThreadStop stop1 = new ThreadStop();
        new Thread(stop1).start();

        for (int i =0;i<100;i++){
            if(i==88){
                stop1.terminte();
                System.out.println(i);
            }
        }
    }
}

sleep暂停
1.sleep时间指定当前线程阻塞的毫秒数；
2.sleep存在异常InterruptedException。
3.时间达到后线程进入就绪状态，等待CPU调用
4.sleep可以模拟网络延时、倒计时等，是静态方法，写在那个线程体中，那个线程阻塞。
5.每一个对象都有一个锁，sleep不会释放锁。
之前模拟抢票的例子，此处示例代码：

import java.text.SimpleDateFormat;
import java.util.Date;

/**
 * 模拟倒计时，10秒倒计时
 */
public class ThreadSleep02{

    public static void main(String[] args) throws InterruptedException {
       //倒数10个数，1秒1个
        Date endTime = new Date(System.currentTimeMillis()+1000*10);
        long end = endTime.getTime();
        while (true){
            System.out.println(new SimpleDateFormat("mm:ss").format(endTime));
            //sleep是一个静态方法，写在那个线程体中，谁运行我谁阻塞，不会释放锁，阻塞的一种
            Thread.sleep(1000);
            endTime = new Date(endTime.getTime()-1000);
            if (end-10000 >endTime.getTime()){
                break;
            }
        }
    }

    public static void test() throws InterruptedException{
        //倒数10个数，1秒1个
        int num = 10;
        while (true){
            Thread.sleep(1000);
            System.out.println(num--);
        }
    }
}

礼让线程yield
1.礼让线程，让当前正在执行线程暂停
2.不是阻塞线程，而是将线程从运行状态转入就绪状态
3.让cpu调度器重新调度
示例代码1：

/**
 * yield礼让，
 * 线程礼让后，进入就绪状态，可能立马执行，也能让其他线程先执行
 * 由CPU调度
 */
public class ThreadYield {
    public static void main(String[] args) {
        MyYeild myYeild = new MyYeild();
        new Thread(myYeild,"a").start();
        new Thread(myYeild,"b").start();

    }

}

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

示例代码2：
由此可见，礼让线程并比一定让出执行。

/**
 * yield礼让，
 * 线程礼让后，进入就绪状态，可能立马执行，也能让其他线程先执行
 * 由CPU调度
 */
public class ThreadYield {
    public static void main(String[] args) {
        new Thread(() ->{
            for (int i = 0;i<100;i++){
                System.out.println("i线程-----"+i);
            }
        }).start();

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

    }

}

join合并线程（插队线程），待此线程执行完成后，再执行其他线程，其他线程阻塞。
join是成员方法，哪个线程对象调用该方法，该线程就先执行。
join()中可以传时间，当时间到了之后，如果该线程还没有执行完，cpu就不管了，失去了优先执行的地位。
示例代码

/**
 * join合并线程、插队线程
 */
public class ThreadJoin implements Runnable{
    @Override
    public void run() {

    }

    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(() -> {
            for (int i = 0; i < 100; i++) {
                System.out.println("-----------" + i);
            }
        });
        thread.start();
        for (int y = 0;y<100;y++){
            if (y== 20){
                thread.join();//插队 main被阻塞，当y==20时被阻塞，先执行i，执行完毕后，再执行y
            }
            System.out.println("main----------"+y);
        }
    }
}