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

最新推荐文章于 2024-06-05 21:00:00 发布
最新推荐文章于 2024-06-05 21:00:00 发布
阅读量215 收藏
点赞数 9
分类专栏： JavaSE学习记录 文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46612641/article/details/135229466
版权

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状态。

憨憨浩浩
关注
  • 9
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
线程生命周期
weixin_43178406的博客
09-14 3万+
本文主要介绍了线程生命周期，希望能对学习线程的同学们有所帮助。 文章目录 1. 综述 2. 线程的生命周期
Java面试--线程的生命周期状态
小刺猬喜歡獨角獸
07-27 5186
面试题：线程有几种状态（招银网络科技） 多线程的基础：Java基础系列（二十一）多线程 线程从创建、运行到结束总是处于下面五个状态之一：新建状态、就绪状态、运行状态、阻塞状态及死亡状态。 具体的运行过程如下： 1、通过new关键字创建后，进入到新生状态 2、调用start后进入就绪状态 3、CPU调度到本线程后，本线程开始执行。进入到运行状态 4、运行中遇到join，yiel...
Java多线程学习（一）- Java线程的生命周期与创建方式
江湖人称小程的博客
06-06 1755
文章目录前言一、Java线程的生命周期二、Java线程的创建及启动创建方式一：继承Thread类创建方式二：实现Runnable接口创建方式三：通过Callable和Future创建线程Callable和Future出现的背景Callable和Future简介源码分析通过Callable和Future创建一个线程三、创建线程的三种方式的对比采用实现Runnable、Callable接口的方式创见多...
JAVA多线程技术-线程池创建方式和原理
Aldeo
07-19 1659
Java里面线程池的顶级接口是Executor，但是严格意义上讲Executor并不是一个线程池，而只是一个执行线程的工具。真正的线程池接口是ExecutorService。下面这张图完整描述了线程池的类体系结构。**Executor**一个接口，其定义了一个接收Runnable对象的方法executor，其方法签名为executor(Runnablecommand),一个可定时调度任务的接口。...
线程生命周期与创建线程的多种方式
小样yx的博客
09-14 5233
多线程的四种实现方式
创建线程的四种方式--常用方法--生命周期
qq_36928041的博客
08-02 1015
把CSDN当一个在线笔记本吧，哈哈哈 加上新特性中的创建方法，共有四种，暂时没去了解。 多线程的创建： 方式一：继承Thread类 步骤： 创建一个继承于Thread类的子类 重写Thread类的run() --> 将此线程执行的操作声明在run()中 创建子类的对象 通过此对象调用start() 问题： 一:启动一个线程，必须调用start(),不能调用run()的方式启动线程。start两个作用：①启动当前线程，②并调用run()方法。 二:如果想再启动一个线程，必须重新创建一个Thread子
多线程(一)：创建线程和线程的常用方法
热门推荐
人不风流枉少年
09-01 24万+
一：为什么要学多线程 应付面试 ：多线程几乎是面试中必问的题，所以掌握一定的基础知识是必须的。 了解并发编程：实际工作中很少写多线程的代码，这部分代码一般都被人封装起来了，在业务中使用多线程的机会也不是很多(看具体项目)，但是作为一个高级程序员如果不会多线程是说不过去的。 二：进程与线程 进程 进程是资源（CPU、内存等）分配的基本单位，它是程序执行时的一个实例。程序运行时系统...
Java多线程（一）：进程与线程的区别、线程的生命周期和线程的创建方法
y_mk的博客
03-26 1436
一、进程与线程的区别 1、进程可以理解成程序的一次执行（即动态的），所以一个程序可以对应一个或多个进程（程序的多次执行），而一个进程往往包含一个或多个线程 2、每个进程有独立的地址空间，包含资源。而线程共享进程的资源，可以把线程理解为轻量的进程 3、线程是处理器调度的基本单位，进程是程序运行的实例 为什么要区分进程和线程 因为进程的执行开销比较大，把进程划分为多个线程能相对减小执行...
【Java多线程-1】线程概述与线程创建和使用
云深不知处
11-02 1万+
说到程序，离不开进程和线程这两个概念。那么这两者分别有什么作用和区别呢？ 1 线程概述 进程是表示资源分配的基本单位，又是调度运行的基本单位。例如，用户运行自己的程序，系统就创建一个进程，并为它分配资源，包括各种表格、内存空间、磁盘空间、I/O设备等。然后，把该进程放人进程的就绪队列。进程调度程序选中它，为它分配CPU以及其它有关资源，该进程才真正运行。所以，进程是系统中的并发执行的单位。如下图所...
线程与线程池生命周期浅谈
weixin_39414779的博客
03-26 1508
1.线程生命周期 ①新生状态：创建线程对象，还没调用start方法 ②就绪状态：线程对象调用start方法进入就绪状态，等待抢占cpu资源 ③运行状态：抢占CPU资源成功的线程进行执行 ④阻塞状态：在运行状态的线程可能因为sleep或者等待io设备、join进入阻塞状态，等待阻塞原因消失，重新进入就绪状态，等待抢占cpu资源，再次抢占到cpu资源时从上次停止的地方再次运行 ⑤死亡状态：线程正常运行完毕或者抛出未捕获的异常，进入死亡状态 2.线程池的生命周期 ①运行状态running ②终止状态termina
多线程知识梳理汇总-思维导图版
07-12
使用思维导图方式，梳理了多线程整体结构，从多线程的介绍到创建线程、线程的生命周期、线程池、锁种类进行梳理。
多线程学习:线程创建详解
12-22
  线程创建包含线程生命周期中的 新建、就绪、运行 三种状态，相关的api为java.lang.Thread 类   ① 新建状态：就是刚使用new方法，new出来的线程 如常见的两种方式   方式一：继承Thread类，并初始化Thread...
多线程多线程.xmind
11-07
该文档是笔者在学习李刚老师《Java疯狂讲义》中有关多线程的用法而总结出来的笔记，其中主要的内容包括线程创建和启动、线程的生命周期、控制线程、线程同步、线程通信线程池等基本内容。对Java多线程有详细的介绍。
多线程多线程.zip
11-07
该文档是笔者在学习李刚老师《Java疯狂讲义》中有关多线程的用法而总结出来的笔记，其中主要的内容包括线程创建和启动、线程的生命周期、控制线程、线程同步、线程通信线程池等基本内容。对Java多线程有详细的介绍。...
进阶2 探索图形化编程：扩展图形组件与切片开发的魅力
优树搭的博客
05-30 1560
当这些切片成功地通过图形程序串联起来后，在后续进行程序升级或维护时，大家会惊喜地发现，图形程序就如同清晰的路标一般，可以非常便捷地通过图形程序准确地定位到相关切片，并对这些切片进行在线查看、编辑和执行等操作。而且，这些切片的代码长度通常不会太长，相比传统开发的代码，阅读起来要容易得多，这无疑会给系统后续的工作带来极大的便利。
JavaScript第九讲：BOM编程
星途码客的博客
06-04 800
今天星途给大家带来JavaScript倒数第二部分知识：BOM编程，希望对码客们有帮助。
设计模式之装饰器模式
最新发布
丿微风乍起的博客
06-05 594
装饰器模式是一种结构型设计模式，它允许我们在不改变原有对象结构的情况下，动态地给对象增加一些职责（即增加其额外功能）。其核心在于通过组合而非继承的方式来扩展对象的功能。Component: 这是抽象组件接口，所有的具体组件和装饰器都必须实现这个接口。Concrete Component: 具体组件，这是我们要装饰的基本对象，它实现了Component接口。Decorator: 抽象装饰器，也是实现Component接口的，它包含一个对Component类型的引用，通常在构造函数中初始化。
Java 异常处理中try-catch块、finally子句以及自定义异常的使用
Itmastergo的博客
05-31 1010
异常是程序运行过程中出现的非正常情况。Java 使用异常类（Exception 类及其子类）来表示这些异常情况。异常处理的核心思想是将正常的程序流程与异常处理流程分离开来，使代码更加清晰和可维护。Throwable 类：所有异常和错误的基类。Error 类：表示系统级的错误，程序通常无法处理，比如内存不足（OutOfMemoryError）。Exception 类：表示程序中可以处理的异常情况。RuntimeException 类。
java 多线程的生命周期
12-19
Java多线程的生命周期包括以下几个状态： 1. 新建状态（New）：当创建一个Thread对象时，线程处于新建状态。此时线程还没有开始执行，也没有分配到系统资源。 2. 就绪状态（Runnable）：当调用线程的start()方法后...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

憨憨浩浩

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值