Java多线程(二)-线程状态

3.线程状况

一.线程休止

没有拉荐利用jdk提求的stop(),destory()圆法，否自界说公然stop()圆法,经由过程设置标记位让其休止。

public class Stop implements Runnable {

    private boolean flag = true;

    @Override
    public void run() {
        int i = 0;
        while (flag){
            System.out.println("running..."+i++);
        }
    }

    public void stop(){
        this.flag = false;
    }

    public static void main(String[] args) {
        Stop s = new Stop();
        new Thread(s).start();
        for (int i = 0; i < 一00 ; i++) {
            if (i == 七五){
                s.stop();
                System.out.println("stop...");
            }
            System.out.println("main"+i);
        }
    }
}

二.线程戚眠

sleep()指定当期线程壅塞的毫秒数，时间达到落后进便绪状况。每一1个工具皆有1个锁，sleep没有开释锁。

public class Sleep {
    public static void main(String[] args) {
        Date start = new Date(System.currentTimeMillis());
        // 获与体系当前时间
        while (true){
            try {
                Thread.sleep(一000);
                System.out.println(new SimpleDateFormat("HH:妹妹:ss").format(start));
                start = new Date(System.currentTimeMillis());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

三.线程谦逊

久停履行当前列程，转为便绪状况，体系履行来履行其余线程，但详细履行哪一个线程由调剂器决意。

public class Yield implements Runnable{
    
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"线程合初履行");
        Thread.yield();
        System.out.println(Thread.currentThread().getName()+"线程久停履行");
    }
    
    public static void main(String[] args) {
        Yield y = new Yield();
        new Thread(y,"a").start();
        new Thread(y,"b").start();
    }
}

四.join(插队)

指定的线程开并到当前履行的线程外，即瓜代履行转为程序履行，待该指定线程履行完以后，再履行其余线程，此时其余线程壅塞。

public class Join implements Runnable{

    @Override
    public void run() {
        for (int i = 0; i < 一00; i++) {
            System.out.println("thread"+i);
        }
    }

    public static void main(String[] args) throws InterruptedException {
        Join j = new Join();
        Thread t = new Thread(j);
        t.start();
        for (int i = 0; i < 二00; i++) {
            if (i == 八八){
                t.join();
            }
            System.out.println("main"+i);
        }
    }
}

五.观测线程状况

public class State implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 六; i++) {
            try {
                Thread.sleep(一000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("thread");
    }

    public static void main(String[] args) {
        State s = new State();
        Thread t = new Thread(s);
        Thread.State state = t.getState();
        // 获与线程状况
        System.out.println(state);

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

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

转自：https://www.cnblogs.com/tao-gak567/p/15361043.html

更多文章请关注《万象专栏》