线程五大状态

创建状态

 

阻塞状态

 

死亡状态

启动→

↘↙

↑待输入

↖↗

完成↑

求资源→

就绪状态

得资源→

运行状态

中止↑

  • Thread t = new Thread()线程对象一旦创建就进入到了新生状态
  • 当调用start()方法时线程立即进入就绪状态，但不意味着立即调度执行
  • CPU给了资源进入运行状态后的线程才真正执行线程体的代码块
  • 当调用sleep、wait或同步锁定时，线程进入阻塞状态，就是代码不继续往下执行，阻塞事件解除后，重新进入就绪状态等待CPU调度执行。
  • 线程中断或者结束，一旦进入死亡状态就不能再次启动。

方法

说明

setPriority(int newPriority)

更改线程的优先级

static void sleep(long mills)

在指定的毫秒数内让当前正在执行的线程体休眠

void join()

等待该线程终止

static void yield()

暂停当前正在执行的线程对象并执行其他线程

void interrupt()

中断线程（别用这方式）

boolean isAlive()

测试线程是否处于活动状态

线程停止

  • 推荐使用标志终止线程运行的方式如下
public class TestStop implements Runnable{
    //1.线程中定义线程体使用的标识
    private boolean flag = true;
    
    @Override
    public void run(){
        //2.线程体使用该标识
        while (flag){
            System.out.println("run...Thread");
        }
    }
    
    //3.对外提供方法改变标识
    public void stop(){
        this.flag = false;
    }
}
package com.kuang.state;

//测试stop
//1.建议线程正常停止-->利用次数，不建议死循环。
//2.建议使用标志位-->设置一个标志位
//3.不要使用stop或者destroy等过时或者JDK不建议使用的方法
public class TestStop implements Runnable{
    //1.设置一个标志位
    private boolean flag = true;
    
    @Override
    public void run(){
        int j = 0;
        while(flag){
            System.out.println("run...Thread" + j++);
        }
    }
    
    //2.设置一个公开的方法停止线程，转换标志位。
    public void stop(){
        this .flag = false;
    }
    
    public static void main(String[] args){
        TestStop testStop = new TestStop(); 
        new Thread(testStop).start();
        
        for (int i=0; i<1000; i++){
            System.out.println("main" + i);
            if (i == 900){
                //调用stop方法切换标志位，让线程停止。
                testStop.stop();
                System.out.println("该线程停止");
            }
        }
    }
}

线程休眠

  • sleep（time）指定当前线程阻塞的毫秒数
  • sleep存在异常interrupted Exception
  • sleep时间达到后线程进入就绪状态
  • sleep可以模拟网络延时、倒计时等
  • 每一个对象都有一个锁，sleep不会释放锁。
package com.kuang.state;
//模拟网络延时，可以放大问题的出现概率，这里还会出现多个线程抢一个对象的线程不安全性问题。
public class TestSleep{
    //参考之前的线程抢票问题
}
package com.kuang.state;

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

线程礼让

  • 礼让线程，让当前正在执行的线程暂停，但不阻塞。
  • 将线程从运行状态转换为就绪状态
  • 让CPU重新调度，礼让不一定成功，看CPU心情。
package com.kuang.state;
//测试礼让线程，虽然礼让不一定成功，看CPU心情。
public class TestYield{
    public static void main(String[] args){
        MyYield myYield1 = new MyYield1();
        MyYield myYield2 = new MyYield2();
        
        new Thread(myYield1, "A").start();
        new Thread(myYield2, "B").start();
    }
}

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

class MyYield2 implements Runnable{
        @Override
    public void run(){
        System.out.println(Thread.currentThread().getName + "线程开始执行");
        System.out.println(Thread.currentThread().getName + "线程停止执行");
    }
}

join插队线程

  • join合并线程，待此线程执行完成后，再执行其他线程，此时其他线程阻塞。
  • 可以想象成插队
public class TestJoin implements Runnable{
    public static void main(String[] args) throws InterruptedException{
        TestJoin testJoin = new TestJoin();
        Thread thread = new Thread(testJoin);
        thread.start();
        
        for (int i=0; i<100; i++){
            if (i == 50){
                thread.join(); //main线程阻塞
            }
            System.out.println("mian..." + i);
        }
    }
    @Override
    public void run(){
        for (int i=0; i<1000; i++){
           System.out.println("join" + i);
        }
    }
}
package com.kuang.state;
//测试join方法
public class TestJoin implements Runnable{
    @Override
    public void run(){
        for (int i=0; i<1000; 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<500; i++){
            if (i==200){
                thread.join(); //插队
            }
            System.out.println("mian" + i);
        }
    }
}
  • 线程里少用插队方法，容易让线程阻塞。

线程状态观测

  • 线程状态：Thread.State（去JDK帮助文档查看）

状态标志

含义

NEW

尚未启动的线程处于此状态

RUNNABLE

在Java虚拟机中执行的线程处于此状

BLOCKED

被阻塞等待监视器锁定的线程处于此状态

WAITING

正在等待另一个线程执行特定动作的线程处于此状态

TIMED_WAITING

正在等待另一个线程执行动作达到指定等待时间的线程处于此状态

TERMINATED

已退出的线程处于此状态

  • 一个线程可以在给定时间点处于一个状态，这些状态是不反映任何操作系统线程状态的虚拟机状态。
package com.kuang.state;
//观察测试线程的状态
public class TestState{
    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("*******")
        });
        
        //观察状态
        Thread.State state = thread.getState();
        System.out.println(state); //NEW
        
        //观察启动后状态
        thread.start(); //启动线程
        state = thread.getState();
        System.out.println(state); //RUN
        
        //用main函数主线程去监测子线程状态，只要线程不终止就一直输出状态。
        while (state != Thread.State.TERMINATED){
            Thread.sleep(1000);
            state = thread.getState(); //更新线程状态
            System.out.println(state); //输出状态
        }
    }
}
  • 线程只能启动一次

线程的优先级

  • Java提供一个线程调度器来监控程序中启动后进入就绪状态的所有线程，线程调度器按照优先级来决定应该调度哪个线程来执行。
  • 线程优先级用数字表示，范围从1~10。
  • Thread.MIN_PRIORITY = 1;
  • Thread.MAX_PRIORITY = 10;
  • Thread.NORM_PRIORITY = 5;
  • 使用一下方式获取或者改变线程优先级
  • getPriority().setPriority(int xxx);
  • 优先级的设定在start()调度之前
package com.kuang.state;

import java.sql.SQLOutput;
//测试线程的优先级
public class TestPriority{
    public static void main(String[] args){
        //打印主线程无法改变的默认优先级
        System.out.println(Thread.currentThread().getName() + "-->" + Thread.currentThread().getPriority());
        
        MyPriority myPriority = new MyPriority();
        Thread t1 = new Thread(myPriority);
        Thread t2 = new Thread(myPriority);
        Thread t3 = new Thread(myPriority);
        Thread t4 = new Thread(myPriority);
        Thread t5 = new Thread(myPriority);
        Thread t6 = new Thread(myPriority);
        
        //先设置优先级再启动
        t1.start(); //默认优先级是5
        
        t2.setPriority(1);
        t2.start();
        
        t3.setPriority(4);
        t3.start();
        
        t4.setPriority(Thread.MAX_PRIORITY); //最高是10
        t4.start();
        
        t5.setPriority(8);
        t5.start();
        
        t6.setPriority(7);
        t6.start();
    }
}

class MyPriority implements Runnable{
    @Override
    public void run(){
        System.out.println(Thread.currentThread().getName() + "-->" + Thread.currentThread().getPriority());
    }
}
  • 线程优先级低只是意味着获得优先调度的概率低一点，但不一定优先级低就不会是优先调用的第一个，这些都看CPU心情。

守护线程

  • 线程分为用户线程和守护（daemon）线程
  • 虚拟机必须确保用户线程执行完毕
  • 虚拟机不用等待守护线程执行完毕
  • 举例：后台记录操作日志，监控内存，垃圾回收等待。
  • 快捷键：
  • 点击类名按下→ALT + ENTER = 重写接口内方法等
  • ALT + INSERT = 生成构造函数、重写父类方法等
  • CTRL + ALT + T = 生成异常捕获结构
package com.kuang.state;
//测试守护线程之上帝守护你
public class TestDaemon{
    public static void main(String[] args){
        God god = new God();
        You you = new You();
        
        Thread thread = new Thread(god);
        thread.setDaemon(true); //默认是false表示是用户线程，一般线程都是用户线程。
        thread.start(); //上帝守护线程启动
        new Thread(you).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<36500; i++){
            System.out.println("你一生都开心的活着");
        }
        System.out.println("----goodbye world!----");
    }
}
  • 就好像人们看不到的 gc（）垃圾管理线程一样，主线程没了它怎么停的都不重要了。