JAVA-多线程 三 {多线程状态}JAVA从基础开始 -- 3

线程状态

1. new
   1）Thread t= new Thread线程对象一旦创建就进入到了新生状态
   2）当调用 start()方法,线程立即进入就绪状态,但不意味着立即调度执行
2. 就绪状态（CPU调度运行）
3. 阻塞状态（当调用sleep,wait或同步锁定，线程进入阻塞状态，就是代码不往下执行，阻塞事件解除后，重新进入就绪状态，等待CPU调度）
4. 运行状态（该状态中，线程体代码才真正执行）
5. dead（线程中断或者结束，一旦进入死亡状态，就不能重启）

线程方法

setPriority(int newPriority) :更改线程优先级
static void sleep(long millis):在指定的毫秒内让当前正在执行的线程休眠
void join():等待该线程终止
static void yield ：暂停当前正在执行的线程对象，并执行其他线程
void interrupt:中断线程 ，别用这个方式
boolean isAlive（）：测试是否出于活动状态

停止方法_stop (舍弃)

jdk中的stop方法不推荐使用，被舍弃

建议使用标志位方式，使线程自己停下来（当flag==false时）

//龟兔赛跑中
private boolean gameOver(int steps) {
        //判断有无胜利者
        if (winner != null) {
            //存在胜利者
            return true;
        } else {
            if (steps >= 100) {
                winner = Thread.currentThread().getName();
                System.out.println(winner + "胜利");
                return true;
            } else {
                return false;
            }
        }
    }
    public void run() {
        for (int i = 0; i < 100; i++) {
            //判断是否结束比赛
            boolean flag = gameOver(i + 1);
            if (flag) { //设置flag==true就退出线程
                break;
            }
            String user = Thread.currentThread().getName();
            if (user == "乌龟") {
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            } else if (user == "兔子") {
                if (i % 10 == 0) {
                    try {
                        Thread.sleep(400);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
            System.out.println(user + "跑了" + i);
        }
    }

休眠状态_sleep

sleep(时间)：指阻塞的毫秒数
sleep存在异常InterruptedException
sleep时间达到后线程进入就绪状态
sleep可以模拟网络延时，倒计时等。
每个对象都有一个锁，sleep不会释放锁

模拟网络延时：放大问题的发生性
例如;之前抢票案例，有可能两个人 同时抢到一张票的情况

模拟倒计时

package ThreadControl;


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

//模拟倒计时
public class ThreadSleep2 {
    private static Date startTime;
    public static Date getTime() {
        startTime = new Date(System.currentTimeMillis());//获取系统当前时间
        return startTime;
    }
    public static void main(String[] args) throws InterruptedException {
        while (true) {
            Thread.sleep(1000);
            System.out.println(new SimpleDateFormat("HH:mm:ss").format(getTime()));
//            if (num <= 0) {
//                break;
//            };
        }
    }
    public static void tenDown() throws InterruptedException {
        int num = 10;
        while (true) {
            Thread.sleep(1000);
            System.out.println(num--);
            if (num <= 0) {
                break;
            }
            ;
        }
    }
}

线程礼让_yield

◆礼让线程,让当前正在执行的线程暂停,但不阻塞
◆将线程从运行状态转为就绪状态
◆让cpu更新调度, 礼让不一定成功! 看cPU心情

package ThreadControl;

//礼让不一定成功  看CPU
public class TestYield {
    public static void main(String[] args) {
        MyYield myYield = new MyYield();
        new Thread(myYield, "a").start();
        new Thread(myYield, "b").start();
    }
}
class MyYield implements Runnable {

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + "线程开始执行");
        Thread.yield();//礼让
        System.out.println(Thread.currentThread().getName() + "线程停止执行");
    }
}

礼让成功

线程强制执行_ join

◆Join合并线程，待此线程执行完成后，再执行其他先，其他线程阻塞
◆可以想象成插队

package ThreadControl;

public class TestJoin implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println("线程VIP来了" + i);
        }
    }

    public static void main(String[] args) throws InterruptedException {
        TestJoin testJoin = new TestJoin();
        Thread thread = new Thread(testJoin);
        thread.start();

        //主线程
        for (int i = 0; i < 1000; i++) {
            if (i == 200) {
                thread.join();
            }
            System.out.println("main" + i);
        }
    }
}

thread.join();插队成功

线程状态观测_Thread.State

Thread.State

线程状态。转程可以处于以下状态之一
●NEW
尚未启动的程处于此状态
●RUNNABLE
在Java虚拟机中执行的括程处于此状态
●BLOCKED
被阳謇等待监视器锁定的线程处于此状态
●WNAITING
正在等待另一个线程执行特定动作的线程处于此状态。
●TIMED WAITING
正在等待另一个蜣程执行动作达到指定等待时间的线程处于此状态。a
●TERMINATED
已退出的线程处于此状态
····
一个线程可以在给定时间点处于一个状态，这些状态是不反映任何操作系统线程状态的虚拟状态

package ThreadControl;

//观测测试线程的状态
public class TestState {
    //观察状态
    static Thread.State state;

    static void gets(Thread thr) {
        state = thr.getState();
        System.out.println("线程状态：" + state);
    }

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

        //观测启动前
        gets(thread);

        //观测启动后
        thread.start();
        gets(thread);

        while (state != Thread.State.TERMINATED){
            Thread.sleep(500);
            gets(thread);
        }
    }
}

线程优先级

◆Java提供一个线程调度器来监控程序中启动后进入就绪状态的所有线程,线程调度器按照优先级决定应该调度哪个线程来执行。
◆线程的优先级用数字表示,范围从110
-◆ Thread. Min PR|OR|Y=1
-◆Thread. MAX PRIORITY=10
-◆Thread. NORM PRIORITY=5
◆使用以下方式改变或获取优先级
getpriority(). setpriority(int xxx)

package ThreadControl;


//测试线程的优先级
public class TestPoriorty extends Thread {

    public static void main(String[] args) {
        //主线程默认优先级
        System.out.println(Thread.currentThread().getName() + "----->" + Thread.currentThread().getPriority());

        MYPoriorty myPoriorty = new MYPoriorty();

        Thread t1 = new Thread(myPoriorty, "t1");
        Thread t2 = new Thread(myPoriorty, "t2");
        Thread t3 = new Thread(myPoriorty, "t3");
        Thread t4 = new Thread(myPoriorty, "t4");
        Thread t5 = new Thread(myPoriorty,"t5");

        //设置优先级再启动
        t1.start();

        t2.setPriority(1);
        t2.start();

        t3.setPriority(4);
        t3.start();

        t4.setPriority(Thread.MAX_PRIORITY);
        t4.start();

    }
}

class MYPoriorty implements Runnable {

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + "----->" + Thread.currentThread().getPriority());
    }
}

优先级越高，CPU先执行的概率越高
，，只是相对，CPU也可能选择优先级低的线程运行，这叫性能倒置（一般不会）

守护线程

◆线程分为用户线程和守护线程
◆虚拟机必须确保用户线程执行完毕
◆虚拟机不用等待守护线程执行完毕
◆如，后台记录操作日志、监控内存、垃圾回收或等待机制

package ThreadControl;

public class TestDaemon {
    public static void main(String[] args) {
        God god = new God();
        You you = new You();

        Thread yous = new Thread(you);
        Thread gods = new Thread(god);
        gods.setDaemon(true);//默认为false表示用户线程，正常的线程都是用户线程。


        gods.start();
        yous.start();
    }
}

//上帝
class God implements  Runnable{

    @Override
    public void run() {
        while (true){
            System.out.println("上帝保佑");
        }
    }
}
//你
class You implements Runnable{

    @Override
    public void run() {
        for (int i = 0; i < 10000; i++) {
            System.out.println("活着"+i);
        }
        System.out.println("Good Bye World");
    }
}

可以看到加了while（true）的上帝守护线程，也随着yous线程的停止而停止！

源码下载 0积分

文件下载: 所有java文件都在这 多线程.488).