精华内容
下载资源
问答
  • Java线程有多少个状态? 直接查看Thread.state类 public enum State { NEW,// 尚未启动的线程处于此状态 RUNNABLE,// 在Java虚拟机中执行的线程处于此状态 BLOCKED,//被堵塞等待监视器锁定的线程处于此状态 ...

    Java线程有多少个状态?
    直接查看Thread.state类

    public enum State {
        NEW,// 尚未启动的线程处于此状态
        RUNNABLE,// 在Java虚拟机中执行的线程处于此状态
        BLOCKED,//被堵塞等待监视器锁定的线程处于此状态
        WAITING,//等待,死死的等,等待另一个线程执行特定动作的线程处于此状态
        TIMED_WAITING,//超时等待,等待另一个线程执行动作达到指定等待时间的线程处于此状态。
        TERMINATED;//线程终止,已退出的线程处于此状态
    }
    
    
    /**
     * 测试 NEW RUNNABLE TIMED_WAITING TERMINATED
     * @author LCW
     * @since 2020/11/18 21:26
     **/
    public class Test01 {
        public static void main(String[] args) throws InterruptedException {
            //启动的时候
            Thread thread = new Thread(() -> {
                //开始执行start(),线程显示RUNNABLE
                System.err.println(Thread.currentThread().getState());
                //执行sleep方法会使得线程进入TIMED_WAITING
                try {
                    TimeUnit.SECONDS.sleep(2);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.err.println(Thread.currentThread().getState());
            }, "A");
            System.out.println("A==>" +thread.getState());//还没执行start方法,thread的状态就是NEW
            thread.start();//开始执行start(),线程显示RUNNABLE
            int i = 3;
            while (i-->0) {
                System.out.println("A==>" + thread.getState());
                TimeUnit.SECONDS.sleep(1);//线程结束TERMINATED
            }
    
        }
    }
    
    

    在这里插入图片描述

    
    /**
     * 测试WAITING,该线程执行了wait()方法就会进入WAITING状态
     * @author LCW
     * @since 2020/11/18 21:26
     **/
    public class Test02 {
        public static void main(String[] args) throws InterruptedException {
            //开启两个线程
            MyRunnable myRunnable = new MyRunnable();
            Thread threadA = new Thread(myRunnable, "A");
            Thread threadB = new Thread(myRunnable, "B");
            //线程A执行,进入WAITING状态
            threadA.start();
            int i = 3;
            while (i-- > 0) {//打印查看线程A的状态
                System.out.println("A==>" + threadA.getState());
                System.out.println("B==>" + threadB.getState());
                try {
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            threadB.start();
            TimeUnit.SECONDS.sleep(1);
            System.out.println("A==>" + threadA.getState());
            System.out.println("B==>" + threadB.getState());
    
        }
    }
    
    class MyRunnable implements Runnable {
    
        @Override
        public void run() {
            if (Thread.currentThread().getName().equals("A")) {
                testA();
            } else {
                testB();
            }
        }
    
        private synchronized void testB() {//这个只是为了最后释放线程
            this.notifyAll();
        }
    
        public synchronized void testA() {//将该线程进程堵塞,此时线程A的State就是WAITING
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    

    在这里插入图片描述

    
    /**
     * 测试BLOCKED
     * @author LCW
     * @since 2020/11/18 22:40
     **/
    public class Test03 {
        public static void main(String[] args) {
            MyRunnable2 myRunnable2 = new MyRunnable2();
            //当线程A,B需要获取同一把锁的时候
            Thread threadA = new Thread(myRunnable2, "A");
            Thread threadB = new Thread(myRunnable2, "B");
            threadA.start();
            threadB.start();
            int i = 3;
            while (i-- > 0) {//打印查看线程A的状态
                System.out.println("A==>" + threadA.getState());
                System.out.println("B==>" + threadB.getState());
                try {
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
    
    class MyRunnable2 implements Runnable {
    
        @Override
        public void run() {
          test();
        }
    
        private synchronized void test() {
            while (true) {
    
            }
        }
    
    }
    

    在这里插入图片描述

    总结:

    1. NEW就是在线程还没有启动的时候的状态
    2. RUNNABLE 就是线程在执行start()方法后就进入的状态,下面的几种状态都是从RUNNABLE 变换过去的,也就是new第一,RUNNABLE 一定是第二个状态,其次才是下面的几种状态
    3. WAITING 就是当此线程执行了wait()方法的时候,线程进入的状态,死死的等待,直到其他线程执行了notify()或者notifyAll()方法才继续执行。
      注意:当线程执行wait()后,会释放锁,这跟sleep()不同,sleep()是不释放锁的。
    4. TIMED_WAITING 就是当线程执行了sleep()方法或者TimeUtil的sleep()方法,线程进入的状态
    5. BLOCKED就是当两个线程同时需要获取同一把锁,一个线程拿到了锁,那么另一个线程就进入了BLOCKED状态,等待拿到锁的线程执行完毕,才继续执行。
    6. TERMINATED就是线程结束后的状态
    展开全文
  • 一、线程状态 新建(new):处于该状态的时间很短暂。已被分配了必须的系统资源,并执行了初始化。表示有资格获得CPU时间。调度器可以把该线程变为runnable或者blocked状态 就绪(Runnable):这种状态下...

    一、线程的四种状态

    新建(new):处于该状态的时间很短暂。已被分配了必须的系统资源,并执行了初始化。表示有资格获得CPU时间。调度器可以把该线程变为runnable或者blocked状态

    就绪(Runnable):这种状态下只要调度器把时间片分配给线程,线程就能运行。处在这种状态就是可运行可不运行的状态

    阻塞(Bolocked):线程能够运行,但有个条件阻止它的运行。当线程处于阻塞状态时,调度器将会忽略线程,不会分配给线程任何CPU时间(例如sleep)。只有重新进入了就绪状态,才有可能执行操作。

    死亡(Dead):处于死亡状态的线程讲不再是可调度的,并且再也不会得到CPU时间。任务死亡的通常方式是从run()方法返回。

    一个任务进入阻塞状态,可能有如下原因:
    1.sleep
    2.wait(),知道线程得到了notify()或者notifyAll()消息,线程才会进入就绪状态。
    3.任务在等待某个输入/输出完成
    4.线程在试图在某个对象上调用其同步控制方法,但是对象锁不可用,因为另一个任务已经获取了这个锁。

    二、wait和sleep的区别

    1.wait和notify方法定义在Object类中,因此会被所有的类所继承。 这些方法都是final的,即它们都是不能被重写的,不能通过子类覆写去改变它们的行为。 而sleep方法是在Thread类中是由native修饰的,本地方法。

        public static native void sleep(long l) throws InterruptedException;

     

    2.当线程调用了wait()方法时,它会释放掉对象的锁。
    另一个会导致线程暂停的方法:Thread.sleep(),它会导致线程睡眠指定的毫秒数,但线程在睡眠的过程中是不会释放掉对象的锁的。

    3.正因为wait方法会释放锁,所以调用该方法时,当前的线程必须拥有当前对象的monitor,也即lock,就是锁。要确保调用wait()方法的时候拥有锁,即,wait()方法的调用必须放在synchronized方法或synchronized块中。

    顺便说说notify(),notify()方法会唤醒一个等待当前对象的锁的线程。 如果多个线程在等待,它们中的一个将会选择被唤醒。这种选择是随意的,和具体实现有关。(线程等待一个对象的锁是由于调用了wait方法中的一个)。

    被唤醒的线程是不能被执行的,需要等到当前线程放弃这个对象的锁。
    被唤醒的线程将和其他线程以通常的方式进行竞争,来获得对象的锁。也就是说,被唤醒的线程并没有什么优先权,也没有什么劣势,对象的下一个线程还是需要通过一般性的竞争。
    且notify方法和wait一样,是需要放在synchronized方法或synchronized块中。

    展开全文
  • Java线程状态

    千次阅读 2014-11-29 19:03:17
    对于线程的状态的分类并没有严格的规定,只要能正确表示状态即可,如图2-5-7-1,先看其中一种状态分类,一个线程从创建到死亡可能会经历若干个状态,但在任意一个时间点线程只能处于其中一种状态,总共包含五个

    线程跟人类一样拥有自己的生命周期,一条线程从创建到执行完毕的过程即是线程的生命周期,此过程可能在不同时刻处于不同的状态,线程状态正是这小节的主题,线程到底有多少种状态?不同状态之间是如何转化的?

    对于线程的状态的分类并没有严格的规定,只要能正确表示状态即可,如图2-5-7-1,先看其中一种状态分类,一个线程从创建到死亡可能会经历若干个状态,但在任意一个时间点线程只能处于其中一种状态,总共包含五个状态:新建(new)、可运行(runnable)、运行(running)、非可运行(not runnable)、死亡(dead)。线程的状态的转化可以由程序控制,通过某些API可以达到转化效果,例如Thread类的start、stop、sleep、suspend、resume、wait、notify等方法(stop、suspend、resume等方法因为容易引起死锁问题而早已被弃用)。

    图2-5-7-1

     

    l   新建(new):一个线程被创建了但未被启动就处于新建状态,即在程序中使用new MyThread();创建的线程实例就处于此状态。

    l   可运行(runnable)&#x

    展开全文
  • [线程学习]线程状态

    千次阅读 2006-09-29 16:16:00
    线程状态,任何一个线程肯定处于这状态中的一种:产生(New),可执行(Runnable),死亡(Dead),停滞(Blocked)。1、产生(New):线程对象已经产生,但尚未被启动,所以无法执行。如通过new产生了一...


    线程有四种状态,任何一个线程肯定处于这四种状态中的一种:产生(New),可执行(Runnable),死亡(Dead),停滞(Blocked)。
    1、产生(New):线程对象已经产生,但尚未被启动,所以无法执行。如通过new产生了一个线程对象后没对它调用start()函数之前。
    2、可执行(Runnable):每个支持多线程的系统都有一个排程器,排程器会从线程池中选择一个线程并启动它。当一个线程处于可执行状态时,表示它可能正处于线程池中等待排排程器启动它;也可能它已正在执行。如执行了一个线程对象的start()方法后,线程就处于可执行状态,但显而易见的是此时线程不一定正在执行中。
    3、 死亡(Dead):当一个线程正常结束,它便处于死亡状态。如一个线程的run()函数执行完毕后线程就进入死亡状态。
    4、 停滞(Blocked):当一个线程处于停滞状态时,系统排程器就会忽略它,不对它进行排程。当处于停滞状态的线程重新回到可执行状态时,它有可能重新执行。如通过对一个线程调用wait()函数后,线程就进入停滞状态,只有当再次对该线程调用notify或notifyAll后它才能再次回到可执行状态。

    http://www.hxitz.com/Edu/Arts/chedimingbaiJavadeduoxianchengxianchengjiandetongxin1.html
     

    展开全文
  • 一,线程状态的检查 一般情况下无法确定一个线程的运行状态,对于这些处于未知状态线程,可以通过isAlive()方法用来确定一个线程是否仍处在活动状态。当然即使处于活动状态线程也并不意味着这个线程一定正在...
  • 线程状态和基本操作

    万次阅读 多人点赞 2019-10-03 23:36:42
    在上一篇博客中并发编程的优...文章目录创建线程种方式线程状态和生命周期线程状态的基本操作interruptedjoinsleepyield进程和线程线程优先级守护线程和用户线程守护线程详解线程死锁认识线程死锁如何避免线...
  • 线程状态

    千次阅读 2007-11-11 01:24:00
    1. 新状态线程已被创建但尚未执行(start() 尚未被调用)。2. 可执行状态线程可以执行,虽然不一定正在执行。CPU 时间随时可能被分配给该线程,从而使得它执行。3. 死亡状态:正常情况下 run() 返回使得...
  • 一、在java中怎样实现多线程? extends Thread implement Runnable 方法一:继承 Thread 类,覆盖方法 run(),我们在...下面是一例子:  public class MyThread extends Thread  {  int count= 1, nu...
  • Java线程状态分析/线程状态转换图

    万次阅读 多人点赞 2018-05-12 10:16:16
    注:以下代码讲解基于JDK1.8.0_144一、线程状态分类 线程一共有六种状态,分别为New、RUNNABLE、BLOCKED、WAITING、TIMED_WAITINGTERMINATED,同一时刻只有一种状态,通过线程的getState方法可以获取线程状态。...
  • 线程的5种状态详解

    万次阅读 多人点赞 2018-08-23 11:02:42
    1.新建(NEW):新创建了一个线程对象。 2.可运行(RUNNABLE):线程对象创建后,其他线程(比如main线程)调用了该对象的start()方法。该状态线程位于可运行线程池中,等待被线程调度选中,获取cpu 的使用权 。 3....
  • 线程创建的种方式

    万次阅读 多人点赞 2018-03-30 14:34:14
    java中创建线程种方法以及区别 Java使用Thread类代表线程,所有的线程对象都必须是Thread类或其子类的实例。Java可以用种方式来创建线程,如下所示: 1)继承Thread类创建线程 2)实现Runnable接口创建线程...
  • 线程锁的状态

    千次阅读 2019-05-24 13:39:41
    重量锁又被称为监视器锁,每对象有一监视器锁,当监视器锁被占用时就会处于锁定状态,其它线程必须等待当前线程执行完毕后,才可以竞争获取监视器锁,监视器锁是互斥锁。 监视器锁本质是...
  • Java多线程线程状态转换

    千次阅读 2015-03-10 15:53:08
    Java实现多线程的方法有两种,一是继承Thread类、二是实现Runnable接口。 一、继承Thread类 public class ThreadTest extends Thread { @Override public void run() { System.out.println("this thread name ...
  • JVM线程状态

    千次阅读 2018-12-18 11:24:22
    在jvm中一共定义了6种线程状态,分别是:NEW,RUNNABLE,BLOCKED,WAITING,TIMED_WAITING,TERMINATED。在Thread类中体现为下面的代码: public static enum State { NEW, RUNNABLE, BLOCKED, WAITING, TIMED_...
  • Java之线程状态

    千次阅读 2015-06-13 04:33:08
    1.New(新生),使用new Thread(r)创建一线程时,该线程处于新生状态,新生状态会为线程的运行做一些准备。 2.Runnable(可运行),调用线程的start方法,使该线程处于可运行状态。可运行状态不代表该线程一定...
  • 话说线程种暂停状态

    千次阅读 2012-07-18 18:44:15
    对于线程对象,如果想让其暂时停止,但是恢复运行后又不至于产生一新的线程对象时,就需要知道如何让线程处于暂停状态了。在java语言中,可通过如下种方式来实现该功能:    1、sleep()方法  sleep的中文...
  • Java进程与线程线程状态及判断

    千次阅读 2019-02-19 23:19:49
    二、线程:一程序下的每一任务称之为一个线程线程:一程序同时可以执行多任务,比如,一浏览器可以同时下载很多图片,音乐 三、对多进程、多线程的形象化描述:比如学校餐厅,有多窗口...
  • 1、新建状态(New):新创建了一个线程对象。 2、就绪状态(Runnable):线程对象创建后,其他线程调用了该对象的start()方法。该状态线程位于“可运行线程池”中,变得可运行,只等待获取CPU的使用权。即在就绪状态...
  • [超级链接:Java并发学习系列-绪论] 本章主要对Java中线程状态转换进行学习。 1.前言 ...thread.join():在当前线程中加入指定线程,使得这指定线程等待当前线程,并在当前线程结束前结束。 t...
  • 线程的六种状态及其状态的转换

    万次阅读 2018-10-04 18:15:26
    1.线程自身信息 线程运行的过程会产生很多信息,这些信息都保... 线程的优先级:getPriority,线程优先级从1-10,其中数字越大表示优先级别越高,同时获得JVM调度执行的可能性越大,JDK内置了三种常见的状态: //...
  • 线程指在程序执行过程中,能够执行程序代码的一执行单位,每程序至少都有一个线程,也就是程序本身。 Java中的线程状态分别是:运行、就绪、挂起、结束。
  • 总结了线程安全性的二十四个精华问题

    千次阅读 多人点赞 2019-12-05 19:19:27
    1、对象的状态:对象的状态是指存储在状态变量中的数据,对象的状态可能包括其他...当多个线程访问某个状态变量并且其中有一个线程执行写入操作时,必须采用同步机制来协同这些线程对变量的访问。同步机制包括synch...
  • 线程状态初始态:NEW创建一Thread对象,但还未调用start()启动线程时,线程处于初始态。运行态:RUNNABLE在Java中,运行态包括就绪态 和 运行态。 就绪态 该状态下的线程已经获得执行所需的所有资源,只要CPU...
  • 线程各种状态

    千次阅读 2015-06-02 13:12:17
    - Sleep 之后还会占用 CPU 资源,而貌似等待就不会; - 要想用wait方法必须...线程1(比如消费者线程)调用lock.wait()方法后,线程1就停下,直到其他某个线程(比如生产者线程)调用了lock.notify()或者lock.notif
  • 1、线程状态 NSThread *thread = [[Thread alloc] initWithTarget: self selector:@selector(run) object: nil];...在thread没有start之前alloc之后处于一新建状态,进程会为其线程分配内存(把线程放入到内存中)
  • java线程的五大状态,阻塞状态详解

    千次阅读 2020-08-17 09:45:54
    个线程的生命周期里有五大状态,分别是: 新生 就绪 运行 死亡 运行后可能遇到的阻塞状态 二、相关方法 2.1 新生状态 Thread t = new Thread(); 正如我们前面所说的,一个线程开始之后有自己的内存空间,这些...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 393,397
精华内容 157,358
关键字:

线程四个状态