第二篇：线程七种状态

线程状态

• 初始化状态
• 就绪状态
• 运行状态
• 死亡状态
• 阻塞状态
• 超时等待
• 等待状态

    1.1 初始化状态

        通过实现Runnable接口，new出来实例，线程进入初始化状态

    1.2 就绪状态

        初始化状态调用start()方法，程序进入了就绪状态。

            ①调用start(),sleep()结束，join()方法结束，调用yield()方法。

            ②某个线程拿到对象锁，锁池里的对象拿到对象锁。

            ③当前时间片用完。

    1.3 运行状态

        线程抢占到CPU资源。

    1.4 死亡状态

        线程正常执行完、调用stop()方法、抛出异常或ERROR。

    1.5 阻塞状态

        发生I/O输入，进入同步代码块

    1.6 超时等待

        执行Thread.sleep()方法，此方法是Thread内的方法，会抛出异常。

    1.7 等待状态

      调用Object里的wait()方法。

比较点	wait()	sleep()
所属类	Thread	Object
控制资源	释放资源，让出CPU	不释放资源，仅仅让出CPU
方法结束时刻	调用notify()或notifyAll()	超时时间到
调用方法后线程状态	线程释放对象锁，进入等待锁池	指定时间不运行
方法调用结束后	等待notify()、或者notifyAll()同步方法执行完拿到锁， 进入就绪状态	方法调用结束，进入就绪状态

    1.7 线程状态的切换

 线程状态切换中的方法说明

1. start()：调用start()方法会使得该线程开始执行，正确启动线程的方式。
2. wait()：调用wait()方法，进入等待状态，释放资源，让出CPU。需要在同步快中调用。
3. sleep()：调用sleep()方法，进入超时等待，不释放资源，让出CPU
4. stop()：调用sleep()方法，线程停止，线程不安全，不释放锁导致死锁，过时。
5. join()：调用sleep()方法，线程是同步，它可以使得线程之间的并行执行变为串行执行。
6. yield()：暂停当前正在执行的线程对象，并执行其他线程，让出CPU资源可能立刻获得资源执行。

   yield()的目的是让相同优先级的线程之间能适当的轮转执行

7. notify()：在锁池随机唤醒一个线程。需要在同步快中调用。
8. nnotifyAll()：唤醒锁池里所有的线程。需要在同步快中调用。

 线程状态方法测试

/**
 * 测试yield()
 */
public class TestYield {
	public static void main(String[] args) {
		MyThread t1 = new MyThread("t1");
		MyThread t2 = new MyThread("t2");
		t1.start();
		t2.start();
	}
}

class MyThread extends Thread {
	MyThread(String s) {
		super(s);
	}

	public void run() {
		for (int i = 1; i <= 100; i++) {
			System.out.println(getName() + ":" + i);
			if (i == 0)
				yield();
		}
	}
}
t1:1
t2:1 ---t2执行
t1:2
t1:3
t1:4
t2:2

　　

join()问题连接

/**
 * 测试join()
 */
public class JoinTest {
    public static void main(String [] args) throws InterruptedException {
        ThreadJoinTest t1 = new ThreadJoinTest("t1");
        ThreadJoinTest t2 = new ThreadJoinTest("t2");
        t1.start();
        t1.join();
        t2.start();
    }

}
class ThreadJoinTest extends Thread{
    public ThreadJoinTest(String name){
        super(name);
    }
    @Override
    public void run(){
        for(int i=0;i<10;i++){
            System.out.println(this.getName() + ":" + i);
        }
    }
}
t1:9
t2:0  --t1执行完，t2才执行
t2:1
t2:2
t2:3
t2:4

join()可以带参数：join(0)的意思不是A线程等待B线程0秒，而是A线程等待B线程无限时间，直到B线程执行完毕，即join(0)等价于join()。
join()必须在start()后，这样才能同步。

　　

 

转载于:https://www.cnblogs.com/dc-earl/p/9594162.html