精华内容
下载资源
问答
  • java线程状态转换图

    2011-07-04 11:27:47
    java线程状态之间的转换图,包含转换的一些条件
  • 线程状态转换图及各部分介绍

    千次阅读 2019-04-11 22:13:14
    线程状态转换图 线程的几种状态 新建状态(New): 用new语句创建的线程处于新建状态,此时它和其他Java对象一样,仅仅在堆区中被分配了内存。 就绪状态(Runnable): 当一个线程对象创建后,其他线程调用它的...

    线程的状态转换图

    在这里插入图片描述

    线程的几种状态

    • 新建状态(New):
      用new语句创建的线程处于新建状态,此时它和其他Java对象一样,仅仅在堆区中被分配了内存。
    • 就绪状态(Runnable):
      当一个线程对象创建后,其他线程调用它的start()方法,该线程就进入就绪状态,Java虚拟机会为它创建方法调用栈和程序计数器。处于这个状态的线程位于可运行池中,等待获得CPU的使用权。
    • 运行状态(Running):
      处于这个状态的线程占用CPU,执行程序代码。只有处于就绪状态的线程才有机会转到运行状态。
    • 阻塞状态(Blocked):
      阻塞状态是指线程因为某些原因放弃CPU,暂时停止运行。当线程处于阻塞状态时,Java虚拟机不会给线程分配CPU。直到线程重新进入就绪状态,它才有机会转到运行状态。
      • 阻塞状态可分为以下3种:
        • 位于对象等待池中的阻塞状态(Blocked in object’s wait pool):
          当线程处于运行状态时,如果执行了某个对象的wait()方法,Java虚拟机就会把线程放到这个对象的等待池中,这涉及到“线程通信”的内容。
        • 位于对象锁池中的阻塞状态(Blocked in object’s lock pool):
          当线程处于运行状态时,试图获得某个对象的同步锁时,如果该对象的同步锁已经被其他线程占用,Java虚拟机就会把这个线程放到这个对象的锁池中,这涉及到“线程同步”的内容。
        • 其他阻塞状态(Otherwise Blocked):
          当前线程执行了sleep()方法,或者调用了其他线程的join()方法,或者发出了I/O请求时,就会进入这个状态。
    • 死亡状态(Dead):
      当线程退出run()方法时,就进入死亡状态,该线程结束生命周期。

    线程状态转换图还可参考此博客Java线程状态分析/线程状态转换图

    展开全文
  • Java线程状态分析/线程状态转换图

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

    注:以下代码讲解基于JDK1.8.0_144

    一、线程状态分类
     

    线程一共有六种状态,分别为NewRUNNABLEBLOCKEDWAITINGTIMED_WAITING

    TERMINATED,同一时刻只有一种状态,通过线程的getState方法可以获取线程的状态。

    二、线程状态讲解

    2.1 NEW

          /**

             * Thread state for a thread which has not yet started.

             */

            NEW,

         当线程被创建出来还没有被调用start()时候的状态。    

    2.2 RUNNABLE

            /**

             * Thread state for a runnable thread.  A thread in the runnable

             * state is executing in the Java virtual machine but it may

             * be waiting for other resources from the operating system

             * such as processor.

             */

            RUNNABLE,

         当线程被调用了start(),且处于等待操作系统分配资源(如CPU)、等待IO连接、正在运行状态,即表示Running状态和Ready状态。

         注:不一定被调用了start()立刻会改变状态,还有一些准备工作,这个时候的状态是不确定的。

    2.3 BLOCKED

            /**

             * Thread state for a thread blocked waiting for a monitor lock.

             * A thread in the blocked state is waiting for a monitor lock

             * to enter a synchronized block/method or

             * reenter a synchronized block/method after calling

             * {@link Object#wait() Object.wait}.

             */

            BLOCKED,

          等待监视锁,这个时候线程被操作系统挂起。当进入synchronized/方法或者在调用wait()被唤醒/超时之后重新进入synchronized/方法,锁被其它线程占有,这个时候被操作系统挂起,状态为阻塞状态。

           阻塞状态的线程,即使调用interrupt()方法也不会改变其状态。

    2.4 WAITING

            /**

             * Thread state for a waiting thread.

             * A thread is in the waiting state due to calling one of the

             * following methods:

             * <ul>

             *   <li>{@link Object#wait() Object.wait} with no timeout</li>

             *   <li>{@link #join() Thread.join} with no timeout</li>

             *   <li>{@link LockSupport#park() LockSupport.park}</li>

             * </ul>

             *

             * <p>A thread in the waiting state is waiting for another thread to

             * perform a particular action.

             *

             * For example, a thread that has called <tt>Object.wait()</tt>

             * on an object is waiting for another thread to call

             * <tt>Object.notify()</tt> or <tt>Object.notifyAll()</tt> on

             * that object. A thread that has called <tt>Thread.join()</tt>

             * is waiting for a specified thread to terminate.

             */

            WAITING,

    无条件等待,当线程调用wait()/join()/LockSupport.park()不加超时时间的方法之后所处的状态,如果没有被唤醒或等待的线程没有结束,那么将一直等待,当前状态的线程不会被分配CPU资源和持有锁。

    2.5 TIMED_WAITING

            /**

             * Thread state for a waiting thread with a specified waiting time.

             * A thread is in the timed waiting state due to calling one of

             * the following methods with a specified positive waiting time:

             * <ul>

             *   <li>{@link #sleep Thread.sleep}</li>

             *   <li>{@link Object#wait(long) Object.wait} with timeout</li>

             *   <li>{@link #join(long) Thread.join} with timeout</li>

             *   <li>{@link LockSupport#parkNanos LockSupport.parkNanos}</li>

             *   <li>{@link LockSupport#parkUntil LockSupport.parkUntil}</li>

             * </ul>

             */

            TIMED_WAITING,

          有条件的等待,当线程调用sleep(睡眠时间)/wait(等待时间)/join(等待时间)/ LockSupport.parkNanos(等待时间)/LockSupport.parkUntil(等待时间)方法之后所处的状态,在指定的时间没有被唤醒或者等待线程没有结束,会被系统自动唤醒,正常退出。

    2.6 TERMINATED

            /**

             * Thread state for a terminated thread.

             * The thread has completed execution.

             */

            TERMINATED;

    执行完了run()方法。其实这只是Java语言级别的一种状态,在操作系统内部可能已经注销了相应的线程,或者将它复用给其他需要使用线程的请求,而在Java语言级别只是通过Java代码看到的线程状态而已。

    三、状态转换图

     四、常见场景

    4.1 RUNNABLE状态

    主要是测试在进入run方法之后线程的状态,以及在等待IO的时候,线程的状态。

    测试代码:

    public static void testStateRunnable() {
    		IOThread simpleThread = new IOThread("IOThread");
    		simpleThread.start();
    
    		try {
    			Thread.sleep(100);
    		} catch (InterruptedException e) {
    			e.printStackTrace();
    		}
    
    		System.out.println("Main thread check the state is " + simpleThread.getState() + "."); // RUNNABLE
    	}
    
    	static class IOThread extends Thread {
    
    		public IOThread(String name) {
    			super(name);
    		}
    
    		@Override
    		public void run() {
    			System.out.println("In run method, state is " + getState() + "."); // RUNNABLE
    			Socket socket = new Socket();
    			try {
    				System.out.println("Try to connect socket address which not exist...");
    				socket.connect(new InetSocketAddress(
    						InetAddress.getByAddress(new byte[] { (byte) 192, (byte) 168, 1, 14 }), 5678));
    			} catch (UnknownHostException e) {
    				e.printStackTrace();
    			} catch (IOException e) {
    				e.printStackTrace();
    			} finally {
    				try {
    					socket.close();
    				} catch (IOException e) {
    					e.printStackTrace();
    				}
    			}
    		}
    	}

    测试结果:

    In run method, state is RUNNABLE.
    
    Try to connect socket address which not exist...
    
    Main thread check the state is RUNNABLE.

    堆栈信息:

    "IOThread" #10 prio=5 os_prio=0 tid=0x00000000187c7800 nid=0x8b0 runnable [0x00000000192ee000]
       java.lang.Thread.State: RUNNABLE
    	at java.net.DualStackPlainSocketImpl.connect0(Native Method)
    	at java.net.DualStackPlainSocketImpl.socketConnect(DualStackPlainSocketImpl.java:79)
    	at java.net.AbstractPlainSocketImpl.doConnect(AbstractPlainSocketImpl.java:350)
    	- locked <0x00000000eb6c0fa8> (a java.net.DualStackPlainSocketImpl)
    	at java.net.AbstractPlainSocketImpl.connectToAddress(AbstractPlainSocketImpl.java:206)
    	at java.net.AbstractPlainSocketImpl.connect(AbstractPlainSocketImpl.java:188)
    	at java.net.PlainSocketImpl.connect(PlainSocketImpl.java:172)
    	at java.net.SocksSocketImpl.connect(SocksSocketImpl.java:392)
    	at java.net.Socket.connect(Socket.java:589)
    	at java.net.Socket.connect(Socket.java:538)
    	at com.test.threadpool.TestThreadState$IOThread.run(TestThreadState.java:83)

    4.2 BLOCKED状态

    模拟两个线程抢锁,当一个线程抢到锁之后进入sleepsleep状态下不会释放锁,所以另外一个线程被阻塞。从堆栈信息可以看到,lockedwaiting to lock都是同一个对象。

    测试代码:

     public static void testBlockedState() {
    		Object lock = new Object();
    		SleepThread t1 = new SleepThread("t1", lock);
    		SleepThread t2 = new SleepThread("t2", lock);
    		t1.start();
    		t2.start();
    
    		try {
    			Thread.sleep(100);
    		} catch (InterruptedException e) {
    			e.printStackTrace();
    		}
    
    		System.out.println("Thread t1's state " + t1.getState());
    		System.out.println("Thread t2's state " + t2.getState());
    	}
    
    	static class SleepThread extends Thread {
    		private String name;
    		private Object lock;
    
    		public SleepThread(String name, Object lock) {
    			super(name);
    			this.name = name;
    			this.lock = lock;
    		}
    
    		@Override
    		public void run() {
    			System.out.println("Thread:" + name + " in run.");
    
    			synchronized (lock) {
    				System.out.println("Thread:" + name + " hold the lock.");
    
    				try {
    					Thread.sleep(1000 * 1000);
    				} catch (InterruptedException e) {
    					e.printStackTrace();
    				}
    
    				System.out.println("Thread:" + name + " return the lock.");
    			}
    		}
    	}

    测试结果:

    Thread:t2 in run.
    
    Thread:t1 in run.
    
    Thread:t2 hold the lock.
    
    Thread t1's state BLOCKED
    
    Thread t2's state TIMED_WAITING

    堆栈信息:

    "t2" #11 prio=5 os_prio=0 tid=0x0000000018604800 nid=0x934 waiting on condition [0x000000001920f000]
       java.lang.Thread.State: TIMED_WAITING (sleeping)
            at java.lang.Thread.sleep(Native Method)
            at com.test.threadpool.TestThreadState$SleepThread.run(TestThreadState.java:274)
            - locked <0x00000000eb64b910> (a java.lang.Object)
    "t1" #10 prio=5 os_prio=0 tid=0x000000001860b000 nid=0x3528 waiting for monitor entry [0x000000001910f000]
       java.lang.Thread.State: BLOCKED (on object monitor)
            at com.test.threadpool.TestThreadState$SleepThread.run(TestThreadState.java:271)
            - waiting to lock <0x00000000eb64b910> (a java.lang.Object)

    4.3 WAITING状态

    4.3.1 调用wait()方法导致的WAITING状态。

    测试代码:

     /**
    	 * 线程调用wait方法,状态变成WAITING。
    	 */
    	public static void testStateWatingByWait() {
    		Object lock = new Object();
    		WaitingThread waitingThread = new WaitingThread("WaitingThread", lock);
    		waitingThread.start();
    
    		try {
    			Thread.sleep(100);
    		} catch (InterruptedException e) {
    			e.printStackTrace();
    		}
    
    		System.out.println("Main thread check the state is " + waitingThread.getState() + "."); // WAITING
    	}
    
    	static class WaitingThread extends Thread {
    		private int timeout = 0;
    		private Object lock;
    
    		public WaitingThread(String name, Object lock) {
    			this(name, lock, 0);
    		}
    
    		public WaitingThread(String name, Object lock, int timeout) {
    			super(name);
    			this.timeout = timeout;
    			this.lock = lock;
    		}
    
    		@Override
    		public void run() {
    			synchronized (lock) {
    				if (timeout == 0) {
    					try {
    						System.out.println("Try to wait.");
    						lock.wait();
    					} catch (InterruptedException e) {
    						e.printStackTrace();
    					}
    				} else {
    					try {
    						System.out.println("Try to wait in " + timeout + ".");
    						lock.wait(timeout);
    					} catch (InterruptedException e) {
    						e.printStackTrace();
    					}
    				}
    			}
    
    			System.out.println("Over thread.");
    		}
    	}

    测试结果:

    Try to wait.
    
    Main thread check the state is WAITING.

    堆栈信息:

    "WaitingThread" #10 prio=5 os_prio=0 tid=0x0000000018dea000 nid=0x1220 in Object.wait() [0x00000000198ee000]
       java.lang.Thread.State: WAITING (on object monitor)
            at java.lang.Object.wait(Native Method)
            - waiting on <0x00000000eb6477e8> (a java.lang.Object)
            at java.lang.Object.wait(Object.java:502)
            at com.test.threadpool.TestThreadState$WaitingThread.run(TestThreadState.java:138)
            - locked <0x00000000eb6477e8> (a java.lang.Object)

    4.3.2 调用join()方法导致的WAITING状态。

    thread.join()方法其实就是synchronized(thread)内部一直判断thread的状态,如果为存活状态,就wait一个指定的时间,默认为0,然后继续循环判断,直到状态不为存活状态。

    测试代码:

     /**
    	 * 线程调用join方法,状态变成WAITING。
    	 */
    	public static void testStateWatingByJoin() {
    		Object lock = new Object();
    		WaitingThread waitingThread = new WaitingThread("WaitingThread", lock);
    		waitingThread.start();
    		JoinThread joinThread = new JoinThread("JoinThread", waitingThread);
    		joinThread.start();
    		
    		try {
    			Thread.sleep(100);
    		} catch (InterruptedException e) {
    			e.printStackTrace();
    		}
    
    		System.out.println("Main thread check the join thread's state is " + joinThread.getState() + "."); // WAITING
    	}
    
    	static class JoinThread extends Thread {
    		private int timeout = 0;
    		private Thread thread;
    
    		public JoinThread(String name, Thread thread) {
    			this(name, thread, 0);
    		}
    
    		public JoinThread(String name, Thread thread, int timeout) {
    			super(name);
    			this.timeout = timeout;
    			this.thread = thread;
    		}
    
    		@Override
    		public void run() {
    			if (timeout == 0) {
    				try {
    					System.out.println("Try to join.");
    					thread.join();
    				} catch (InterruptedException e) {
    					e.printStackTrace();
    				}
    			} else {
    				try {
    					System.out.println("Try to join in " + timeout + ".");
    					thread.join(timeout);
    				} catch (InterruptedException e) {
    					e.printStackTrace();
    				}
    			}
    			System.out.println("Over join.");
    		}
    	}
    	static class WaitingThread extends Thread {
    		private int timeout = 0;
    		private Object lock;
    
    		public WaitingThread(String name, Object lock) {
    			this(name, lock, 0);
    		}
    
    		public WaitingThread(String name, Object lock, int timeout) {
    			super(name);
    			this.timeout = timeout;
    			this.lock = lock;
    		}
    
    		@Override
    		public void run() {
    			synchronized (lock) {
    				if (timeout == 0) {
    					try {
    						System.out.println("Try to wait.");
    						lock.wait();
    					} catch (InterruptedException e) {
    						e.printStackTrace();
    					}
    				} else {
    					try {
    						System.out.println("Try to wait in " + timeout + ".");
    						lock.wait(timeout);
    					} catch (InterruptedException e) {
    						e.printStackTrace();
    					}
    				}
    			}
    
    			System.out.println("Over thread.");
    		}
    	}

    测试结果:

    Try to wait.
    
    Try to join.
    
    Main thread check the state is WAITING.

    堆栈信息:

    "JoinThread" #11 prio=5 os_prio=0 tid=0x0000000019007000 nid=0x33c0 in Object.wait() [0x0000000019c1f000]
       java.lang.Thread.State: WAITING (on object monitor)
            at java.lang.Object.wait(Native Method)
            - waiting on <0x00000000eb64a498> (a com.test.threadpool.TestThreadState$WaitingThread)
            at java.lang.Thread.join(Thread.java:1252)
            - locked <0x00000000eb64a498> (a com.test.threadpool.TestThreadState$WaitingThread)
            at java.lang.Thread.join(Thread.java:1326)
            at com.test.threadpool.TestThreadState$JoinThread.run(TestThreadState.java:194)
    "WaitingThread" #10 prio=5 os_prio=0 tid=0x0000000019006000 nid=0x35ac in Object.wait() [0x0000000019b1f000]
       java.lang.Thread.State: WAITING (on object monitor)
            at java.lang.Object.wait(Native Method)
            - waiting on <0x00000000eb64a468> (a java.lang.Object)
            at java.lang.Object.wait(Object.java:502)
            at com.test.threadpool.TestThreadState$WaitingThread.run(TestThreadState.java:138)
            - locked <0x00000000eb64a468> (a java.lang.Object)

    4.3.3 调用LockSupport.park方法导致的WAITING状态。

    使用线程池的时候经常会遇到这种状态,当线程池里面的任务都执行完毕,会等待获取任务。

    测试代码:

    public static void testStateWatingByThreadExecutor() {
    		ExecutorService executeService = Executors.newSingleThreadExecutor();
    		executeService.submit(new Runnable() {
    			@Override
    			public void run() {
    				System.out.println("Over Run.");
    			}
    		});
    
    		try {
    			Thread.sleep(10000);
    		} catch (InterruptedException e) {
    			e.printStackTrace();
    		}
    	}

    堆栈信息:

    "pool-1-thread-1" #10 prio=5 os_prio=0 tid=0x0000000018f9c000 nid=0x2e88 waiting on condition [0x0000000019aaf000]
       java.lang.Thread.State: WAITING (parking)
            at sun.misc.Unsafe.park(Native Method)
            - parking to wait for  <0x00000000eb64cc30> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject)
            at java.util.concurrent.locks.LockSupport.park(LockSupport.java:175)
            at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.await(AbstractQueuedSynchronizer.java:2039)
            at java.util.concurrent.LinkedBlockingQueue.take(LinkedBlockingQueue.java:442)
            at java.util.concurrent.ThreadPoolExecutor.getTask(ThreadPoolExecutor.java:1074)
            at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1134)
            at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:624)
            at java.lang.Thread.run(Thread.java:748)

    4.4 TIMED_WAITING状态

    只测试sleep()方法,其余参照WAITING状态。

    测试代码:

     public static void testSleep() {
    		try {
    			Thread.sleep(1000 * 100);
    		} catch (InterruptedException e) {
    			e.printStackTrace();
    		}
    	}

    堆栈信息:

    "main" #1 prio=5 os_prio=0 tid=0x0000000004f80800 nid=0x34bc waiting on condition [0x0000000004e7f000]
       java.lang.Thread.State: TIMED_WAITING (sleeping)
            at java.lang.Thread.sleep(Native Method)
            at com.test.threadpool.TestThreadState.testSleep(TestThreadState.java:233)
            at com.test.threadpool.TestThreadState.main(TestThreadState.java:53)

    4.5 NEWTERMINATED状态

    测试创建线程,启动线程,线程运行完毕。处于这两个状态的线程在堆栈不会出现在堆栈信息里面。

    测试代码:

    public static void testNewAndTerminatedState() {
    		Thread thread = new Thread(new Runnable() {
    			@Override
    			public void run() {
    				System.out.println("Over Run.");
    			}
    		});
    
    		System.out.println("State " + thread.getState() + ".");
    		thread.start();
    
    		try {
    			Thread.sleep(100);
    		} catch (InterruptedException e) {
    			e.printStackTrace();
    		}
    
    		System.out.println("State " + thread.getState() + ".");
    	}

    测试结果:

    State NEW.
    
    Over Run.
    
    State TERMINATED.
    展开全文
  • 在网上看到了很多关于线程状态转换图,我认为下面这个是描述的最为精确的一个,当然这个图是在参考别人的基础上修改得到的。下面我会对这个图做详细的说明,因为原图中的描述很少,不够详细。 在接下来的博文中,我...

    在网上看到了很多关于线程状态转换图,我认为下面这个是描述的最为精确的一个,当然这个图是在参考别人的基础上修改得到的。下面我会对这个图做详细的说明,因为原图中的描述很少,不够详细。

    在接下来的博文中,我会就java问题的线程的使用做详细的介绍。

    为什么说上面这个图是比较详细的,是因为上图中描述了wait方法和sleep方法在线程中的作用,具有很强的实践意义。

    由上图可知线程分为5个状态,创建(new)、可执行(runnable)、执行(running)、阻塞(block、sleep和wait)和结束(dead)。

    1. 创建阶段:创建一个新的线程,系统为线程分配线程执行所需要的非CPU资源的时候(在JVM中,为线程分配私有的虚拟机栈,本地方法栈和程序计数器),线程的状态转换成可执行状态。

    2. 可执行阶段:在此阶段的线程获得了CPU的时间片的时候即刻进入执行阶段。

    3. 执行阶段:在执行阶段程序可能遇到三种情况,第一种是程序自动放弃时间片就进入阻塞阶段;第二种是程序执行完时间片就会进入到可执行状态,等到再次获得时间片之后继续执行程序;第三种是程序执行完成或者在执行时异常产生,程序结束执行。

    4. 阻塞阶段:在此阶段,程序主动放弃在CPU执行的时间片,在此阶段调用方法sleep、wait方法、遇到锁或者遇到长时间不使用CPU的操作(长时间是相对而言的)。经过阻塞之后程序就进入了可执行阶段。其中理解wait方法和sleep方法对于资源的占有情况对于线程的理解很有好处。

    5. 结束阶段:在此阶段JVM销毁线程对象并且释放JVM分配的资源,即自动GC。

    最后我们看看wait和sleep的区别(很重要):

    1)wait:首先看一下java(J2SE8)的官方文档上是怎么说的

    由上图可知在执行wait方法时,当前线程会释放监视器的所有权,即是释当前所拥有的资源,让给其他线程使用。而且在调用wait方法之后需要使用notify或者notifyAll方法、中断或者在等待时间大于时间参数才能唤醒。更坑爹的是wait必须在同步快内才能使用,sleep方法的没有这个限制。

    2)sleep:同理

    上图可知sleep方法不会失去任何监视器的所有权,即是sleep的睡眠其实是线程在执行计数,也就是说线程是不会释放任何所拥有的资源。

    展开全文
  • Java Thread线程内部有一个枚举内部类State,定义了Java语言中线程共有6种状态 枚举值 NEW(初始化状态) RUNNABLE (可运行/运行状态) BLOCKED(阻塞状态) WAITING (无时限...

    介绍

    简易的线程状态如下图
    在这里插入图片描述
    Java Thread线程内部有一个枚举内部类State,定义了Java语言线程状态的枚举值

    1. NEW(初始化状态)
    2. RUNNABLE (可运行/运行状态)
    3. BLOCKED(阻塞状态)
    4. WAITING (无时限等待)
    5. TIMED_WAITING(有时限等待)
    6. TERMINATED(终止状态)

    Java将操作系统层面的阻塞状态细分为BLOCK,WAITING,TIMED_WAITING三种状态

    NEW:新建状态,线程被创建但未启动的状态。创建线程有三种方式

    1. 继承Thread类
    2. 实现Runnable接口
    3. 实现Callable接口

    我们最常用的是通过实现接口这种方式,Runnable和Callable接口的区别如下

    1. Runnable无法获取返回值,而Callable可以获取返回值
    2. Runnable无法抛出异常,而Callable可以抛出异常

    RUNNABLE(就绪状态):调用start之后运行之前的状态
    RUNNING(运行状态):线程正在运行
    BLOCKED(阻塞状态):进入以下状态,有以下几种情况

    1. BLOCK(同步阻塞):锁被其他线程占用,如等待进入synchronized方法或者代码块
    2. WAITING(主动阻塞):执行Object.wait(),Thread.join()等
    3. TIMED_WAITING(等待阻塞):执行Object.wait(long),Thread.sleep(long)等

    DEAD(终止状态):线程执行完毕
    最后将各种方法补充到线程状态图上
    在这里插入图片描述

    参考博客

    [1]https://blog.csdn.net/pange1991/article/details/53860651

    展开全文
  • 线程状态转换

    2015-03-23 11:04:36
    对于操作系统来说线程只是一小部分,但是在做分布式计算,云计算的时候,线程的优越性就可以体现了,所以掌握线程很重要
  • 线程状态转换图

    千次阅读 2017-05-21 21:20:38
    线程状态类型 1. 新建状态(New):新创建了一个线程对象。 2. 就绪状态(Runnable):线程对象创建后,其他线程调用了该对象的start()方法。该状态的线程位于可运行线程池中,变得可运行,等待获取CPU的使用权。...
  • Java多线程状态转换图

    2017-04-12 09:48:47
    线程状态类型 1. 新建状态(New):新创建了一个线程对象。 2. 就绪状态(Runnable):线程对象创建后,其他线程调用了该对象的start()方法。该状态的线程位于可运行线程池中,变得可运行,等待获取CPU的使用权。...
  • 线程状态转换图:两幅图仅是表现形式不同; 线程状态转化图一: 线程转换状态图二: 线程的几种状态: 新建状态(New): 用new语句创建的线程处于新建状态,此时它和其它java对象一样,仅仅在堆中分配了内存。 ...
  • JVM中线程状态转换图

    万次阅读 2014-08-28 20:29:20
    JVM中线程状态转换图 线程在一定条件下,状态会发生变化。线程一共有以下几种状态: 1、新建状态(New):新创建了一个线程对象。 2、就绪状态(Runnable):线程对象创建后,其他线程调用了该对象的start()方法。...
  • https://www.zhihu.com/question/27654579
  • Java线程状态转换图

    千次阅读 2014-10-12 13:07:22
    说明:本文只选择了原文的线程状态转换部分,由于原图中的线程状态名称和Java文档中的名称不对应,所以本文重新绘制了状态转换图,并尽量保持了原图的内容和样式。 原图对线程转换的解释非常好,这里补充...
  • 线程的五种状态转换

    2019-09-07 16:31:02
    线程通常都有五种状态,创建、就绪、运行、阻塞和死亡。 创建状态。在生成线程对象,并没有调用该对象的start方法,这是线程处于创建状态。 就绪状态。当调用了线程对象的start方法之后,该线程就进入了就绪状态,...
  • public enum State { NEW, RUNNABLE, WAITING, TIMED_WAITING, TERMINATED; }
  • 一、Java线程状态转换图 二、Java的几种线程状态说明 Java语言定义了6中状态,而同一时刻,线程有且仅有其中的一种状态。要获取Java线程的状态可以使用 java.lang.Thread类中定义的getState()方法,获取当前线程...
  • 线程状态转换图

    2018-11-27 11:26:02
    https://blog.csdn.net/yixueweima/article/details/81700542
  • JVM中线程状态转换图 线程在一定条件下,状态会发生变化。线程一共有以下几种状态: 1、新建状态(New):新创建了一个线程对象。 2、就绪状态(Runnable):线程对象创建后,其他线程调用了该对象的start()方法。...
  • 线程间的状态转换:  1. 新建(new):新创建了一个线程对象。 2. 可运行(runnable):线程对象创建后,其他线程(比如main线程)调用了该对象的start()方法。该状态的线程位于可运行线程池中,等待被线程...
  • 操作系统-进程状态转换图

    万次阅读 多人点赞 2019-03-23 11:30:01
    答:因为就绪态只需要等待处理机,而阻塞态可能在等待输入输出,即使分配给处理机也是徒劳,所以两状态图不妥。对于调度进程,只需要等待就绪队列里的进程,因为阻塞状态可以转换到就绪队列里去。 进程五状态 ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 170,997
精华内容 68,398
关键字:

线程状态转换图