29--多线程的创建与生命周期

发布时间:2023年12月26日

1、相关概念

1.1 程序、进程与线程

程序(program):为完成特定任务,用某种语言编写的一组指令的集合。即指一段静态的代码,静态对象

进程(process)程序的一次执行过程,或是正在内存中运行的应用程序。如:运行中的QQ,运行中的网易音乐播放器。

  • 每个进程都有一个独立的内存空间,系统运行一个程序即是一个进程从创建、运行到消亡的过程。(生命周期)
  • 程序是静态的,进程是动态的
  • 进程作为操作系统调度和分配资源的最小单位(亦是系统运行程序的基本单位),系统在运行时会为每个进程分配不同的内存区域。
  • 现代的操作系统,大都是支持多进程的,支持同时运行多个程序。比如:现在我们上课一边使用编辑器,一边使用录屏软件,同时还开着画图板,dos窗口等软件。

线程(thread):进程可进一步细化为线程,是程序内部的一条执行路径。一个进程中至少有一个线程

  • 一个进程同一时间若并行执行多个线程,就是支持多线程的。

  • 线程作为CPU调度和执行的最小单位。
  • 一个进程中的多个线程共享相同的内存单元,它们从同一个堆中分配对象,可以访问相同的变量和对象。这就使得线程间通信更简便、高效。但多个线程操作共享的系统资源可能就会带来安全的隐患。
  • 下图中,红框的区域为线程独享,黄色区域为线程共享。

注意:

????????不同的进程之间是不共享内存的。

????????进程之间的数据交换和通信的成本很高。

1.2 查看进程和线程

我们可以在电脑底部任务栏,右键----->打开任务管理器,可以查看当前任务的进程:

1、每个应用程序的运行都是一个进程

2、一个应用程序的多次运行,就是多个进程

3、一个进程中包含多个线程

1.3 线程调度

分时调度所有线程轮流使用 CPU 的使用权,并且平均分配每个线程占用 CPU 的时间。

抢占式调度优先级高的线程以较大的概率优先使用 CPU。如果线程的优先级相同,那么会随机选择一个(线程随机性),Java使用的为抢占式调度。

1.4 多线程程序的优点

背景:以单核CPU为例,只使用单个线程先后完成多个任务(调用多个方法),肯定比用多个线程来完成用的时间更短,为何仍需多线程呢?

多线程程序的优点:

  1. 提高应用程序的响应。对图形化界面更有意义,可增强用户体验。
  2. 提高计算机系统CPU的利用率
  3. 改善程序结构。将既长又复杂的进程分为多个线程,独立运行,利于理解和修改

1.5 补充概念

1.5.1 单核CPU和多核CPU

单核CPU,在一个时间单元内,只能执行一个线程的任务。例如,可以把CPU看成是医院的医生诊室,在一定时间内只能给一个病人诊断治疗。所以单核CPU就是,代码经过前面一系列的前导操作(类似于医院挂号,比如有10个窗口挂号),然后到cpu处执行时发现,就只有一个CPU(对应一个医生),大家排队执行。

这时候想要提升系统性能,只有两个办法,要么提升CPU性能(让医生看病快点),要么多加几个CPU(多整几个医生),即为多核的CPU。

问题:多核的效率是单核的倍数吗?譬如4核A53的cpu,性能是单核A53的4倍吗?理论上是,但是实际不可能,至少有两方面的损耗。

  • 一个是多个核心的其他共用资源限制。譬如,4核CPU对应的内存、cache、寄存器并没有同步扩充4倍。这就好像医院一样,1个医生换4个医生,但是做B超检查的还是一台机器,性能瓶颈就从医生转到B超检查了。
  • 另一个是多核CPU之间的协调管理损耗。譬如多个核心同时运行两个相关的任务,需要考虑任务同步,这也需要消耗额外性能。好比公司工作,一个人的时候至少不用开会浪费时间,自己跟自己商量就行了。两个人就要开会同步工作,协调分配,所以工作效率绝对不可能达到2倍。

1.5.2 并行与并发

并行(parallel):指两个或多个事件在同一时刻发生(同时发生)。指在同一时刻,有多条指令多个CPU同时执行。比如:多个人同时做不同的事。

并发(concurrency):指两个或多个事件同一个时间段内发生。即在一段时间内,有多条指令在单个CPU上快速轮换、交替执行,使得在宏观上具有多个进程同时执行的效果。

在操作系统中,启动了多个程序,并发指的是在一段时间内宏观上有多个程序同时运行,这在单核 CPU 系统中,每一时刻只能有一个程序执行,即微观上这些程序是分时的交替运行,只不过是给人的感觉是同时运行,那是因为分时交替运行的时间是非常短的。

而在多核 CPU 系统中,则这些可以并发执行的程序便可以分配到多个CPU上,实现多任务并行执行,即利用每个处理器来处理一个可以并发执行的程序,这样多个程序便可以同时执行。目前电脑市场上说的多核 CPU,便是多核处理器,核越多,并行处理的程序越多,能大大的提高电脑运行的效率。

2、创建和启动线程

2.1 概述

Java语言的JVM允许程序运行多个线程,使用java.lang.Thread类代表线程,所有的线程对象都必须是Thread类或其子类的实例。

Thread类的特性

  • 每个线程都是通过某个特定Thread对象的run()方法来完成操作的,因此把run()方法体称为线程执行体
  • 通过该Thread对象的start()方法来启动这个线程,而非直接调用run()
  • 要想实现多线程,必须在主线程中创建新的线程对象

2.2 方式1:继承Thread类

Java通过继承Thread类来创建启动多线程的步骤如下:

  1. 定义Thread类的子类,并重写该类的run()方法,该run()方法的方法体就代表了线程需要完成的任务
  2. 创建Thread子类的实例,即创建了线程对象
  3. 调用线程对象的start()方法来启动该线程

代码如下:

package com.suyv.test01;

/**
 * @Author: 憨憨浩浩
 * @CreateTime: 2023-12-25 11:02
 * @Description: 自定义线程类
 */
public class MyThread extends Thread{

    public MyThread() {
    }

    //定义指定线程名称的构造方法
    public MyThread(String name) {
        //调用父类的String参数的构造方法,指定线程的名称
        super(name);
    }

    // 重写run()方法
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(getName()+":正在执行!"+i);
        }
    }
}

测试类:

package com.suyv.test01;

/**
 * @Author: 憨憨浩浩
 * @CreateTime: 2023-12-25 11:05
 * @Description: 测试MyThread
 */
public class TestMyThread {

    public static void main(String[] args) {
        // 创建自定义线程对象1
        MyThread m1 = new MyThread("线程1");
        // 开启子线程1
        m1.start();

        // 创建自定义线程对象2
        MyThread m2 = new MyThread("线程2");
        // 开启子线程2
        m2.start();

        //在主方法中执行for循环
        for (int i = 0; i < 10; i++) {
            System.out.println("main线程!"+i);
        }

    }
}

注意:

如果自己手动调用run()方法,那么就只是普通方法,没有启动多线程模式。

run()方法由JVM调用,什么时候调用,执行的过程控制都有操作系统的CPU调度决定。

想要启动多线程,必须调用start方法。

一个线程对象只能调用一次start()方法启动,如果重复调用了,则将抛出以上的异常IllegalThreadStateException

2.3 方式2:实现Runnable接口

Java有单继承的限制,当我们无法继承Thread类时,那么该如何做呢?在核心类库中提供了Runnable接口,我们可以实现Runnable接口,重写run()方法,然后再通过Thread类的对象代理启动和执行我们的线程体run()方法

步骤如下:

  1. 定义Runnable接口的实现类,并重写该接口的run()方法,该run()方法的方法体同样是该线程的线程执行体。
  2. 创建Runnable实现类的实例,并以此实例作为Thread的target参数来创建Thread对象,该Thread对象才是真正的线程对象。
  3. 调用线程对象的start()方法,启动线程。调用Runnable接口实现类的run方法。

代码如下:

package com.suyv.test02;

/**
 * @Author: 憨憨浩浩
 * @CreateTime: 2023-12-25 11:12
 * @Description: 自定义线程类
 */
public class MyRunnable implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName()+":正在执行!"+i);
        }
    }
}

测试类:

package com.suyv.test02;

/**
 * @Author: 憨憨浩浩
 * @CreateTime: 2023-12-25 11:13
 * @Description: 测试 MyRunnable
 */
public class TestMyRunnable {

    public static void main(String[] args) {
        //创建自定义类对象  线程任务对象
        MyRunnable myRunnable = new MyRunnable();

        //创建线程对象
        Thread t1 = new Thread(myRunnable,"线程1");
        Thread t2 = new Thread(myRunnable,"线程2");

        // 开启子线程
        t1.start();
        t2.start();

        //在主方法中执行for循环
        for (int i = 0; i < 10; i++) {
            System.out.println("main线程!"+i);
        }

    }

}

通过实现Runnable接口,使得该类有了多线程类的特征。所有的分线程要执行的代码都在run方法里面。

在启动的多线程的时候,需要先通过Thread类的构造方法Thread(Runnable target) 构造出对象,然后调用Thread对象的start()方法来运行多线程代码。

实际上,所有的多线程代码都是通过运行Thread的start()方法来运行的。因此,不管是继承Thread类还是实现Runnable接口来实现多线程,最终还是通过Thread的对象的API来控制线程的,熟悉Thread类的API是进行多线程编程的基础。

说明:Runnable对象仅仅作为Thread对象的target,Runnable实现类里包含的run()方法仅作为线程执行体。而实际的线程对象依然是Thread实例,只是该Thread线程负责执行其target的run()方法。

2.4 变形写法

使用匿名内部类对象来实现线程的创建和启动

2.4.1 继承Thread写法

package com.suyv.test01;

/**
 * @Author: 憨憨浩浩
 * @CreateTime: 2023-12-25 11:29
 * @Description: 使用匿名内部类实现继承Thread的方式启动多线程
 */
public class TestThread {

    public static void main(String[] args) {

        // 子线程调用start()方法
        new Thread(){
            @Override
            public void run() {
                for (int i = 0; i < 10; i++) {
                    System.out.println(Thread.currentThread().getName()+":正在执行!"+i);
                }
            }
        }.start();

        // 主线程
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName()+":正在执行!"+i);
        }

    }
}

2.2.4 实现Runnable

package com.suyv.test02;

/**
 * @Author: 憨憨浩浩
 * @CreateTime: 2023-12-25 11:32
 * @Description: 使用匿名内部类实现实现Runnable的方式启动多线程
 */
public class TestRunnable {

    public static void main(String[] args) {

        // 子线程调用start()方法
        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 10; i++) {
                    System.out.println(Thread.currentThread().getName()+":正在执行!"+i);
                }
            }
        }).start();

        // 主线程
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName()+":正在执行!"+i);
        }
    }
}

2.5 对比两种方式

联系

Thread类实际上也是实现了Runnable接口的类。即:public class Thread extends Object implements Runnable

区别

  • 继承Thread:线程代码存放Thread子类run方法中。
  • 实现Runnable:线程代码存在接口的子类的run方法。

实现Runnable接口比继承Thread类所具有的优势

  • 避免了单继承的局限性
  • 多个线程可以共享同一个接口实现类的对象,非常适合多个相同线程来处理同一份资源
  • 增加程序的健壮性,实现解耦操作,代码可以被多个线程共享,代码和线程独立。

如果一个类继承Thread,则不适合资源共享。但是如果实现了Runable接口的话,则很容易的实现资源共享。

2.6 练习

创建两个分线程,让其中一个线程输出1-100之间的偶数,另一个线程输出1-100之间的奇数。

2.6.1 方式1

package com.suyv.test03;

/**
 * @Author: 憨憨浩浩
 * @CreateTime: 2023-12-25 12:13
 * @Description: 创建两个分线程,让其中一个线程输出1-100之间的偶数,另一个线程输出1-100之间的奇数。
 */

// 用于打印偶数
public class EvenNumberPrint extends Thread{

    @Override
    public void run() {
        for (int i = 1; i <= 100; i++) {
            if (i % 2 == 0){
                System.out.println(Thread.currentThread().getName() + ":" + i);
            }
        }
    }
}

// 用于打印奇数
class oddNumberPrint extends Thread{

    @Override
    public void run() {
        for (int i = 1; i <= 100; i++) {
            if (i % 2 != 0){
                System.out.println(Thread.currentThread().getName() + ":" + i);
            }
        }
    }
}

class Test01{
    public static void main(String[] args) {
        EvenNumberPrint even = new EvenNumberPrint();

        oddNumberPrint odd = new oddNumberPrint();

        even.start();
        odd.start();
    }
}

2.6.2 方式2

package com.suyv.test03;

/**
 * @Author: 憨憨浩浩
 * @CreateTime: 2023-12-25 12:19
 * @Description: 创建两个分线程,让其中一个线程输出1-100之间的偶数,另一个线程输出1-100之间的奇数。
 */
public class Test02 {
    public static void main(String[] args) {
        // 打印偶数
        new Thread(){
            @Override
            public void run() {
                for (int i = 1; i <= 100; i++) {
                    if (i % 2 == 0){
                        System.out.println(Thread.currentThread().getName() + ":" + i);
                    }
                }
            }
        }.start();

        // 打印奇数
        new Thread(){
            @Override
            public void run() {
                for (int i = 1; i <= 100; i++) {
                    if (i % 2 != 0){
                        System.out.println(Thread.currentThread().getName() + ":" + i);
                    }
                }
            }
        }.start();
    }
}

2.6.3 方式3

package com.suyv.test03;

/**
 * @Author: 憨憨浩浩
 * @CreateTime: 2023-12-25 12:21
 * @Description: 创建两个分线程,让其中一个线程输出1-100之间的偶数,另一个线程输出1-100之间的奇数。
 */
public class Test03 {

    public static void main(String[] args) {

        // 打印偶数
        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 1; i <= 100; i++) {
                    if (i % 2 == 0){
                        System.out.println(Thread.currentThread().getName() + ":" + i);
                    }
                }
            }
        }).start();

        // 打印奇数
        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 1; i <= 100; i++) {
                    if (i % 2 != 0){
                        System.out.println(Thread.currentThread().getName() + ":" + i);
                    }
                }
            }
        }).start();
    }
}

3、Thread类的常用结构

3.1 构造器

  • public Thread() :分配一个新的线程对象。
  • public Thread(String name) :分配一个指定名字的新的线程对象。
  • public Thread(Runnable target) :指定创建线程的目标对象,它实现了Runnable接口中的run方法
  • public Thread(Runnable target,String name) :分配一个带有指定目标新的线程对象并指定名字。

3.2 常用方法系列1

  • public void run() :此线程要执行的任务在此处定义代码。
  • public void start() :导致此线程开始执行; Java虚拟机调用此线程的run方法。
  • public String getName() :获取当前线程名称。
  • public void setName(String name):设置该线程名称。
  • public static Thread currentThread() :返回对当前正在执行的线程对象的引用。在Thread子类中就是this,通常用于主线程和Runnable实现类
  • public static void sleep(long millis) :使当前正在执行的线程以指定的毫秒数暂停(暂时停止执行)。
  • public static void yield():yield只是让当前线程暂停一下,让系统的线程调度器重新调度一次,希望优先级与当前线程相同或更高的其他线程能够获得执行机会,但是这个不能保证,完全有可能的情况是,当某个线程调用了yield方法暂停之后,线程调度器又将其调度出来重新执行。

3.2.1 线程休眠

package com.suyv.test04;

import java.util.Date;

/**
 * @Author: 憨憨浩浩
 * @CreateTime: 2023-12-25 13:15
 * @Description: 线程休眠
 */
public class ThreadSleepTest {
    public static void main(String[] args) {
        ThreadSleep threadSleep = new ThreadSleep();

        Thread t1 = new Thread(threadSleep);
        Thread t2 = new Thread(threadSleep);
        Thread t3 = new Thread(threadSleep);

        // 修改线程名
        t1.setName("线程1");
        t2.setName("线程2");
        t3.setName("线程3");

        t1.start();
        t2.start();
        t3.start();
    }
}

class ThreadSleep implements Runnable{

    @Override
    public void run() {
        for (int i = 0; i <= 10 ; i++) {
            System.out.println(Thread.currentThread().getName()+": "+i+", 日期:"+ new Date());

            //困了,我睡一会
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

3.2.2 线程礼让

package com.suyv.test04;

/**
 * @Author: 憨憨浩浩
 * @CreateTime: 2023-12-25 13:26
 * @Description: 线程礼让
 */
public class ThreadYieldTest {
    public static void main(String[] args) {
        ThreadYield t1 = new ThreadYield();
        ThreadYield t2 = new ThreadYield();

        t1.setName("线程1");
        t2.setName("线程2");

        t1.start();
        t2.start();
    }
}

class ThreadYield extends Thread{

    @Override
    public void run() {
        for (int i = 0; i <= 10 ; i++) {
            System.out.println(getName()+": "+ i );

            //线程礼让
            Thread.yield();

        }
    }
}

3.3 常用方法系列2

  • public final boolean isAlive():测试线程是否处于活动状态。如果线程已经启动且尚未终止,则为活动状态。
  • void join() :等待该线程终止。 void join(long millis) :等待该线程终止的时间最长为 millis 毫秒。如果millis时间到,将不再等待。 void join(long millis, int nanos) :等待该线程终止的时间最长为 millis 毫秒 + nanos 纳秒。
  • public final void stop():已过时,不建议使用。强行结束一个线程的执行,直接进入死亡状态。run()即刻停止,可能会导致一些清理性的工作得不到完成,如文件,数据库等的关闭。同时,会立即释放该线程所持有的所有的锁,导致数据得不到同步的处理,出现数据不一致的问题。
  • void suspend() / void resume() : 这两个操作就好比播放器的暂停和恢复。二者必须成对出现,否则非常容易发生死锁。suspend()调用会导致线程暂停,但不会释放任何锁资源,导致其它线程都无法访问被它占用的锁,直到调用resume()。已过时,不建议使用。

3.3.1 线程加入

package com.suyv.test04;

/**
 * @Author: 憨憨浩浩
 * @CreateTime: 2023-12-25 13:21
 * @Description: 线程加入
 */
public class ThreadJoinTest {

    public static void main(String[] args) {
        ThreadJoin t1 = new ThreadJoin();
        ThreadJoin t2 = new ThreadJoin();
        ThreadJoin t3 = new ThreadJoin();

        t1.setName("线程1");
        t2.setName("线程2");
        t3.setName("线程3");

        t1.start();
        try {
            t1.join();//加入线程,t1走完之后,t2,t3才可以去抢
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        t2.start();
        t3.start();

    }
}

class ThreadJoin extends Thread{
    @Override
    public void run() {
        for (int i = 0; i <= 10 ; i++) {
            System.out.println(getName()+": "+i);
        }
    }
}

3.3.2 线程停止

package com.suyv.test04;

import java.util.Date;

/**
 * @Author: 憨憨浩浩
 * @CreateTime: 2023-12-25 13:49
 * @Description: 线程停止
 */
public class ThreadStopTest {
    public static void main(String[] args) {

        ThreadStop t1 = new ThreadStop();
        t1.start();

        try {
            // 如果你睡3秒还不睡醒,就干掉你
            Thread.sleep(3000);
            // t1.stop();// 已过时,但可以用。如果后面还有代码就不没去运行
            t1.interrupt();// 判断当前线程中断,不影响后面的执行
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

    }
}

class ThreadStop extends Thread{

    @Override
    public void run() {
        System.out.println("开始执行:"+new Date());
        try {
            Thread.sleep(10000);// 睡了10秒
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("结果执行:"+new Date());
    }
}

3.4 常用方法系列3

每个线程都有一定的优先级,同优先级线程组成先进先出队列(先到先服务),使用分时调度策略。优先级高的线程采用抢占式策略,获得较多的执行机会。每个线程默认的优先级都与创建它的父线程具有相同的优先级。

Thread类的三个优先级常量:

????????MAX_PRIORITY(10):最高优先级

????????MIN _PRIORITY (1):最低优先级

????????NORM_PRIORITY (5):普通优先级,默认情况下main线程具有普通优先级。????????

public final int getPriority() :返回线程优先级

public final void setPriority(int newPriority) :改变线程的优先级,范围在[1,10]之间。

package com.suyv.test04;

/**
 * @Author: 憨憨浩浩
 * @CreateTime: 2023-12-25 13:07
 * @Description: 设置线程优先级
 */
public class ThreadPriorityTest {

    public static void main(String[] args) {

        ThreadPriority t1 = new ThreadPriority();
        ThreadPriority t2 = new ThreadPriority();
        ThreadPriority t3 = new ThreadPriority();

        // 设置优先级只是尽可以保证线程的优先级并不能完全保证,线程本身就是随机
        t1.setPriority(Thread.MAX_PRIORITY);        // 10
        t2.setPriority(Thread.NORM_PRIORITY);       // 5
        t2.setPriority(Thread.MIN_PRIORITY);        // 1

        System.out.println(t1.getPriority());
        System.out.println(t2.getPriority());
        System.out.println(t3.getPriority());

        t1.start();
        t2.start();
        t3.start();

    }
}

class ThreadPriority extends Thread{

    @Override
    public void run() {
        for (int i = 1; i <= 10 ; i++) {
            System.out.println(getName()+":"+i);
        }
    }
}

3.5 守护线程(了解)

有一种线程,它是在后台运行的,它的任务是为其他线程提供服务的,这种线程被称为“守护线程”。JVM的垃圾回收线程就是典型的守护线程。

守护线程有个特点,就是如果所有非守护线程都死亡,那么守护线程自动死亡。形象理解:兔死狗烹,鸟尽弓藏

调用setDaemon(true)方法可将指定线程设置为守护线程。必须在线程启动之前设置,否则会报IllegalThreadStateException异常。

调用isDaemon()可以判断线程是否是守护线程。

package com.suyv.test04;

/**
 * @Author: 憨憨浩浩
 * @CreateTime: 2023-12-25 13:30
 * @Description: 守护线程
 */
public class ThreadDaemonTest {

    public static void main(String[] args) {
        ThreadDaemon t1 = new ThreadDaemon();
        ThreadDaemon t2 = new ThreadDaemon();

        t1.setName("线程1");
        t2.setName("线程2");

        // 设置守护线程,一定在启动之前调用
        t1.setDaemon(true);
        t2.setDaemon(true);

        // 判断线程是否是守护线程
        System.out.println(t1.isDaemon());
        System.out.println(t2.isDaemon());

        t1.start();
        t2.start();

        Thread.currentThread().setName("main线程");
        for (int i = 1; i <=5 ; i++) { // 主线程,main方法,当前线程走到5的时候,t1,t2都会挂掉
            System.out.println(Thread.currentThread().getName()+": "+i);
        }

    }
}

class ThreadDaemon extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {

            System.out.println(getName()+": "+i);

        }
    }
}

4. 多线程的生命周期

Java语言使用Thread类及其子类的对象来表示线程,在它的一个完整的生命周期中通常要经历如下一些状态:

4.1 JDK1.5之前:5种状态

线程的生命周期有五种状态:新建(New)、就绪(Runnable)、运行(Running)、阻塞(Blocked)、死亡(Dead)。CPU需要在多条线程之间切换,于是线程状态会多次在运行、阻塞、就绪之间切换。

1.新建

当一个Thread类或其子类的对象被声明并创建时,新生的线程对象处于新建状态。此时它和其他Java对象一样,仅仅由JVM为其分配了内存,并初始化了实例变量的值。此时的线程对象并没有任何线程的动态特征,程序也不会执行它的线程体run()。

2.就绪

但是当线程对象调用了start()方法之后,就不一样了,线程就从新建状态转为就绪状态。JVM会为其创建方法调用栈和程序计数器,当然,处于这个状态中的线程并没有开始运行,只是表示已具备了运行的条件,随时可以被调度。至于什么时候被调度,取决于JVM里线程调度器的调度。

注意:程序只能对新建状态的线程调用start(),并且只能调用一次,如果对非新建状态的线程,如已启动的线程或已死亡的线程调用start()都会报错IllegalThreadStateException异常。

3.运行

如果处于就绪状态的线程获得了CPU资源时,开始执行run()方法的线程体代码,则该线程处于运行状态。如果计算机只有一个CPU核心,在任何时刻只有一个线程处于运行状态,如果计算机有多个核心,将会有多个线程并行(Parallel)执行。

当然,美好的时光总是短暂的,而且CPU讲究雨露均沾。对于抢占式策略的系统而言,系统会给每个可执行的线程一个小时间段来处理任务,当该时间用完,系统会剥夺该线程所占用的资源,让其回到就绪状态等待下一次被调度。此时其他线程将获得执行机会,而在选择下一个线程时,系统会适当考虑线程的优先级。

4.阻塞

当在运行过程中的线程遇到如下情况时,会让出 CPU 并临时中止自己的执行,进入阻塞状态:

  • 线程调用了sleep()方法,主动放弃所占用的CPU资源;
  • 线程试图获取一个同步监视器,但该同步监视器正被其他线程持有;
  • 线程执行过程中,同步监视器调用了wait(),让它等待某个通知(notify);
  • 线程执行过程中,同步监视器调用了wait(time)
  • 线程执行过程中,遇到了其他线程对象的加塞(join);
  • 线程被调用suspend方法被挂起(已过时,因为容易发生死锁);

当前正在执行的线程被阻塞后,其他线程就有机会执行了。针对如上情况,当发生如下情况时会解除阻塞,让该线程重新进入就绪状态,等待线程调度器再次调度它:

  • 线程的sleep()时间到;
  • 线程成功获得了同步监视器;
  • 线程等到了通知(notify);
  • 线程wait的时间到了
  • 加塞的线程结束了;
  • 被挂起的线程又被调用了resume恢复方法(已过时,因为容易发生死锁);

5.死亡

线程会以以下三种方式之一结束,结束后的线程就处于死亡状态:

  • run()方法执行完成,线程正常结束
  • 线程执行过程中抛出了一个未捕获的异常(Exception)或错误(Error)
  • 直接调用该线程的stop()来结束该线程(已过时)

4.2 JDK1.5及之后:6种状态

在java.lang.Thread.State的枚举类中这样定义:

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

NEW(新建):线程刚被创建,但是并未启动。还没调用start方法。

RUNNABLE(可运行):这里没有区分就绪和运行状态。因为对于Java对象来说,只能标记为可运行,至于什么时候运行,不是JVM来控制的了,是OS来进行调度的,而且时间非常短暂,因此对于Java对象的状态来说,无法区分。

Teminated(被终止):表明此线程已经结束生命周期,终止运行。

重点说明,根据Thread.State的定义,阻塞状态分为三种:BLOCKED、WAITING、TIMED_WAITING。

????????BLOCKED(锁阻塞):在API中的介绍为:一个正在阻塞、等待一个监视器锁(锁对象)的线程处于这一状态。只有获得锁对象的线程才能有执行机会。比如,线程A与线程B代码中使用同一锁,如果线程A获取到锁,线程A进入到Runnable状态,那么线程B就进入到Blocked锁阻塞状态。

????????TIMED_WAITING(计时等待):在API中的介绍为:一个正在限时等待另一个线程执行一个(唤醒)动作的线程处于这一状态。当前线程执行过程中遇到Thread类的sleep或join,Object类的wait,LockSupport类的park方法,并且在调用这些方法时,设置了时间,那么当前线程会进入TIMED_WAITING,直到时间到,或被中断。

????????WAITING(无限等待):在API中介绍为:一个正在无限期等待另一个线程执行一个特别的(唤醒)动作的线程处于这一状态。当前线程执行过程中遇到遇到Object类的wait,Thread类的join,LockSupport类的park方法,并且在调用这些方法时,没有指定时间,那么当前线程会进入WAITING状态,直到被唤醒。

????????通过Object类的wait进入WAITING状态的要有Object的notify/notifyAll唤醒;

????????通过Condition的await进入WAITING状态的要有Condition的signal方法唤醒;

????????通过LockSupport类的park方法进入WAITING状态的要有LockSupport类的unpark方法唤醒

????????通过Thread类的join进入WAITING状态,只有调用join方法的线程对象结束才能让当前线程恢复;

说明:当从WAITING或TIMED_WAITING恢复到Runnable状态时,如果发现当前线程没有得到监视器锁,那么会立刻转入BLOCKED状态。

文章来源:https://blog.csdn.net/weixin_46612641/article/details/135229466
本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。