线程的几种状态和方法介绍

最新推荐文章于 2022-12-06 15:41:05 发布

星际迷航‖

最新推荐文章于 2022-12-06 15:41:05 发布

阅读量819

点赞数 3

分类专栏： java 文章标签：多线程 java thread

本文链接：https://blog.csdn.net/weixin_44048140/article/details/105453244

版权

java 专栏收录该内容

13 篇文章 0 订阅

订阅专栏

线程的状态及转化

public enum State {
        NEW,
        RUNNABLE,
        BLOCKED,
        WAITING,
        TIMED_WAITING,
        TERMINATED;
    }

NEW：新建状态

用new创建的线程处于新建状态，此时他和其他的Java对象一样，仅仅在堆中分配了内存，没有调用start方法。

Runable：就绪状态

当线程对象被创建后，调用了start方法，线程就处于就绪状态，处于就绪状态的线程（其他的条件都满足，可以等待获取CPU的使用权），等待获取CPU的使用权

Running：运行状态

处于运行状态的线程也就占用的CPU，执行线程代码。只能有就绪状态的线程进入到运行状态

Blocked：阻塞状态

阻塞状态是指线程因为某些原因放弃CPU（缺少资源：IO、锁），暂时停止运行，当前的线程处于阻塞状态

Waiting：等待状态

当线程处于该状态，如果某个线程中的对象的wait()时，JVM就会将线程放入到等待池池

Timed_waiting:超时等待

sleep(long time)，jion(long time) 会使线程处于睡眠状态

Terminated：终止状态

当线程执行到run()方法结尾时，就进入到终止状态，该表示线程的生命周期结束

在这里插入图片描述
一个正常的线程只有四个状态：新建状态（NEW）、RUNNABLE（就绪状态）、运行状态（RUNING）、终止状态（TERMINATED）。
非正常状态：阻塞状态（BLOCKED）、等待状态（WAITING）、睡眠状态（TIME WAITING）。

线程的几种常用方法介绍

start(）方法是启用一个新线程、其实就是间接启动线程。真正的是start0()由OS来启动线程

注意：如果不调用start方法，线程永远不会被启动

文章所有的源码都是来自jdk1.8

public synchronized void start() {
        if (threadStatus != 0)
            throw new IllegalThreadStateException();
        group.add(this);
        boolean started = false;
        try {
            start0();
            started = true;
        } finally {
            try {
                if (!started) {
                    group.threadStartFailed(this);
                }
            } catch (Throwable ignore) {
            }
        }
    }
//native是调用本地方法、由操作系统调用（OS）
private native void start0();

java带有native修饰的方法，该方法的具体实现是非java语言实现，android中常见是用C或者C++语言实现。

native方法介绍
run（）线程所有的业务逻辑都在内部实现。
当一个类继承了Thread或者实现了Runnable接口，都要重写run方法，run方法中就是整个线程的功能实现

private Runnable target;
 @Override
    public void run() {
        if (target != null) {
            target.run();
        }
    }

Thread方法中对Runnable接口中的run重写也就是判断是否Runnable存在，不存在不做任何操作返回。

public class ThreadDemo extends Thread {
    @Override
    public void run() {
        System.out.println("线程");
    }

    public static void main(String[] args) {
        ThreadDemo threadDemo  = new ThreadDemo();
        threadDemo.run();
        //isAlive()就是判断线程是否被启动
        System.out.println(threadDemo.isAlive());//false
        threadDemo.start();
        System.out.println(threadDemo.isAlive());//true
    }
}

这里需要注意的是如果直接调用run方法不会启动线程（相当于一个对象调用普通方法一样），
当调用start方法以后，JVM会自动的运行run方法。

yield方法：线程让步（表示当前执行的线程愿意让出CPU上的执行时间片）
用来暂停正在执行的线程、并且让步于相同优先级或更高的优先级线程执行。线程会由运行状态转换为就绪状态，由系统自动分配，并不是调用yield方法当前线程暂时就不会被执行，有可能当前线程又会转变为运行状态。yield调用线程不会释放它所持有的锁。

public static native void yield();

join线程加入
线程A正在执行当线程A中调用B.join（），线程A会暂停执行，等待B执行完成、才继续执行。
在这里插入图片描述

public class ThreadDemo {
    Thread threadA;
    Thread threadB;

    public ThreadDemo() {
        threadA = new Thread(new Runnable() {
            @Override
            public void run() {
                int i = 0;
                while (i < 10) {
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + ": " + i++);
                    if (i == 5) {
                        try {
                            threadB.join();//加入B线程
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }
        }, "A");
        threadA.start();
        threadB = new Thread(new Runnable() {
            @Override
            public void run() {
                int i = 0;
                while (i < 10) {
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + ": " + i++);
                }
            }
        }, "B");
        threadB.start();
    }

    public static void main(String[] args) {
        new ThreadDemo();
    }
}

打印结果：
在这里插入图片描述

//一直等待子线程
public final void join() throws InterruptedException {
        join(0);
}
//millis毫秒处理
//nanos纳秒处理
public final synchronized void join(long millis, int nanos) throws InterruptedException {

        if (millis < 0) {
            throw new IllegalArgumentException("timeout value is negative");
        }

        if (nanos < 0 || nanos > 999999) {
            throw new IllegalArgumentException(
                                "nanosecond timeout value out of range");
        }

        if (nanos >= 500000 || (nanos != 0 && millis == 0)) {
            millis++;
        }
		//转为毫秒处理
        join(millis);
    }
//毫秒处理
public final synchronized void join(long millis)throws InterruptedException {
        long base = System.currentTimeMillis();
        long now = 0;
		//小于0抛出数据异常
        if (millis < 0) {
            throw new IllegalArgumentException("timeout value is negative");
        }
        if (millis == 0) {
        	//判断子线程是否结束，如果未结束就一直等待
            while (isAlive()) {
                wait(0);
            }
        } else {
        	//判断子线程结束是否已经够millis时间
            while (isAlive()) {
            	//delay表示线程还需要等待的时间
                long delay = millis - now;
                if (delay <= 0) {
                    break;
                }
                wait(delay);
                //表示线程已经执行的的时间
                now = System.currentTimeMillis() - base;
            }
        }
    }

interrupt中断线程
所谓的中断线程并不是真正意义的中断线程，其实是中断状态，如果只调用interrupt方法并不能中断线程

public class ThreadDemo extends Thread{
    @Override
    public void run() {
        int i = 0;
        while(i < 10){
            System.out.print(i+++" ");
            Thread.interrupted();
        }
    }

    public static void main(String[] args) {
        new ThreadDemo().start();
    }
}
//输出：0 1 2 3 4 5 6 7 8 9 
public class ThreadDemo extends Thread{
    @Override
    public void run() {
        int i = 0;
        while(i < 10){
            System.out.print(i+" ");
            i++;
            if( i == 5){
                interrupt();//中断操作将i == 4位置中断标志设置为true
            }
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                System.out.println("线程被中断");
                break;
            }
        }
    }

    public static void main(String[] args) {
        new ThreadDemo().start();
    }
}
//输出：0 1 2 3 4 线程被中断

也就是说如果一个线程处于可阻塞状态（join、wait、sleep等状态是）、那么线程退出阻塞状态、抛出一个InterruptedException异常。如果线程处于正常运行状态，即使你调用了interrupt方法线程也会正常运行。interrupt仅仅设置中断标志位，如果为true线程出现join等方法立即中断。

boolean isInterrupted() 判断是否发送了中断操作， true：发生中断操作 false:未发生中断操作。

sleep：线程休眠
那个线程调用，那个线程就休眠。
方法特点：
1、sleep休眠期间，会让出CPU使用权，但线程任然持有锁
2、sleep休眠时间到了之后，不会立即执行，而是线程由“阻塞状态”进入到“就绪状态”。

public static void sleep(long millis, int nanos)throws InterruptedException {
        if (millis < 0) {
            throw new IllegalArgumentException("timeout value is negative");
        }

        if (nanos < 0 || nanos > 999999) {
            throw new IllegalArgumentException(
                                "nanosecond timeout value out of range");
        }

        if (nanos >= 500000 || (nanos != 0 && millis == 0)) {
            millis++;
        }

        sleep(millis);
    }

后台线程（daemon）也可叫（守护线程）
是指在程序运行的时候在后台提供一种通用的服务的线程，并且线程不属于程序之中不可或缺的部分。因此，当所有的非后台线程结束时，程序也就终止了，同时会杀死所有的后台线程。GC就是一个后台线程。

public class ThreadDemo extends Thread{
    @Override
    public void run() {
        while (true){
            try {
                Thread.sleep(100);
                System.out.println(Thread.currentThread()+" "+this);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        for (int i = 0; i < 10; i++) {
            ThreadDemo t = new ThreadDemo();
            //设置后台线程必须在start方法之前完成
            t.setDaemon(true);
            t.start();
        }
        System.out.println("线程开始执行");
        Thread.sleep(100);
    }
}

/*执行结果：
线程开始执行
Thread[Thread-5,5,main]
Thread[Thread-0,5,main]
Thread[Thread-2,5,main]
Thread[Thread-7,5,main]
Thread[Thread-6,5,main]
Thread[Thread-4,5,main]
Thread[Thread-3,5,main]
Thread[Thread-1,5,main]
Thread[Thread-9,5,main]
Thread[Thread-8,5,main]
 */

如果上面的程序中main方法中sleep参数变小点可能有的线程未执行，就会被杀死。

Priority：线程优先级
每个线程都有各自的优先级，当有很多的线程处于就绪的状态下，系统会根据线程的优先级来决定那个线程进入运行状态，需要注意的是线程优先级高就不一定优先执行，只是它相对于优先级低的线程执行的概率大而已。

public final static int MIN_PRIORITY = 1;  //最小优先级
public final static int NORM_PRIORITY = 5;  //默认优先级
public final static int MAX_PRIORITY = 10;  //最大优先级

线程的默认值为NORM_PRIORITY = 5

public class ThreadDemo extends Thread{
    @Override
    public void run() {
        System.out.println(this);
    }

    public static void main(String[] args) throws InterruptedException {
        for (int i = 1; i <= 5; i++) {
            ThreadDemo threadDemo = new ThreadDemo();
            threadDemo.setPriority(i);
            threadDemo.start();
        }
    }
}
/**
 * Thread[Thread-3,4,main]
 * Thread[Thread-4,5,main]
 * Thread[Thread-0,1,main]
 * Thread[Thread-2,3,main]
 * Thread[Thread-1,2,main]
 */

由打印结果可知：优先级为1线程优先于优先级为2线程执行。

星际迷航‖

关注

3
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
线程的几种状态和方法介绍

线程的状态及转化public enum State { NEW, RUNNABLE, BLOCKED, WAITING, TIMED_WAITING, TERMINATED; }NEW：新建状态用new创建的线程处于新建状态，此时他和其他的Java对象一样，仅仅在堆中分配了内存，没有调用...
复制链接

扫一扫