精华内容
下载资源
问答
  • 线程状态

    2016-01-17 13:04:15
    线程状态 1. 新建状态-New:新创建了一个线程对象。 2. 就绪状态-Runnable:线程对象创建后,其他线程调用了该对象的start()方法。该状态的线程位于可运行线程池中,变得可运行,等待获取CPU的使用权。 3. 运行状态-...

     线程状态

    1. 新建状态-New:新创建了一个线程对象。
    2. 就绪状态-Runnable:线程对象创建后,其他线程调用了该对象的start()方法。该状态的线程位于可运行线程池中,变得可运行,等待获取CPU的使用权。
    3. 运行状态-Running:就绪状态的线程获取了CPU,执行程序代码。其中可以把就绪和运行状态笼统的称之为运行中
    4. 阻塞状态-Blocked:阻塞状态是线程因为某种原因放弃CPU使用权,暂时停止运行。直到线程进入就绪状态,才有机会转到运行状态。

    5.等待状态-WAITING:表示线程进入等待状态,进入该状态表示当前线程需要 其他线程做出一些特定的动作(通知或者中断),

    6.超时等待状态-TIME_WAITING:该状态不同于WAITING,它是可以在指定的时间内自行返回的

    7. 死亡状态-Dead/TERMINATED:终止状态,线程执行完了或者因异常退出了run()方法,该线程结束生命周期。

    其中阻塞状态分三种:
    (一)、等待阻塞:运行的线程执行wait()方法,JVM会把该线程放入等待池中。
    (二)、同步阻塞:运行的线程在获取对象的同步锁时,若该同步锁被别的线程占用,则JVM会把该线程放入锁池中。
    (三)、其他阻塞:运行的线程执行sleep()或join()方法,或者发出了I/O请求时,JVM会把该线程置为阻塞状态。当sleep()状态超时、join()等待线程终止或者超时、或者I/O处理完毕时,线程重新转入就绪状态。


    实例代码如下

    package thread.threadstatus;


    public class ThreadStatusTest {


        public static void main(String[] args) {
            new Thread(new TimeWaiting(), "TimeWaiting").start();
            new Thread(new Waiting(), "Waiting").start();
            new Thread(new Blocked(), "Blocked-1").start();
            new Thread(new Blocked(), "Blocked-2").start();
        }


        // 该线程不断的睡眠
        static class TimeWaiting implements Runnable {


            @Override
            public void run() {
                while (true) {
                    SleepUtils.second(100);
                }
            }


        }


        // 该线程在Waiting.class的实例上等待
        static class Waiting implements Runnable {


            @Override
            public void run() {
                while (true) {
                    synchronized (Waiting.class) {
                        try {
                            Waiting.class.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }


        }


        // 该线程在Blocked.class的实例上加了锁,不会释放该锁
        static class Blocked implements Runnable {


            @Override
            public void run() {
                synchronized (Blocked.class) {
                    while (true) {
                        SleepUtils.second(100);
                    }
                }
            }


        }
    }

    import java.util.concurrent.TimeUnit;


    public class SleepUtils {


        public static final void second(long second) {
            try {
                TimeUnit.SECONDS.sleep(second);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }





    展开全文
  • Java多线程03_线程状态、优先级、用户线程和守护线程 线程方法: setPriority() 更改线程优先级 static void sleep() 线程休眠 void join() 插队 static void yield() 礼让 void interrupt() 中断...

    Java多线程03_线程状态、优先级、用户线程和守护线程


    在这里插入图片描述


    线程方法:

    setPriority()				更改线程优先级
    static void sleep()			线程休眠
    void join()					插队
    static void yield()			礼让
    void interrupt()			中断线程
    boolean isAlive()			是否存活
    

    停止线程:

    不推荐JDK提供的stop()、destory()方法 【已废弃】

    推荐让线程正常停止,不要死循环!

    建议使用一个标志位进行终止,当flag=false,则终止线程运行

    public class TestStop implements Runnable{
    
    	private boolean flag = true;
    	
    	@Override
    	public void run() {
    		int i = 0;
    		while(flag) {
    			System.out.println("run...Thread"+i++);
    		}
    	}
    	
    	//设置公开方法利用标志位停止线程
    	public void stopThread() {
    		this.flag = false;
    		System.out.println("线程停止了");
    	}
    	
    	public static void main(String[] args) {
    		TestStop testStop = new TestStop();
    		new Thread(testStop).start();
    		
    		for(int i=0;i<1000;i++) {
    			System.out.println("main...,"+i);
    			if(i==900) {
    				testStop.stopThread();
    			}
    		}
    		
    	}
    	
    }
    

    线程休眠:

    sleep方法存在异常:InterruptedException

    sleep时间结束,线程进入就绪状态

    每个对象都有一个锁,sleep不会释放锁

    Thread.sleep(1000);
    

    线程礼让:

    让当前执行的线程暂停,但不阻塞

    将线程从运行状态转为就绪状态

    礼让不一定成功,看cpu心情

    Thread.yield();
    

    Join合并线程,待此线程执行完成后,再执行其他线程,其他线程阻塞(插队)

    main线程和Thread线程交替执行,当main线程执行到200时,Thread线程插队,一直到执行结束,main线程才能重新执行

    package com.blu.demo1;
    
    public class TestJoin implements Runnable{
    
    	@Override
    	public void run() {
    		for(int i = 0;i < 1000;i++) {
    			System.out.println("vip线程正在执行....."+i);
    		}
    	}
    	
    	public static void main(String[] args) throws InterruptedException {
    		TestJoin testJoin = new TestJoin();
    		Thread thread = new Thread(testJoin);
    		thread.start();
    		
    		for(int i = 0;i < 1000;i++) {
    			if(i==200) {
    				thread.join();
    			}
    			System.out.println("main线程正在执行....."+i);
    		}
    	}
    
    }
    

    getState()监测线程状态:

    返回枚举类型:

    NEW	
    RUNNABLE
    BLOCKED
    WAITING
    TIMED_WAITING
    TERMINATED
    

    线程优先级:

    线程优先级用1-10之间的整数表示,1为最低优先级,10为最高优先级

    主线程优先级默认为5,且不可修改

    枚举
    Thread.MAX_PRIORITY = 10
    Thread.NORM_PRIORITY = 5
    Thread.MIN_PRIORITY = 1

    优先级高不一定先执行,由CPU调度决定

    public class TestPriority {
    	
    	public static void main(String[] args) {
    		//主线程优先级
    		System.out.println(Thread.currentThread().getName()+"-->"+Thread.currentThread().getPriority());
    		MyPriority myPriority = new MyPriority();
    		Thread t1 = new Thread(myPriority);
    		Thread t2 = new Thread(myPriority);
    		Thread t3 = new Thread(myPriority);
    		Thread t4 = new Thread(myPriority);
    		Thread t5 = new Thread(myPriority);
    		Thread t6 = new Thread(myPriority);
    		//设置优先级
    		t1.start();
    		t2.setPriority(1);
    		t3.setPriority(4);
    		t4.setPriority(Thread.MAX_PRIORITY);
    		t5.setPriority(5);
    		t6.setPriority(7);
    		t2.start();
    		t3.start();
    		t4.start();
    		t5.start();
    		t6.start();
    	}
    	
    }
    
    class MyPriority implements Runnable{
    
    	@Override
    	public void run() {
    		System.out.println(Thread.currentThread().getName()+"-->"+Thread.currentThread().getPriority());
    	}
    	
    }
    

    守护线程

    线程分为用户线程(比如main)守护线程(比如gc)

    虚拟机必须确保用户线程执行完毕,不用等待守护线程执行完毕

    当只剩下守护线程时,JVM就会退出,只要存在一个用户线程,JVM就不会退出

    public class TestDaemon {
    	
    	public static void main(String[] args) {
    		God god = new God();
    		You you = new You();
    		Thread thread = new Thread(god);
    		thread.setDaemon(true);
    		thread.start();
    		new Thread(you).start();
    	}
    }
    
    class God implements Runnable{
    	
    	@Override
    	public void run() {
    		while(true) {
    			System.out.println("上帝保佑着你");
    		}
    	}
    }
    
    class You implements Runnable{
    
    	@Override
    	public void run() {
    		for(int i = 0;i<=100;i++) {
    			System.out.println("你开心地活了"+i+"年");
    		}
    		System.out.println("GoodBye,World!");
    	}
    	
    }
    
    展开全文
  • 线程状态转换图:两幅图仅是表现形式不同; 线程状态转化图一: 线程转换状态图二: 线程的几种状态: 新建状态(New): 用new语句创建的线程处于新建状态,此时它和其它java对象一样,仅仅在堆中分配了内存。 ...

    线程状态转换图:

    线程状态转化图一:

    在这里插入图片描述

    线程的几种状态:

    • 新建状态(New):
      用new语句创建的线程处于新建状态,此时它和其它java对象一样,仅仅在堆中分配了内存。
    • 就绪状态(Runnable):
      当一个线程对象被创建后,其它线程调用它的start()方法,该线程就进入就绪状态。处于就绪状态的线程已经具备了运行条件,但还没有分配到CPU的使用权。该状态的线程位于可运行线程池中,等待获取CPU使用权;一旦获取到CPU,线程就会进入运行状态并自动调用自己的run方法;
    • 运行状态(Running):
      在运行状态的线程执行自己的run方法,直到调用其它方法(如Interrupt()或者抛异常)而终止/等待某资源而阻塞(锁资源)/完成任务而自然死亡。如果在给定的时间片内没有执行完毕,就会被系统给换下来回到等待执行状态。
    • 阻塞状态(Blocked):
      处于运行状态的线程在某些情况下,如执行了sleep()方法或者等待I/O设备资源,将让出CPU执行权停止自己的运行,进入阻塞状态。在阻塞状态下的线程不能进入就绪队列。只有当引起阻塞的原因消除时,如睡眠时间到,或者等待的I/O设备空闲下来。线程就会转入就绪状态,重新到就绪队列中排队等待。
    阻塞状态分为以下三种:
    • 位于对象等待池中的阻塞状态(Blocked in object’s wait pool):
      当线程处于运行状态时,如果执行了某个对象wait()方法,JVM就会把线程放到这个对象的等待池中,wait方法只有所在的线程只有被唤醒才会重新进入就绪状态。wait()方法带参数,如果时间到则不需要唤醒就会重新进入就绪状态,如果时间未到就被唤醒,则和没有参数的wait方法一样。
    • 位于对象锁池的中阻塞状态(Blocked in object’s lock pool):
      当线程处于运行状态时,试图获得某个对象的同步锁时,如果该对象锁被其它线程占用,JVM就会把这个线程放入对象的锁池中。
    • 其他阻塞状态(Otherwise Blocked):
      当前线程执行了sleep方法,或者调用了其它线程的join()方法,或者发出了I/O请求时,就会进入这个状态;
    • 死亡状态(Dead):
      当线程正常退出run方法/因异常退出run()方法,则该线程结束生命周期。死亡的线程不可再次复生。
    注意:

    wait方法是对象锁的方法,因此调用的时候可以释放锁。而sleep和join是线程的方法,因此阻塞时,是带着锁一起阻塞的,在次运行时,因为本身有锁,所以直接运行。

    线程状态转换图二:

    在这里插入图片描述
    在这里插入图片描述

    展开全文
  • 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.
    展开全文
  • Thread03之多线程线程状态

    万次阅读 2019-10-16 18:05:22
    简述 - 线程状态 demo:https://github.com/LiJinHongPassion/ThreadTest 当线程被创建并启动以后,它既不是一启动就进入了执行状态,也不是一直处于执行状态。 在线程的生命周期中,有几种状态呢?在API中 java....
  • 【多线程】线程状态和创建方式

    千次阅读 多人点赞 2021-02-24 20:28:30
    目录线程状态线程创建方式继承Thread和实现Runnable接口创建线程方式Callable接口创建线程线程池创建线程 线程状态 线程共存在5种状态:新建、就绪、运行、阻塞、死亡,如下图: 解释说明各个状态: 1、新建状态...
  • windows线程状态

    千次阅读 2019-01-29 13:53:07
    文章目录线程状态就绪态备用态运行态等待态转换态终止态线程关系线程同步线程互斥实现同步与互斥方法线程同步实例未同步状态使用临界区实现同步使用事件实现同步信号量使用互斥量使线程同步 线程状态 就绪态 可以被...
  • 守护线程及六种线程状态简介

    千次阅读 热门讨论 2020-03-03 18:55:10
    守护线程及六种线程状态简介 1. 守护线程 守护线程一般用于: 1. 自动下载 2. 操作日志 3. 操作监控 方法是通过线程对象 setDeamon(boolean flag); true为守护线程 false缺省属性,正常线程 2. 线程状态 ...
  • java线程状态——java线程状态

    千次阅读 2017-02-14 17:03:08
    java线程状态图,网上有很多资源,无外乎两种,如下: 图一 图二 图二是比较多的,可以看出来我贴出的链接这个博主挺有心的,还把右下角的水印给抹去了,赤裸裸的伪原创心理呀。 还有几张图说的也挺不错的,链接...
  • 线程状态: 线程共包括以下5种状态。 1.新建状态(New)  线程对象被创建后,就进入了新建状态。例如,Thread thread = new Thread()。 2.就绪状态(Runnable)  也被称为“可执行状态”。线程对象被创建后,...
  • Java多线程之线程状态转换、控制线程和线程同步
  • Java线程状态

    千次阅读 2014-11-29 19:03:17
    线程跟人类一样拥有自己的生命周期,一条线程从创建到执行完毕的过程即是线程的生命周期,此过程可能在不同时刻处于不同的状态,线程状态正是这小节的主题,线程到底有多少种状态?不同状态之间是如何转化的? 对于...
  • Java线程状态、线程停止、线程阻塞

    千次阅读 2015-05-28 08:59:44
    Java线程状态、线程停止、线程阻塞
  • 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线程状态详解

    2018-07-31 09:29:51
    线程状态 状态值 状态转换图 状态详解 NEW RUNNABLE BLOCKED 线程状态 状态值 NEW :未启动的。不会出现在Dump中。 RUNNABLE:在虚拟机内执行的。 BLOCKED:受阻塞并等待监视器锁。 WATING:无限期...
  • kvm线程-006-线程状态-THREAD_ACTIVE

    千次阅读 2019-07-25 14:47:39
    本文介绍线程状态THREAD_ACTIVE的使用.设置线程状态THREAD_ACTIVE的地方有: InitializeThreading,这点在kvm启动流程-006 中有详细介绍. resumeThread,其代码如下: void resumeThread(THREAD thisThread) { //...
  • jstack 线程状态

    千次阅读 2015-09-25 17:19:10
    jstack 线程状态 jstack 线程里,值得关注的线程状态有: 死锁,Deadlock(重点关注) 执行中,Runnable  等待资源,Waiting on condition(重点关注) 等待获取监视器,Waiting
  • Java线程状态转化

    2018-09-30 17:26:49
    先来一张线程状态转化图,然后我再慢慢解释: 在Java中线程的状态一共被分成6种: 初始态:NEW 创建一个Thread对象,但还未调用start()启动线程时,线程处于初始态。 运行态:RUNNABLE 在Java中,运行态包括...
  • jstack线程状态分析

    千次阅读 2016-03-11 19:48:23
    jstack线程状态
  • ps 命令查看进程下的线程及线程状态 查看java所有线程 ps –eLf | grep java 查看进程下的所有线程cpu利用率 Top -H -p 25120 其中25120为Java进程号。 下图红色标注的地方为线程状态。其中总数为28,当前运行的...
  • 线程状态转换图

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

    万次阅读 多人点赞 2012-03-04 00:07:28
    线程状态类型 1. 新建状态(New):新创建了一个线程对象。 2. 就绪状态(Runnable):线程对象创建后,其他线程调用了该对象的start()方法。该状态的线程位于可运行线程池中,变得可运行,等待获取CPU的使用权。...
  • Java线程状态及其转移

    千次阅读 2019-02-18 21:58:04
    说到线程,一定要谈到线程状态,不同的状态说明线程正处于不同的工作机制下,不同的工作机制下某些动作可能对线程产生不同的影响。  Java语言定义了6中状态,而同一时刻,线程有且仅有其中的一种状态。要获取Java...
  • Java学习笔记-线程状态

    千次阅读 2019-07-08 21:44:31
    线程状态概述 当线程被创建并启动以后,它既不是一启动就进入了执行状态,也不是一直处于执行状态。在线程的生命周期中,有几种状态呢?在APi中java.lang.Thread.State这个枚举中给出了六种线程状态: 这里先列出...
  • Java 线程状态有哪些?

    千次阅读 2019-03-11 20:00:00
    Java 线程状态有哪些? 线程状态有 5 种,新建,就绪,运行,阻塞,死亡。关系图如下: 1. 线程 start 方法执行后,并不表示该线程运行了,而是进入就绪状态,意思是随时准备运行,但是真正何时运行,...
  • Java线程状态与方法关系

    千次阅读 2016-12-15 14:31:13
    调用与线程有关的方法是造成线程状态改变的主要原因,使用Java多线程技术,其中线程状态和方法的关系如下图所示:
  • linux 下查看线程状态

    万次阅读 2018-03-12 13:23:53
    前言 在调试程序时需要查看各个线程的状态,方便定位问题。 解决 方法1、pstree pstree PID 方法2、top top 然后按H,会显示线程 ...此方法还可以查看线程状态 方法3、ps ps -T ...
  • 主要展示Java线程状态,以及状态的转换
  • 初始状态(new了对象没有start()) 可运行状态(等待分配cup时间片) 运行状态(分配到了cup时间片) 阻塞状态线程还没结束,但是暂时失去cup时间片) 终止状态线程结束) 状态之间的关系 ...
  • java线程状态切换图

    千次阅读 2015-01-08 10:01:30
    java线程状态

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 66,013
精华内容 26,405
关键字:

线程状态