Java学习（多线程五大状态（接下来的））

Java学习----多线程五大状态（接下来的部分）

线程休眠

线程休眠就是让线程停下来，然后进入阻塞状态，阻塞结束之后重新进入就绪状态的这样一个过程。

线程休眠一般有两种方法：sleep方法和wait方法，其中sleep方法为本次的重点，wait方法会放在后面的线程通讯时讲到

---

sleep方法

1. 用法：Thread.sleep(seconds)，其中Thread表示当前线程，seconds表示暂停的秒数，用毫秒来做单位。
2. sleep方法存在一个InterruptedException错误，需要进行捕捉
3. sleep方法在线程沉睡执行完之后才会重新进入就绪
4. sleep可以模拟网络延迟和倒计时
5. sleep方法不会释放锁，当存在一个synchronized锁时，sleep不会把锁给其他线程，但是wait方法会

下面是一个例子：

public class race implements Runnable{

    private String winner;
    @Override
    public void run() {
        for (int i = 0; i <=80; i++) {
            System.out.println(Thread.currentThread().getName()+"跑了"+i+"步");
            boolean flag=getWinner(i);
            if (flag){
                break;
            }
            if (Thread.currentThread().getName().equals("兔子")&&i%10==0){
                try {//让线程进入阻塞状态，从而使线程被卡死
                    Thread.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

        }
    }

    private boolean getWinner(int steps){
        //这个if用于判断是否已经存在胜利者，如果不用就会出现两个胜利者
        if (winner!=null){
            System.out.println("失败者是："+Thread.currentThread().getName());
            return true;
        }
        {//这里是代码块，会被执行
            if (steps==80){
                winner=Thread.currentThread().getName();
                System.out.println("最后的胜利者是："+winner);
                return true;}
            return false;
        }
    }

    public static void main(String[] args) {
        race race = new race();
        new Thread(race,"乌龟").start();
        new Thread(race,"兔子").start();

    }
}

还是经典的龟兔赛跑，这里让龟兔两个线程都一起跑，随着线程的调度，可以模拟出龟兔的赛跑情景，而用sleep方法可以模拟兔子睡着了而乌龟还在跑，这里就是利用sleep来让兔子线程进入休眠，随后在这一段时间内乌龟就被调用，也就是乌龟一直在跑，因此乌龟就能跑在前面。

sleep还可以模拟网络延迟，放大问题的出现概率，例如多个线程操作一个对象的时候就可以用sleep来放大可能出现的数据不安全现象

---

线程礼让

yield方法

线程礼让就是让线程暂停，但不进入阻塞状态，而是进入就绪状态，等待重新被调用

举个例子，就是在竞争干饭的时候，你上了，结果你决定退出来，然后和后面那哥们儿重新公平竞争一次，注意：公平竞争，也就是说喜下次是谁不确定，也有可能还是你

用法，Thread.yield();如此一来就能让一个线程礼让后面的线程了，这个用的不多。

---

线程插队

jion方法

线程插队就是指线程在运行过程中，让一个线程强行插入进来执行，相当于是有一个线程开了vip，要优先处理。

//模拟线程插队
public class jion implements  Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 200; i++) {
            System.out.println("vip"+i);
        }
    }

    public static void main(String[] args) {
        jion jion = new jion();
        Thread thread = new Thread(jion);
        thread.start();
        for (int i = 0; i < 400; i++) {
            if (i==200){
                try {
                    thread.join();
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
            System.out.println("main"+i);

        }
    }
}

这里是是让主线程走了200次之后让子线程插入进来。很简单，不多解释了。
·
·
·
·
·
·
·
·
·
·
·
·
·
·
搞完了，接下来似乎还有个线程状态的观测，那就留待大家自个儿解决吧

哈哈哈，开玩笑，我桃乙怎么可能如此草率，其实这个也蛮简单，说白了就是一个getState()方法，用这个方法可以获取一个线程的状态，如果要把搞成作为一个对象，那么就这样：

Thread.State state=thread.getState();

这就可以了，当然如果你要实时监控一个线程，那么就要不断更新这个线程

放个例子，大家自取吧：

public class State {
    public static void main(String[] args) {
        Thread thread = new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("");
        });
        Thread.State state=thread.getState();
        System.out.println(state);

        thread.start();
        System.out.println(thread.getState());

        while (state!=Thread.State.TERMINATED){
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            state=thread.getState();
            System.out.println(state);

        }
    }
}

OK，咱多线程的五大状态到这里就没了。