精华内容
下载资源
问答
  • 线程生命周期和人有生老病死一样,线程也有它完整的生命周期:1. 新生(New):代表线程的对象已经被初始化,但尚未运行run方法。2. 可执行(Runnable):线程正在运行run方法,但这只说明线程目前处于的状态,如果...

    线程的生命周期

    和人有生老病死一样,线程也有它完整的生命周期:

    1.         新生(New):代表线程的对象已经被初始化,但尚未运行run方法。

    2.         可执行(Runnable):线程正在运行run方法,但这只说明线程目前处于的状态,如果系统没有能力拨出CPU执行时间给线程,线程就“不执行”,这里的“不执行”不代表“停滞”或“死亡”。

    3.         停滞(Blcked):线程是可以执行的,但由于某些因素的阻碍处于停滞状态,系统排程器略过了应给的CPU执行时间。

    4.         死亡(Dead):线程的正式结束方式,run方法执行完毕并返回。

    如果用我们上学来解释线程的生命周期则更容易理解:

    1.         我们在进行了一系列考察后选择了这个学校,填写入学登记表、交纳学费、打印听课证、获取课程表,这时我们已经成功的“初始化”了求学的线程;

    2.         当我们第一天上课的时候,求学线程就处于“可执行”状态,法定节假日只是学校没有能力来安排课程,并不是求学线程的“停滞”或“死亡”;

    3.         求学的过程是很艰辛且漫长的,如果哪天晚上我一高兴,和几个哥们对酒当歌,直喝的月朦胧、鸟朦胧,宿舍的床铺也朦胧,第二天早晨只觉得头晕脑胀、四肢无力,这时才想起求学线程还在进行中,可又偏偏心有余而力不足,不得已打电话给班主任老师,由于某某原因,需要请假一天,无奈求学线程被停滞;

    4.         有起点就会有终点、有开始就会有结束,在我们顺利的通过了毕业考试后,求学线程便理所应当的画上一个圆满的句号。

    在Thread中应该如何更好的控制整个生命周期,我们先来看看Thread类代码,下面的方法会影响到线程的生命周期,为了方便省略了实现细节:

    package java.lang;

    public class Thread{

    public void start(); // 线程的启动

    public void run(); // 线程体

    public void stop(); // 已废弃

    public void resume(); // 已废弃

    public void suspend(); // 已废弃

    public static void sleep(long millis); // 在指定的毫秒数内让当前正在执行的线程休眠

    public static void sleep(long millis, int nanos); // 同上,增加了纳秒参数

    public boolean isAlive(); // 测试线程是否处于活动状态

    public void interrupt(); // 中断线程

    public boolean isInterrupted(); // 测试线程是否已经中断

    public static boolean interrupted(); // 测试当前线程是否已经中断

    public void join() throws InterruptedException; // 等待该线程终止

    public void join(long millis) throws InterruptedException; // 等待该线程终止的时间最长为 millis 毫秒

    public void join(long millis, int nanos) throws InterruptedException; // 等待该线程终止的时间最长为 millis 毫秒 + nanos 纳秒

    }

    重点:停滞状态

    1.         通过sleep(millis)使线程进入休眠,该方法在指定的时间内无法被唤醒。

    2.         通过suspend()暂停线程,除非线程收到resume()消息,否则不会变回可执行状态。(该方法已经废弃)

    3.         通过wait() 暂停线程,除非收到notify()或notifyAll()消息,否则不会变回可执行状态。wait()和notify()两个函数都是Object的一部分,不像sleep()那样属于Thread,这是因为两个函数会取用对象的机锁,而机锁正是每个继承自Object对象都拥有的。如此一来我们可以把wait()置于任何同步函数内,也只能在同步函数中调用wait()。sleep()、suspend()、resume()可以在所有非同步函数中使用,因为它们不会取用机锁。

    4.         线程正在等待某个IO动作完成。

    5.         线程正尝试调用一个同步对象,但尚未取得该对象机锁。

    下面的例子表现了一个完整的线程生命周期:

    1.[代码]TestMain6.java

    import java.awt.event.ActionEvent;

    import java.awt.event.ActionListener;

    import javax.swing.JButton;

    import javax.swing.JFrame;

    import javax.swing.JLabel;

    import javax.swing.JPanel;

    import javax.swing.JTextField;

    /**

    * 线程的生命周期

    * 一个线程的生命周期分为四种状态:新生、可执行、停滞、死亡

    * 我们在本例中对一个线程进行上述操作

    * @author 五斗米

    * @blog http://blog.csdn.net/mq612

    */

    public class TestMain6 extends JFrame {

    private MyThread thread = null; // 要操作的线程

    private JTextField text = null; // 运行计数器

    private JLabel label = null; // 显示线程运行状态

    private JButton newButton = null, startButton = null,

    waitButton = null, stopButton = null; // 新生、启动、停滞、死亡 四个按钮

    private boolean isWait = false; // 是否为暂停状态

    /**

    * 构造一个银行存取款界面

    */

    public TestMain6(){

    super("线程生命周期");

    text = new JTextField(25);

    label = new JLabel(" ");

    newButton = new JButton("新生");

    newButton.addActionListener(new ActionListener(){

    public void actionPerformed(ActionEvent e) {

    thread = new MyThread();

    label.setText("新生");

    }

    });

    startButton = new JButton("执行");

    startButton.addActionListener(new ActionListener(){

    public void actionPerformed(ActionEvent e) {

    thread.start();

    label.setText("执行");

    }

    });

    waitButton = new JButton("停滞");

    waitButton.addActionListener(new ActionListener(){

    public void actionPerformed(ActionEvent e) {

    if(!isWait){ // 如果不是暂停状态

    isWait = true;

    waitButton.setText("继续");

    }else{

    isWait = false;

    synchronized (thread){

    thread.notify(); // 继续

    }

    waitButton.setText("停滞");

    }

    }

    });

    stopButton = new JButton("死亡");

    stopButton.addActionListener(new ActionListener(){

    public void actionPerformed(ActionEvent e) {

    if(isWait){

    isWait = false;

    synchronized (thread){

    thread.notify();

    }

    }

    thread.quit();

    label.setText("死亡");

    }

    });

    JPanel pane = new JPanel();

    pane.add(label);

    pane.add(text);

    pane.add(newButton);

    pane.add(startButton);

    pane.add(waitButton);

    pane.add(stopButton);

    this.getContentPane().add(pane);

    this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

    this.setSize(300, 200);

    this.setLocationRelativeTo(null);

    this.setVisible(true);

    }

    class MyThread extends Thread{

    private int i = 0; // 计数器数值

    private boolean b = true; // 控制循环,也就是控制线程结束的boolean变量

    public MyThread(){

    i = 0;

    text.setText(Integer.toString(i));

    }

    public void quit(){

    this.b = false;

    }

    public synchronized void run(){

    while(b){

    if(isWait){ // 这里决定了线程何时停滞

    try {

    wait(); // 只能在同步函数中调用wait()

    } catch (InterruptedException ex) {

    ex.printStackTrace();

    }

    }

    text.setText(Integer.toString(i++));

    try {

    this.sleep(100);

    } catch (InterruptedException ex) {

    ex.printStackTrace();

    }

    }

    }

    }

    public static void main(String [] args){

    new TestMain6();

    }

    }

    展开全文
  • 简述线程生命周期

    2020-09-03 21:30:12
    线程生命周期包含5个阶段,包括新建,就绪,运行,阻塞,销毁。 新建:就是使用new方法,new出来的线程; 就绪:调用的线程的start()方法后,线程处于等待CPU分配资源阶段,谁先抢到CPU资源,谁开始执行; 运行:...

    线程的生命周期包含5个阶段,包括新建,就绪,运行,阻塞,销毁。
    新建:就是使用new方法,new出来的线程;
    就绪:调用的线程的start()方法后,线程处于等待CPU分配资源阶段,谁先抢到CPU资源,谁开始执行;
    运行:当就绪的线程被调度并获得CPU资源时,便进入运行状态,run方法定义了线程的操作和功能;
    阻塞:在运行状态的时候可能因为某些原因导致运行状态的线程变成了阻塞状态。比如sleep(),wait(),之后线程就处于了阻塞状态,这个时候需要其他机制将处于阻塞状态的线程唤醒,比如调用notify或者notifyAll()方法。wait超过时间后,进入锁池,同步锁释放后进入就绪状态。唤醒的线程不会立刻执行run方法,它们要再次等待CPU分配资源进入运行状态。
    销毁:如果线程正常执行完毕后或线程被提前强制性的终止或出现异常导致结束,那么线程就要被销毁,释放资源。

    展开全文
  • 在每个线程中都有自己的局部变量表、程序计数器、以及生命周期等,本章节将描述什么是线程生命周期。 首先线程生命周期可分为五个重要阶段: new runnable running blocked terminated 具体流程如图所示(该图...

    生命周期概述

    在每个线程中都有自己的局部变量表、程序计数器、以及生命周期等,本章节将描述什么是线程的生命周期。
    首先线程的生命周期可分为五个重要阶段:

    • new
    • runnable
    • running
    • blocked
    • terminated

    具体流程如图所示(该图来源于《Java高并发编程详解》)

    1.new状态

    当我们采用new关键字创建一个Thread对象时,该对象就是一个new状态,但是他并不是可执行状态,严格来讲这并不是线程,只是一个普通的对象,只有当他调用start方法的时候,才能称之为线程。

    2.runnable状态

    当线程对象调用start方法时,线程就会进入runnable状态,这可以说是一个准备状态,因为就算线程启动,但是还是需要CPU调度才能得到执行。所以在没有被CPU调度之前,只能是runnable可执行状态,说明该线程是可以运行,但是并没有轮到他运行。

    3.running状态

    线程的运行状态,当CPU轮询到这个线程,那么这个线程将从runnable状态到running状态,当进入running状态就意味着该线程开始执行其run方法

    4.blocked状态

    线程的阻塞状态,线程进入阻塞的原因有,

    • 线程调用wait,sleep方法
    • 进行某个I/O阻塞操作时
    • 获取某个锁资源,如synchronized锁住的资源

    当进入blocked状态时,可以切换如以下几种状态

    • 直接进入terminated状态,调用stop方法
    • 线程阻塞操作结束,进入runnable状态
    • 线程完成指定休眠时间,进入runnable状态
    • wait线程被其他现场notify/notifyAll唤醒,进入runnable状态
    • 线程获取到了某个锁资源,进入runnable状态
    • 线程阻塞被打断,其他线程调用interrupt方法,进入runnable状态

    5.terminated状态

    线程结束状态,线程的最终状态,在该状态下线程将不会切换到其他任何状态进入terminated状态

    扩展-CPU调度简单描述

    可能在上面描述runnable的时候有很多人会不理解什么是CPU调度,其实在一台电脑中,一个CPU是不可能同时执行多个线程的,比如2核的CPU就只能同时执行两个线程,那么我们的CPU是如何完成并发操作的呢。那就是时间片。CPU会给每个线程分配一个时间段,我们称作为时间片,比如有4个线程同时执行,我们这里有一个一核的CPU,那么线程1拿到了CPU给他执行的时间片,他就允许线程1执行,那他就是running状态,那么其他没有被CPU分配的,那就是runnable状态,那么当线程1被分配的时间执行完时,就会4个线程重新抢夺时间片(注:是时间片完成,不是线程执行完成,线程执行完时间片拥有的时间后会记录当前位置,抢到时间片后继续执行,直到线程完成任务),那么抢到时间片的线程就会进入running状态,其他线程进入runnable状态,这种就是CPU时间片的轮询调度。可能会有人问到,为什么我们看那些线程都是同时进行,如果是这种时间片抢夺等待的方式,不会出现卡顿么,答案是不会的,因为时间片的轮询是很快的,所以在肉眼中看到就是同时进行的。

    展开全文
  • 线程生命周期简述

    2020-05-28 08:55:04
    线程生命周期包含5个阶段,包括:新建、就绪、运行、阻塞、销毁。 新建:就是刚使用new方法,new出来的线程; 就绪:就是调用的线程的start()方法后,这时候线程处于等待CPU分配资源阶段,谁先抢的CPU资源,谁...

    线程的生命周期包含5个阶段,包括:新建就绪运行阻塞销毁

    • 新建:就是刚使用new方法,new出来的线程;
    • 就绪:就是调用的线程的start()方法后,这时候线程处于等待CPU分配资源阶段,谁先抢的CPU资源,谁开始执行;
    • 运行:当就绪的线程被调度并获得CPU资源时,便进入运行状态,run方法定义了线程的操作和功能;
    • 阻塞:在运行状态的时候,可能因为某些原因导致运行状态的线程变成了阻塞状态,比如sleep()、wait()之后线程就处于了阻塞状态,这个时候需要其他机制将处于阻塞状态的线程唤醒,比如调用notify或者notifyAll()方法。唤醒的线程不会立刻执行run方法,它们要再次等待CPU分配资源进入运行状态;
    • 销毁:如果线程正常执行完毕后或线程被提前强制性的终止或出现异常导致结束,那么线程就要被销毁,释放资源;

    完整的生命周期图如下:

                                    

     

    JDK线程类状态描述如下:

    展开全文
  • java线程生命周期

    2018-07-12 16:58:08
    Java 线程状态 在线程生命周期中,它要经过新建(New)、就绪(Runnable)、运行(Running)、阻塞(Blocked)和死亡(Dead)5种状态创建:可以理解我们new 了一线程对象;就绪:new 的线程对象调用了 start()方法,但...
  • 线程和进程区别,生命周期,线程理解 1. 线程 2. 进程 3. 线程生命周期 4. 线程理解
  • 1. 线程生命周期 线程生命周期图 新建状态(New) 当线程对象创建后,即进入新建状态,如:Thread t = new MyThread(); 就绪状态(Runnable) 当调用线程对象的start()方法时,线程即进入就绪状态。处于就绪...
  • 11 线程生命周期状态

    2020-08-09 00:13:49
    1.线程生命周期(5种状态) 在线程生命周期中,它会经过新建(New)、就绪(Running)、阻塞(Blocked)和死亡(Dead)五种状态。由于CPU在多条线程之间切换,于是线程状态会多次在就绪和运行之间切换 新建状态...
  • 线程的五种基本状态 新建态 new 就绪态 等cpu yield 运行态 ...getState() 返回当前线程对象的状态...state的六种状态简述 NEW:新建态,没有开启线程 RUNNABLE:就绪态和运行态 BLOCKED:阻塞态(等待锁、I\O) WAI
  • 线程生命周期(状态)

    千次阅读 2019-05-31 19:37:44
    1. 线程生命周期(状态) 当线程被创建并启动以后,它既不是一启动就进入了执行状态,也不是一直处于执行状态。 在线程的生命周期中,它要经过新建(New)、就绪(Runnable)、运行(Running)、阻塞 (Blocked)和死亡...
  • Java线程生命周期及五种基本状态

    千次阅读 多人点赞 2020-02-06 20:11:39
    一、Java中线程生命周期图 用这张图可以概述大多的线程创建及运行,简单易懂的掌握线程知识!!! 二、线程的五种基本状态 新建状态(New):至今尚未启动的线程的状态。线程刚被创建,但尚未启动。如:Thread t = ...
  • 简述servlet生命周期

    2019-10-15 20:42:09
    简述servlet生命周期 1、加载 2、实例化 3、初始化init() 4、处理客户请求 5、销毁destroy() 以下代码在页面上的输出值是什么: ;%> ; %> ! int x=7; %> x = , 答案:x=5,3 解释:;%>是局部变量,; %>...
  • 线程生命周期对于掌握真正掌握多
  • 线程生命周期,把图转化为文字就是: 线程通过new方法创建,调用start()方法,线程进入就绪状态,等待系统的调度(时间片轮转调度)。当系统调度,进入运行状态。正常结束或者异常退出,进程进入死亡状态。处于...
  • Java线程生命周期

    2018-03-22 22:03:52
    以下类图展示了线程生命周期中不同的状态。我们可以创建一个线程并启动它,但是线程状态从Runnable、Running、Blocked等状态的变化取决于系统线程调度器,java本身并不能完全控制。 线程状态 New...
  • java语言使用Thread类及其子类的对象来表示线程,在它的一个完整的生命周期中通常要经历以下的五种状态,这也就是对线程生命周期概括: 1.新建: 当一个Thread类或其子类的对象被声明并创建时,新生的线程对象处于...
  • 楼主决定要好好地把Java的多线程给看一下,所以特地来写下博客,内容大部分都是摘抄自网上看到的资料或者书籍,能给出链接的我会给出链接。嗯,希望大家跟楼主一起抱团,加油加油↖(^ω^)↗ 1.多线程相关概念 程序...
  • 线程生命周期包括5个阶段:新建、就绪、运行、阻塞、销毁。 新建:刚使用new出来的线程对象 就绪:调用start( )方法后,这时线程处于等待CPU分配资源阶段(就是谁抢到CPU资源,谁就执行) 运行:当就绪状态的...
  • Java线程生命周期各个状态总结

    千次阅读 2017-11-12 22:24:22
    最近在学习Java技术相关基础知识,准备边学习便总结,写这个博客主要是做个记录方便自己回查,但然顺便也就方便了别人,这个作为Java...1、生命状态分类根据Java API文档将Java线程运行在JVM中的状态分成六个状态,废话
  • 线程生命周期: 新建状态: 继承Thread类,重写run方法,得到新线程 就绪状态: 线程调用.start()方法,进入就绪状态。 运行状态: 线程获得cpu时间片,执行代码,线程进入运行状态 阻塞状态: 代...
  • 生命周期的五种状态:新建,就绪,运行,阻塞,死亡
  • 死亡状态(Dead)二、简述线程生命周期的运行过程三、程序判读1.代码2.运行结果3.分析 一、线程的生命周期的定义 1.新建状态(New) 新创建了一个线程对象。 2.就绪状态(Runnable) 线程对象创建后,其他线程调用...
  • 线程生命周期

    千次阅读 2018-05-27 18:38:22
    写在前面 新建、就绪状态 ...线程生命周期会经历以下几个状态: 新建:new创建线程对象时 就绪:调用start()方法时 运行:调用run()方法时 阻塞: 多种原因可导致阻塞 死亡:dead 线程状态转换...
  • 生命周期线程被创建并启动后经历的各个状态;线程整个生命周期可以分为五个阶段,分别是新建状态(New)、就绪状态(Runnable)、运行状态(Running)、阻塞状态(Blocked)和死亡状态(Terminated) 1.新建状态(New)当...
  • 图1 线程生命周期图 下面对线程生命周期中的 7 种状态做说明。 出生状态:用户在创建线程时所处的状态,在用户使用该线程实例调用 start() 方法之前,线程都处于出生状态。 就绪状态:也称可执行状态,当用户...
  • 线程的“生老病死”,我们称之为生命周期。     那java线程生命周期都有哪些个阶段呢?请看下图:     重点是各个状态直接的转化在java代码层面上如何体现,你需要好好...
  • 线程生命周期 新建状态, 就绪状态, 运行状态, 阻塞状态, 死亡状态 1. 新建状态: 用 new 关键字建立一个线程后,该线程对象就处于新建状态,处于新建状态的内存空间,通过调用 start() 方法进入就绪状态 2. 就绪...
  • JAVA线程生命周期

    千次阅读 2019-03-05 20:10:51
    线程生命周期中,它要经过创建(New)、就绪(Runnable)、运行(Running)、阻塞(Blocked)和死亡(Dead)这五种状态。当线程进入运行状态后,它不是一直“霸占”CPU运行,一般的操作系统是采用抢占式的方式来...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 18,209
精华内容 7,283
关键字:

简述线程的生命周期