AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

java并发原理实战(2)--线程的状态和切换

2022-10-18 97
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： java并发原理实战(2)--线程的状态和切换

高效并发

1.join的理解


join源码中，只会调用wait方法，并没有在结束时调用notify，这是因为线程在die的时候会自动调用自身的notifyAll方法，来释放所有的资源和锁。


2.sleep的理解


调用sleep()之后，会引起当前执行的线程进入暂时中断状态，也即睡眠状态。


中断完成之后，自动进入唤醒状态从而继续执行代码。


3.wait的理解


关键点: wait是Object的方法，必须在同步代码中使用，通过notice/noticeAll方法唤醒。

代码演示:

1dc618a0ed9580ce8bfa6facb208c08f.png


4.线程状态


《java核心技术-卷1》


线程可以有6种状态：


New（新建）

Runnable（可运行）

Blocked（被阻塞）

Waiting（等待）

Timed waiting（计时等待）

Terminated（被终止）

New：new Thread()后线程的状态就是新建。


Runnable：线程一旦调用start()方法，无论是否运行，状态都为Runable，注意Runable状态指示表示线程可以运行，不表示线程当下一定在运行，线程是否运行由虚拟机所在操作系统调度决定。


被阻塞：线程试图获取一个内部对象的Monitor（进入synchronized方法或synchronized块）但是其他线程已经抢先获取，那此线程被阻塞，知道其他线程释放Monitor并且线程调度器允许当前线程获取到Monitor，此线程就恢复到可运行状态。


等待：当一个线程等待另一个线程通知调度器一个条件时，线程进入等待状态。


计时等待：和等待类似，某些造成等待的方法会允许传入超时参数，这类方法会造成计时等待，收到其他线程的通知或者超时都会恢复到可运行状态。


被终止：线程执行完毕正常结束或执行过程中因未捕获异常意外终止都会是线程进入被终止状态。


5.线程状态转换



1dc618a0ed9580ce8bfa6facb208c08f.png

观察状态转化图，我们发现“可运行”状态为所有状态的必经状态。我们分析出四条基本的状态转换线路图。


新建—>可运行—>被终止

新建—>可运行—>被阻塞—>可运行—>被终止

新建—>可运行—>等待—>可运行—>被终止

新建—>可运行—>计时等待—>可运行—>被终止

“新建”和“被终止”状态分别为起始和结束状态，和“可运行”状态不可逆。其他状态均能和“可运行”状态相互转换。


用代码说话


让我们用代码演示线程状态是如何转换的，大家重点关注两个问题？


什么操作会改变线程状态？


改变的状态是如何恢复的？


① 新建—>可运行—>被终止


这个状态转换时创建的线程生命周期。


/**
 * NEW->RUNNABLE->TERMINATED
 */
public class ThreadStateNRT {
    public static void main(String[] args) {
        Thread thread=new Thread(new Task());
        print(thread.getName(),thread.getState());
        thread.start();
        //等待线程执行完毕。
        try {
            thread.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        print(thread.getName(),thread.getState());
    }
    private static class Task implements Runnable{
        @Override
        public void run() {
            print(Thread.currentThread().getName(),Thread.currentThread().getState());
        }
    }
    private static final String stringFormat="%s:%s";
    private static void print(String threadName,Thread.State state){
        System.out.println(String.format(stringFormat,threadName,state));
    }
}


其中，print()方法用来打印线程信息。后面的代码示例均不在展示。


运行程序结果为：


Thread-0:NEW

Thread-0:RUNNABLE

Thread-0:TERMINATED


② 新建—>可运行—>被阻塞—>可运行—>被终止


只有一种方法能出现阻塞状态，那就是synchronized同步原语。我们需要两个线程其中一个线程被另一个阻塞来展示。

/**
 * NEW->RUNNABLE->BLOCKED->RUNNABLE->TERMINATED
 */
public class ThreadStateNRBRT {
    //锁
    private static final Object lock=new Object();
    public static void main(String[] args) {
        //辅助线程，制造synchronized状态。
        Thread assistantThread = new Thread(new SynTask());
        assistantThread.start();
        try {
            //保证assistantThread先执行。
            Thread.sleep(10);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        Thread showThread = new Thread(new Task());
        print(showThread.getName(), showThread.getState());
        showThread.start();
        print(showThread.getName(),showThread.getState());
        //因为无法判断显示线程何时执行，所以循环直到显示线程执行。
        while (true){
            if(showThread.getState()==Thread.State.BLOCKED){
                print(showThread.getName(), Thread.State.BLOCKED);
                break;
            }
        }
        //等待两个线程执行完毕。
        try {
            assistantThread.join();
            showThread.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //线程执行完毕打印状态。
        print(showThread.getName(), showThread.getState());
    }
    private static class SynTask implements Runnable {
        @Override
        public void run() {
            //锁定一定时间
            synchronized (lock){
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
    private static class Task implements Runnable {
        @Override
        public void run() {
            synchronized (lock){
                print(Thread.currentThread().getName(),Thread.currentThread().getState());
            }
        }
    }
}


执行一下你有可能看到正确结果：


Thread-1:NEW
Thread-1:RUNNABLE
Thread-1:BLOCKED
Thread-1:RUNNABLE
Thread-1:TERMINATED


为什么是有可能呢？我们调整一下代码，例如将加锁的时间调小一点：


private static class SynTask implements Runnable {
        @Override
        public void run() {
            //锁定一定时间
            synchronized (lock){
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
}


注意此处Thread.sleep(10),我们只锁住十毫秒。


再运行一下，控制台可能打印出这样的结果且程序不会结束：


Thread-1:NEW
Thread-1:RUNNABLE
Thread-1:RUNNABLE

造成以上结果的原因是我么无法保证两个线程的执行顺序，也无法证主线程一定能打印出显示线程阻塞的状态。


    

while (true){
            if(showThread.getState()==Thread.State.BLOCKED){
                print(showThread.getName(), Thread.State.BLOCKED);
                break;
            }
        }


所以执行在这段代码死循环了。


调整一下代码，保证不会因为参数调整改变线程之间的执行顺序和打印结果。


/**
 * NEW->RUNNABLE->BLOCKED->RUNNABLE->TERMINATED
 */
public class ThreadStateNRBRT_New {
    //锁
    private static final Object lock=new Object();
    //锁定标志
    private volatile static boolean lockFlag=true;
    //执行顺序
    private volatile static int order=0;
    public static void main(String[] args) {
        //展示线程
        Thread showThread = new Thread(new Task());
        print(showThread.getName(), showThread.getState());
        showThread.start();
        print(showThread.getName(), showThread.getState());
        //辅助线程，制造synchronized状态。
        Thread assistantThread = new Thread(new SynTask());
        assistantThread.start();
        //循环读取展示线程状态，直到读到展示线程状态为BLOCKED，才让辅助线程退出同步。
        while (true){
            if(showThread.getState()==Thread.State.BLOCKED){
                print(showThread.getName(), Thread.State.BLOCKED);
                lockFlag=false;
                break;
            }
        }
        try {
            assistantThread.join();
            showThread.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //线程执行完毕打印状态。
        print(showThread.getName(), showThread.getState());
    }
    private static class SynTask implements Runnable {
        @Override
        public void run() {
            while (true) {
                //保证先进入同步范围。
                if (order == 0) {
                    synchronized (lock) {
                        //启动另一个同步
                        order=1;
                        //等待主线程读取到线程阻塞状态，退出同步。
                        while (lockFlag) {
                            try {
                                Thread.sleep(10);
                            } catch (InterruptedException e) {
                                e.printStackTrace();
                            }
                        }
                    }
                    break;
                }
            }
        }
    }
    private static class Task implements Runnable {
        @Override
        public void run() {
            while (true){
                //保证后进入同步范围。
                if (order==1){
                    synchronized (lock){
                        print(Thread.currentThread().getName(),Thread.currentThread().getState());
                    }
                    break;
                }
            }
        }
    }
}


我们用order保证线程进入同步区的顺序，用lockFlag保证只有在打印出显示线程的被阻塞状态后辅助线程才退出同步区。这样无论如何执行我们都会得到同样的结果。


Thread-0:NEW
Thread-0:RUNNABLE
Thread-0:BLOCKED
Thread-0:RUNNABLE
Thread-0:TERMINATED

③ 新建—>可运行—>等待—>可运行—>被终止


这里我们展示两种三种方法造成线程的等待状态


Object.wait()
java.util.concurrent.locks.Locke.lock()
java.util.concurrent.locks.Condition.await()

其他方法如Thread.join()等大家可以参考示例代码自己实现。


1. Object.wait()


/**
 * NEW->RUNNABLE->WAITING->RUNNABLE->TERMINATED
 */
public class ThreadStateNRWRT {
    //锁
    private static final Object lock=new Object();
    public static void main(String[] args) {
        //展示线程
        Thread showThread = new Thread(new WaitTask());
        print(showThread.getName(), showThread.getState());
        showThread.start();
        print(showThread.getName(),showThread.getState());
        //循环读取展示线程状态，直到读到展示线程状态为WAITING，才让辅助线程唤醒等待线程。
        while (true){
            if(showThread.getState()==Thread.State.WAITING){
                print(showThread.getName(), Thread.State.WAITING);
                break;
            }
        }
        synchronized (lock){
            lock.notify();
        }
        try {
            showThread.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //线程执行完毕打印状态。
        print(showThread.getName(), showThread.getState());
    }
    private static class WaitTask implements Runnable {
        @Override
        public void run() {
            //等待
            synchronized (lock){
                try {
                    lock.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            print(Thread.currentThread().getName(),Thread.currentThread().getState());
        }
    }
}


2. java.util.concurrent.locks.Locke.lock()


/**
 * NEW->RUNNABLE->WAITING->RUNNABLE->TERMINATED
 */
public class ThreadStateNRWRTLock {
    //锁
    private  static Lock lock=new ReentrantLock();
    //锁定标志
    private volatile static boolean lockFlag=true;
    //执行顺序
    private volatile static int order=0;
    public static void main(String[] args) {
        //展示线程
        Thread showThread = new Thread(new Task());
        print(showThread.getName(), showThread.getState());
        showThread.start();
        print(showThread.getName(), showThread.getState());
        //辅助线程，制造synchronized状态。
        Thread assistantThread = new Thread(new SynTask());
        assistantThread.start();
        //循环读取展示线程状态，直到读到展示线程状态为BLOCKED，才让辅助线程退出同步。
        while (true){
            if(showThread.getState()==Thread.State.WAITING){
                print(showThread.getName(), Thread.State.WAITING);
                lockFlag=false;
                break;
            }
        }
        try {
            assistantThread.join();
            showThread.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //线程执行完毕打印状态。
        print(showThread.getName(), showThread.getState());
    }
    private static class SynTask implements Runnable {
        @Override
        public void run() {
            while (true) {
                //保证先进入同步范围。
                if (order == 0) {
                    //加锁
                    lock.lock();
                    try {
                        order=1;
                        while (lockFlag) {
                            try {
                                Thread.sleep(10);
                            } catch (InterruptedException e) {
                                e.printStackTrace();
                            }
                        }
                    }finally {
                        lock.unlock();
                    }
                    break;
                }
            }
        }
    }
    private static class Task implements Runnable {
        @Override
        public void run() {
            while (true){
                //保证后进入同步范围。
                if (order==1){
                    lock.lock();
                    try{
                        print(Thread.currentThread().getName(),Thread.currentThread().getState());
                    }finally {
                        lock.unlock();
                    }
                    break;
                }
            }
        }
    }
}


3. java.util.concurrent.locks.Condition.await()


/**
 * NEW->RUNNABLE->WAITING->RUNNABLE->TERMINATED
 */
public class ThreadStateNRWRTCondition {
    //锁
    private static Lock lock=new ReentrantLock();
    private static Condition condition=lock.newCondition();
    public static void main(String[] args) {
        //展示线程
        Thread showThread = new Thread(new WaitTask());
        print(showThread.getName(), showThread.getState());
        showThread.start();
        print(showThread.getName(),showThread.getState());
        //循环读取展示线程状态，直到读到展示线程状态为WAITING，才让辅助线程唤醒等待线程。
        while (true){
            if(showThread.getState()==Thread.State.WAITING){
                print(showThread.getName(), Thread.State.WAITING);
                break;
            }
        }
        lock.lock();
        try{
            condition.signal();
        }finally {
            lock.unlock();
        }
        try {
            showThread.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //线程执行完毕打印状态。
        print(showThread.getName(), showThread.getState());
    }
    private static class WaitTask implements Runnable {
        @Override
        public void run() {
            //等待
            lock.lock();
            try{
                try {
                    condition.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }finally {
                lock.unlock();
            }
            print(Thread.currentThread().getName(),Thread.currentThread().getState());
        }
    }
}


4. 运行结果


三段代码的运行结果都是：


Thread-0:NEW
Thread-0:RUNNABLE
Thread-0:WAITING
Thread-0:RUNNABLE
Thread-0:TERMINATED


④新建—>可运行—>计时等待—>可运行—>被终止


我们展示两个方法造成计时等待状态


Object.wait(long timeout)

java.util.concurrent.locks.Condition.await(long time, TimeUnit unit)

其他方法如Thread.sleep(long millis),Thread.join(long millis)等大家可以自己实现。

感觉凡是有超时方法的方法都能让线程状态进入计时等待，但是这个没有经过验证，所以只是一个猜想。


1. Object.wait(long timeout)


/**
 * NEW->RUNNABLE->TIMED_WAITING->RUNNABLE->TERMINATED
 */
public class ThreadStateNRTWRT {
    //锁
    private static final Object lock=new Object();
    public static void main(String[] args) {
        //展示线程
        Thread showThread = new Thread(new WaitTask());
        print(showThread.getName(), showThread.getState());
        showThread.start();
        print(showThread.getName(),showThread.getState());
        //循环读取展示线程状态，直到读到展示线程状态为TIMED_WAITING。
        while (true){
            if(showThread.getState()==Thread.State.TIMED_WAITING){
                print(showThread.getName(), Thread.State.TIMED_WAITING);
                break;
            }
        }
        try {
            showThread.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //线程执行完毕打印状态。
        print(showThread.getName(), showThread.getState());
    }
    private static class WaitTask implements Runnable {
        @Override
        public void run() {
            //等待
            synchronized (lock){
                try {
                    lock.wait(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            print(Thread.currentThread().getName(),Thread.currentThread().getState());
        }
    }
}


2. java.util.concurrent.locks.Condition.await(long time, TimeUnit unit)


/**
 * NEW->RUNNABLE->TIMED_WAITING->RUNNABLE->TERMINATED
 */
public class ThreadStateNRTWRTCondition {
    //锁
    private static Lock lock=new ReentrantLock();
    private static Condition condition=lock.newCondition();
    public static void main(String[] args) {
        //展示线程
        Thread showThread = new Thread(new WaitTask());
        print(showThread.getName(), showThread.getState());
        showThread.start();
        print(showThread.getName(),showThread.getState());
        //循环读取展示线程状态，直到读到展示线程状态为TIMED_WAITING。
        while (true){
            if(Thread.State.TIMED_WAITING==showThread.getState()){
                print(showThread.getName(), Thread.State.TIMED_WAITING);
                break;
            }
        }
        try {
            showThread.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //线程执行完毕打印状态。
        print(showThread.getName(), showThread.getState());
    }
    private static class WaitTask implements Runnable {
        @Override
        public void run() {
            //等待
            lock.lock();
           try{
                try {
                    condition.await(1,TimeUnit.MILLISECONDS);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }finally {
               lock.unlock();
           }
            print(Thread.currentThread().getName(),Thread.currentThread().getState());
        }
    }
}


3. 运行结果


两段程序的运行结果相同：


Thread-0:NEW
Thread-0:RUNNABLE
Thread-0:TIMED_WAITING
Thread-0:RUNNABLE
Thread-0:TERMINATED


完


文章标签：
Java
调度
关键词：
Java线程
Java原理
Java实战
Java原理实战
Java并发
怒放de生命
目录
相关文章
Codelinghu
|
19天前
|
并行计算 Java 数据处理
SpringBoot高级并发实践：自定义线程池与@Async异步调用深度解析
SpringBoot高级并发实践：自定义线程池与@Async异步调用深度解析
Codelinghu
99 0
龙大吉
|
9天前
|
存储 Java 开发者
Java Map实战：用HashMap和TreeMap轻松解决复杂数据结构问题！
【10月更文挑战第17天】本文深入探讨了Java中HashMap和TreeMap两种Map类型的特性和应用场景。HashMap基于哈希表实现，支持高效的数据操作且允许键值为null；TreeMap基于红黑树实现，支持自然排序或自定义排序，确保元素有序。文章通过具体示例展示了两者的实战应用，帮助开发者根据实际需求选择合适的数据结构，提高开发效率。
龙大吉
31 2
明弟有理想
|
12天前
|
存储 算法 Java
Java HashSet：底层工作原理与实现机制
本文介绍了Java中HashSet的工作原理，包括其基于HashMap实现的底层机制。通过示例代码展示了HashSet如何添加元素，并解析了add方法的具体过程，包括计算hash值、处理碰撞及扩容机制。
明弟有理想
28 0
光明顶阳顶天
|
4天前
|
安全
List并发线程安全问题
【10月更文挑战第21天】`List` 并发线程安全问题是多线程编程中一个非常重要的问题，需要我们认真对待和处理。只有通过不断地学习和实践，我们才能更好地掌握多线程编程的技巧和方法，提高程序的性能和稳定性。
光明顶阳顶天
90 59
菜菜的后端私房菜
|
14天前
|
存储 消息中间件 安全
JUC组件实战：实现RRPC(Java与硬件通过MQTT的同步通信)
【10月更文挑战第9天】本文介绍了如何利用JUC组件实现Java服务与硬件通过MQTT的同步通信（RRPC）。通过模拟MQTT通信流程，使用`LinkedBlockingQueue`作为消息队列，详细讲解了消息发送、接收及响应的同步处理机制，包括任务超时处理和内存泄漏的预防措施。文中还提供了具体的类设计和方法实现，帮助理解同步通信的内部工作原理。
菜菜的后端私房菜
20 1
JUC组件实战：实现RRPC(Java与硬件通过MQTT的同步通信)
众所周知
|
2天前
|
存储 Java 关系型数据库
高效连接之道：Java连接池原理与最佳实践
在Java开发中，数据库连接是应用与数据交互的关键环节。频繁创建和关闭连接会消耗大量资源，导致性能瓶颈。为此，Java连接池技术通过复用连接，实现高效、稳定的数据库连接管理。本文通过案例分析，深入探讨Java连接池的原理与最佳实践，包括连接池的基本操作、配置和使用方法，以及在电商应用中的具体应用示例。
众所周知
15 5
java的细水长流
|
3天前
|
Java 数据格式 索引
使用 Java 字节码工具检查类文件完整性的原理是什么
Java字节码工具通过解析和分析类文件的字节码，检查其结构和内容是否符合Java虚拟机规范，确保类文件的完整性和合法性，防止恶意代码或损坏的类文件影响程序运行。
java的细水长流
13 5
小王老师呀
|
6天前
|
存储 安全 Java
深入理解Java中的FutureTask：用法和原理
【10月更文挑战第28天】`FutureTask` 是 Java 中 `java.util.concurrent` 包下的一个类，实现了 `RunnableFuture` 接口，支持异步计算和结果获取。它可以作为 `Runnable` 被线程执行，同时通过 `Future` 接口获取计算结果。`FutureTask` 可以基于 `Callable` 或 `Runnable` 创建，常用于多线程环境中执行耗时任务，避免阻塞主线程。任务结果可通过 `get` 方法获取，支持阻塞和非阻塞方式。内部使用 AQS 实现同步机制，确保线程安全。
小王老师呀
26 3
软件求生
|
11天前
|
开发框架 Java 程序员
揭开Java反射的神秘面纱：从原理到实战应用！
本文介绍了Java反射的基本概念、原理及应用场景。反射允许程序在运行时动态获取类的信息并操作其属性和方法，广泛应用于开发框架、动态代理和自定义注解等领域。通过反射，可以实现更灵活的代码设计，但也需注意其性能开销。
软件求生
29 1
Dylaniou
|
17天前
|
Java
【编程进阶知识】揭秘Java多线程：并发与顺序编程的奥秘
本文介绍了Java多线程编程的基础，通过对比顺序执行和并发执行的方式，展示了如何使用`run`方法和`start`方法来控制线程的执行模式。文章通过具体示例详细解析了两者的异同及应用场景，帮助读者更好地理解和运用多线程技术。
Dylaniou
22 1

热门文章

最新文章

  • 1
    阿里Java代码规约插件即将全球首发，邀您来发布仪式现场
  • 2
    Java中的内存泄露的几种可能
  • 3
    Java中的定时器
  • 4
    kill -3 PID命令获取java应用堆栈信息
  • 5
    gzip压缩js和html文件java源码
  • 6
    Java程序员需要熟悉的库
  • 7
    java8 不使用循环
  • 8
    JAVA简单的SWING及AWT
  • 9
    Java基本数据类型总结
  • 10
    java获得当前文件路径
  • 1
    Android进程与线程
    48
  • 2
    Java并发编程：实现高效、线程安全的多线程应用
    57
  • 3
    python并发编程: Python使用线程池在Web服务中实现加速
    62
  • 4
    LInux下Posix的传统线程示例
    47
  • 5
    Springboot启动的时候初始化的线程池默认配置tomcat
    152
  • 6
    SpringBoot实现多线程定时任务动态定时任务配置文件配置定时任务
    591
  • 7
    Python开启线程和线程池的方法
    56
  • 8
    【C/C++ 线程池设计思路】 深入探索线程池设计：任务历史记录的高效管理策略
    166
  • 9
    【Qt 底层之事件驱动系统】深入理解 Qt 事件机制：主事件循环与工作线程的交互探究，包括 QML 的视角
    1290
  • 10
    【C++ 线程包裹类设计】跨平台C++线程包装类：属性设置与平台差异的全面探讨
    108

    • 相关课程

    更多
  • Java面试疑难点解析 - 面试技巧及语言基础
  • Java面试疑难点解析 - Java Web开发
  • Java编程入门
  • Java面向对象编程
  • Java高级编程

    • 相关电子书

    更多
  • 从《阿里巴巴Java开发手册》编写推广谈技术成长
  • 如何通过 Serverless 提高 Java 微服务治理效
  • 多IO线程优化版

    • 相关实验场景

    更多
  • 基于ECS搭建Java Web开发环境
  • 使用Aliyun Java Intializr进行项目开发
  • 搭建Java Web开发环境
  • 部署基于Dragonwell的Java运行环境
  • 观察进程的并发性
    • 下一篇
    阿里云无影云电脑免费试用，最长可试用3个月