Java多线程编程7--拾遗增补--线程的状态(new,runnable,terminated,timed_waiting,waiting,blocked)

线程对象在不同的运行时期有不同的状态,状态信息就存在于Thread内部类的State枚举类中

    public enum State {
        /**
         * new状态是线程实例化后还从未执行start()方法时的状态
         */
        NEW,

        /**
         * runnable状态是线程进人运行的状态
         */
        RUNNABLE,

        /**
         * blocked状态出现在某一个线程在等待锁的时候。
         */
        BLOCKED,

        /**
         * waiting是线程执行了Object.wait()方法后所处的状态
         */
        WAITING,

        /**
         * timed_waiting代表线程执行了Thread.sleep()方法,
         * 呈等待状态,等待时间到达,继续向下运行。
         */
        TIMED_WAITING,

        /**
         * terinated是线程被销毁时的状态,线程完全执行了
         */
        TERMINATED;
    }

    //该方法能获取线程的状态
    public State getState() {
        // get current thread state
        return sun.misc.VM.toThreadState(threadStatus);
    }

1、验证new, runnable和terminated

下面使用代码的方式验证线程所有的状态值,了解线程的状态有助于程序员监控线程对象所处的情况,比如哪些线程从未启动,哪些线程正在执行,哪些线程正在阻塞,哪些线程正在等待,哪些线程已经销毁了,等等。这些是与线程生命周期相关的信息。

首先验证的是new, runnable及terminated状态,new状态是线程实例化后还从未执行start()方法时的状态,而runnable状态是线程进入运行的状态,terinated是线程被销毁时的状态。

public class MyThread extends Thread {
    public MyThread() {
        System.out.println("构造方法中的状态:" + Thread.currentThread().getState());
    }

    @Override
    public void run() {
        System.out.println("run方法中的状态:" + Thread.currentThread().getState());
    }
}
public class Run {
    public static void main(String[] args) throws InterruptedException {
        MyThread thread = new MyThread();
        System.out.println("main方法中的状态1:" +thread.getState());
        Thread.sleep(1000);
        thread.start();

        Thread.sleep(1000);
        System.out.println("main方法中的状态2:" + thread.getState());
    }
}
构造方法中的状态:RUNNABLE

main方法中的状态1:NEW

run方法中的状态:RUNNABLE

main方法中的状态2:TERMINATED

2、验证TIMED_WAITING

TIMED_WAITING代表线程执行了Thread.sleep()方法,呈等待状态,等待时间到达,继续向下运行。

public class MyThread extends Thread {
    @Override
    public void run() {
        try {
            System.out.println("begin sleep");
            Thread.sleep(4000);
            System.out.println("  end sleep");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
public class Run {
    public static void main(String[] args) throws InterruptedException {
        MyThread thread = new MyThread();
        thread.start();

        //要验证timed_waiting,这里的睡眠时间要小于run方法里睡眠时间
        Thread.sleep(1000);
        System.out.println("main方法中的状态:" + thread.getState());
    }
}
begin sleep

main方法中的状态:TIMED_WAITING

end sleep

要注意:Run类里的睡眠时间要小于MyThread类里睡眠时间,不然结果为:

begin sleep

end sleep

main方法中的状态:TERMINATED

3、验证BLOCKED

BLOCKED状态出现在某一个线程在等待锁的时候。

public class MyService {
    public synchronized static void serviceMethod() {
        try {
            System.out.println(Thread.currentThread().getName()
                    + " 进入了业务方法!" );
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
public class MyThread1 extends Thread {
    @Override
    public void run() {
        MyService.serviceMethod();
    }
}
public class Run {
    public static void main(String[] args) throws InterruptedException {
        MyThread1 t1 = new MyThread1();
        t1.setName("AA");
        t1.start();
        System.out.println("main方法中的t1状态:" + t1.getState());

        MyThread1 t2 = new MyThread1();
        t2.setName("BB");
        t2.start();
        Thread.sleep(1000);
        System.out.println("main方法中的t2状态:" + t2.getState());
    }
}
AA 进入了业务方法!

main方法中的t1状态:RUNNABLE

main方法中的t2状态:BLOCKED

BB 进入了业务方法!

从控制台打印的结果来看,t2线程一直在等待t1释放锁,所以t2当时的状态就是BLOCKED

4、验证WAITING

状态WAITING是线程执行了Object.wait()方法后所处的状态。

public class MyLock {
    public static final Byte lock = new Byte("0");
}
public class MyThread extends Thread {
    @Override
    public void run() {
        try {
            synchronized (MyLock.lock) {
                MyLock.lock.wait();
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
public class Run {
    public static void main(String[] args) throws InterruptedException {
        MyThread t = new MyThread();
        t.start();
        Thread.sleep(1000);  //如果没有,t的状态就是RUNNABLE
        System.out.println("main方法中的t状态:" + t.getState());
    }
}
main方法中的t状态:WAITING

执行wait()方法后线程的状态枚举值就是WAITING

时间: 2024-10-04 21:26:06

Java多线程编程7--拾遗增补--线程的状态(new,runnable,terminated,timed_waiting,waiting,blocked)的相关文章

Java多线程编程7--拾遗增补--线程组

可以把线程归属到某一个线程组中,线程组中可以有线程对象,也可以有线程组,组中还可以有线程.这样的组织结构有些类似于树的形式,如图所示. 线程组的作用是,可以批量的管理线程或线程组对象,有效地对线程或线程组对象进行组织. 1.线程对象关联线程组:1级关联 所谓的1级关联就是父对象中有子对象,但并不创建子孙对象.这种情况经常出现在开发中,比如创建一些线程时,为了有效地对这些线程进行组织管理,通常的情况下是创建一个线程组,然后再将部分线程归属到该组中.这样的处理可以对零散的线程对象进行有效的组织与规划

java多线程编程(1) 线程的基本知识

在前面研究过多线程与进程的区别. 这里在稍微总结一下: 进程:程序动态的一次执行过程. 线程:可以只是程序员的一部分的执行过程 每个进程有多个线程组成,在java程序中,至少两个线程一个是垃圾回收线程和main线程. 线程占有的资源更少,早java中就是每个线程都有自己的工作区,就是有自己独立的栈空间.多个线程共享一些内存资源,堆是共享的. 多线程的力度小,并发度高,这样系统的吞吐量就很大,只有好处吗?调度和执行线程是需要资源的,就是像是数据库中的索引和数据库中的锁一个道理,并发会带来什么问题呢

java多线程编程--如何开始一个线程

如何开始一个线程 1. java多线程的实现方式 1.1 继承Thread类 定义类如下: public SubThread extends Thread { @override public void run() { ... } } 使用时: Thread subThread = new SubThread(); subThread.start(); 可以使用Thread类已有的函数进行操作. 1.2 实现Runnable接口 定义类如下: public SubThread implement

java多线程编程--如何终止一个线程

1. Thread.stop()函数 stop()函数终止线程就像是强行拔掉电源线关机一样,可能会带来未知风险,因此目前不再推荐使用这种方式.请忘记它吧~~ 2. 改变标志变量状态 通常我们会在线程中使用一个标志变量来控制线程的运行,如: public class TestCallable implements Runnable { private boolean running = true; public void stop() { this.running = false; } publi

Java多线程编程(三)线程的优先级、同步与死锁

线程的优先级: 线程的优先级分为三种,分别是: 1-MIN_PRIORITY 10-MAX_PRIORITY 5-NORM_PRIORITY 如果什么都不设置默认值是5 线程的优先级可以影响线程的执行顺序,当然这里指的是有可能影响,不会一定影响.在默认状态下(比如说主线程)它的默认值是5 具体代码演示: package com.yeqc.thread; class ThRun implements Runnable{ @Override public void run() { for(int i

Java多线程编程基础之线程对象

在进入java平台的线程对象之前,基于基础篇(一)的一些问题,我先插入两个基本概念. [线程的并发与并行] 在单CPU系统中,系统调度在某一时刻只能让一个线程运行,虽然这种调试机制有多种形式(大多数是时间片轮巡为主),但无论如何,要通过不断切换需要运行的线程让其运行的方式就叫并发(concurrent).而在多CPU系统中,可以让两个以上的线程同时运行,这种可以同时让两个以上线程同时运行的方式叫做并行(parallel). 在上面包括以后的所有论述中,请各位朋友谅解,我无法用最准确的词语来定义储

Java多线程编程模式实战指南(二):Immutable Object模式--转载

本文由本人首次发布在infoq中文站上:http://www.infoq.com/cn/articles/java-multithreaded-programming-mode-immutable-object.转载请注明作者: 黄文海 出处:http://viscent.iteye.com. 多线程共享变量的情况下,为了保证数据一致性,往往需要对这些变量的访问进行加锁.而锁本身又会带来一些问题和开销.Immutable Object模式使得我们可以在不使用锁的情况下,既保证共享变量访问的线程安

java多线程编程

一.多线程的优缺点 多线程的优点: 1)资源利用率更好2)程序设计在某些情况下更简单3)程序响应更快 多线程的代价: 1)设计更复杂虽然有一些多线程应用程序比单线程的应用程序要简单,但其他的一般都更复杂.在多线程访问共享数据的时候,这部分代码需要特别的注意.线程之间的交互往往非常复杂.不正确的线程同步产生的错误非常难以被发现,并且重现以修复. 2)上下文切换的开销当CPU从执行一个线程切换到执行另外一个线程的时候,它需要先存储当前线程的本地的数据,程序指针等,然后载入另一个线程的本地数据,程序指

Java 多线程编程两个简单的例子

/** * @author gao */ package gao.org; public class RunnableDemo implements Runnable{ @Override public void run() { // TODO Auto-generated method stub for(int i=0;i<10;i++){ System.out.println("新线程输出:"+i); } } public static void main(String []