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

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

线程状态

启动线程 获取CPU资源 线程自然执行完毕外部干涉终止线程 释放CPU资源 等待用户输入线程休眠 阻塞解除 创建状态 就绪状态 运行状态 死亡状态 阻塞状态
  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方法不推荐使用,被舍弃
JAVA-多线程 三 {多线程状态}JAVA从基础开始 -- 3

建议使用标志位方式,使线程自己停下来(当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() + "线程停止执行");
    }
}

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

线程强制执行_ 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);
        }
    }
}

JAVA-多线程 三 {多线程状态}JAVA从基础开始 -- 3
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)

上一篇:C++制作鼠标连点器


下一篇:x的平方根