Java多线程-02-线程状态

目录

一.线程简介

二.线程创建

三.线程状态

四.线程同步

五.线程协作

三.线程状态

介绍

五大状态

image-20220409212219500

image-20220409212346920

线程方法

image-20220409212528092

线程停止_sleep

image-20220409220126239

//1.建议线程正常停止
//2.如果要强制停止，自己设置一个外部标志位控制(不要使用Java自带的方法)

public class Stop_Test {
    public static void main(String[] args) {
        Load load_01 = new Load();
        new Thread(load_01).start();

        for (int i = 0; i < 10000; i++) {
            //在i等于9900时 停止myThread线程
            if(i==9900)     load_01.stop();
            System.out.println("main线程---"+i);
        }

        System.out.println("main线程---自然停止");
    }
}

class Load implements Runnable{
    //标志位
    private boolean flag = true;

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

    //设置一个公开的停止方法
    public void stop(){
        flag = false;
        System.out.println("Load线程---非自然停止");
    }
}
image-20220409223104533

线程礼让_yield

image-20220414144119473

正常的情况

package 线程状态;

public class Yield_Test {
    public static void main(String[] args) {
        MyYeild myYeild = new MyYeild();
        for (int i = 0; i < 10; i++) {
            new Thread(myYeild,Integer.toString(i)).start();
        }
    }
}

class MyYeild implements Runnable{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + "-->开始");
        System.out.println(Thread.currentThread().getName() + "-->结束");
    }
}
image-20220414161116862

礼让的情况

public class Yield_Test {
    public static void main(String[] args) {
        MyYeild myYeild = new MyYeild();
        for (int i = 0; i < 10; i++) {
            new Thread(myYeild,Integer.toString(i)).start();
        }
    }
}

class MyYeild implements Runnable{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + "-->开始");
        //这里写个循环并不是正规操作
        //只是因为礼让有可能不成功,礼让一100次多半会成功,方便观察现象
        //每个线程都在输出了 “开始” 后礼让100次
        //即在输出 “结束" 之前所有的线程都会相互礼让
        //即先被cpu调度的线程在输出 “开始” 后会礼让后被cpu调度的线程
        for (int i = 0; i < 10000; i++) {
            Thread.yield();
        }
        System.out.println(Thread.currentThread().getName() + "-->结束");
    }
}
image-20220414161155615

线程强制执行_join

image-20220414161930089

public class Join_Test {
    public static void main(String[] args) throws InterruptedException {
        //开启线程
        MyJoin myJoin = new MyJoin();
        Thread vipThread = new Thread(myJoin);
        vipThread.start();

        for (int i = 0; i < 5; i++) {
            System.out.println("main-->"+i);
            if(i == 2){
                //强制执行vipThread
                vipThread.join();
            }
        }
    }
}

class MyJoin implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println("VIPt-->"+i);
        }
    }
}
image-20220414163501273

观测线程状态

image-20220414163641080

public class State_Test {
    public static void main(String[] args) {
        Thread t = new Thread(()->{
            //先睡5秒
            try {
                Thread.sleep(5000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("我刚才睡了5秒,现在醒了");
        });

        //观察启动前状态
        Thread.State t_State = t.getState();
        System.out.println(t_State);//NEW

        //观察启动后状态
        t.start();
        t_State = t.getState();
        System.out.println(t_State);//RUNNABLE

        //在 t 线程退出前,main线程每隔1秒观察输出一下 t 线程的状态
        while(t_State != Thread.State.TERMINATED){
            //每轮循环睡1秒
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            t_State = t.getState();//更新线程状态
            System.out.println(t_State);//输出线程状态
        }
    }
}
image-20220414172123249
image-20220414172331397

线程优先级

image-20220414192256285

优先级高的更可能先执行，但最终还是听cpu调度

一般情况下所有线程的优先级都默认是 5

package 线程状态;

public class Priority_Test {
    public static void main(String[] args) {
        //输出主线程Main的优先级
        System.out.println(Thread.currentThread().getName() + "-->" + Thread.currentThread().getPriority());

        MyPriority myPriority = new MyPriority();

        Thread t1 = new Thread(myPriority,"线程1");
        Thread t2 = new Thread(myPriority,"线程2");
        Thread t3 = new Thread(myPriority,"线程3");
        Thread t4 = new Thread(myPriority,"线程4");

        //先设置优先级,再启动
        t1.setPriority(Thread.MIN_PRIORITY);//MIN_PRIORITY = 1
        t2.setPriority(2);
        t3.setPriority(Thread.NORM_PRIORITY);//NORM_PRIORITY = 5
        t4.setPriority(Thread.MAX_PRIORITY);//MAX_PRIORITY = 10

        t1.start();
        t2.start();
        t3.start();
        t4.start();
    }
}

class MyPriority implements Runnable{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + "-->" + Thread.currentThread().getPriority());
    }
}
image-20220414191807296

并不是按照我们设定的优先级执行

原因

1.最终还是要听cpu的调度

2.可能和我的电脑是多核cpu有关，有8个核心(具体影响和关系不清楚)，也许此时5条线程不用等待一个核心的调度，直接5各跑一条线程，所以优先级的设置没什么影响，当然了这只是猜测

守护线程

image-20220414192829781

一个有趣的例子

如何用代码表示我的存在只为守护你?(你离开以后我也将消失)

//如何用代码表示我的存在只为守护你?(你离开以后我也将消失)
public class Daemon_Test {
    public static void main(String[] args) {
        PersonB you = new PersonB(36000);
        PersonA I = new PersonA();
        Thread Your_world = new Thread(you);
        Thread My_world = new Thread(I);
        //默认为 false 表示用户线程
        //守护线程将在用户线程结束一段时间之后结束
        My_world.setDaemon(true);
        Your_world.start();
        My_world.start();
    }
}

class PersonA implements Runnable{
    @Override
    public void run() {
        while(true) System.out.println("我守护你");
    }
}

class PersonB implements  Runnable{
    private int lifeTime;
    public PersonB(int lifeTime){
        this.lifeTime = lifeTime;
    }
    @Override
    public void run() {
        System.out.println("Hello world!");
        for (int i = 1; i <=lifeTime; i++) System.out.println("我在世界的第"+i+"天");
        System.out.println("Goodbye world!");
    }
}
posted @ 2022-04-14 20:07  Cornfield_Chase  阅读(42)  评论(0)    收藏  举报