java 多线程的状态迁移 常用线程方法分析

一、线程的各个状态

　　图中的线程状态（Thread.Stat 中定义的Enum 名）NEW、RUNNABLE 、TERMINATED、WAITING、TIMED_WAITING 和BLOCKED 都能够通过Thread 类的getState 方法获取。

由图中可以看到:

1、sleep方法只有timed_waiting，是Thread的静态方法，可以通过Thread类名调用，也可以用线程对象调用，执行sleep方法不释放锁，只让出CPU等待，是给其他线程执行机会的最佳选择；

2、wait方法notify、notifyAll方法只能在加锁的代码synchronized(obj) 中使用，用被锁住的资源Object.wait()调用，wait()之后，释放对象锁，进入等待队列，被其他程序notify或者超时之后进入同步队列，去争夺锁。

3、I/O操作类似sleep，是不会释放锁。

4、在线程thread2中调用thread1.join()方法，则thread2线程会等待thread1线程执行完毕后才会继续执行，等待过程不会释放锁。（可参考下文代码）

5、obj.notify()唤醒在此对象等待队列上等待的单个线程，选择是任意性的。notifyAll()唤醒在此对象等待队列上等待的所有线程

6、Thread.yield()，当前线程调用此方法，当前线程放弃获取的CPU时间片，但不释放锁资源，由运行状态立即变为就绪状态，让OS再次选择线程。作用：让相同优先级的线程轮流执行，但并不保证一定会轮流执行。实际中无法保证yield()达到让步目的，因为让步的线程还有可能被线程调度程序再次选中。

public class join_sync {
    public static void main(String[] args) {
        Object oo = new Object();
        MyThread1 t1 = new MyThread1("线程t1--");
        MyThread2 t2 = new MyThread2("线程t2--", oo,t1);
        MyThread3 t3 = new MyThread3("线程t3--",oo);
        t2.start(); //t2先启动获得锁
        t3.start(); //t3刚启动时不会获得锁，因为锁被t2占有，t2中执行到join()时，t2先等待t1执行，但是此时没有释放锁
        t1.start(); //t2中执行到join()时，t2先等待t1执行结束，t2继续执行
    }
}

class MyThread1 extends Thread{
    private String name;
    public MyThread1(String name){
        this.name = name;
    }
    @Override
    public void run() {
            for(int i = 0; i < 20; i++){
                System.out.println(name + i);
            }
    }
}

class MyThread2 extends Thread{
    private String name;
    private Object oo;
    public Thread threadd;
    public MyThread2(String name,Object oo,Thread threadd){
        this.name = name;
        this.oo = oo;
        this.threadd = threadd;
    }
    @Override
    public void run() {
        synchronized (oo) {
            for(int i = 0; i < 20; i++){
                System.out.println(name + i);
                if(i==10) {
                    try {
                        threadd.join();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }
}

class MyThread3 extends Thread{
    private String name;
    private Object oo;
    public MyThread3(String name,Object oo){
        this.name = name;
        this.oo = oo;
    }
    @Override
    public void run() {
        synchronized (oo) {
            for(int i = 0; i < 20; i++){
                System.out.println(name + i);
            }
        }
    }
}

线程t1--0
线程t2--0
线程t1--1
线程t2--1
线程t1--2
线程t2--2
线程t1--3
线程t2--3
线程t1--4
线程t2--4
线程t1--5
线程t2--5
线程t1--6
线程t2--6
线程t1--7
线程t2--7
线程t1--8
线程t2--8
线程t1--9
线程t2--9
线程t1--10
线程t2--10
线程t1--11
线程t1--12
线程t1--13
线程t1--14
线程t1--15
线程t1--16
线程t1--17
线程t1--18
线程t1--19
线程t2--11
线程t2--12
线程t2--13
线程t2--14
线程t2--15
线程t2--16
线程t2--17
线程t2--18
线程t2--19
线程t3--0
线程t3--1
线程t3--2
线程t3--3
线程t3--4
线程t3--5
线程t3--6
线程t3--7
线程t3--8
线程t3--9
线程t3--10
线程t3--11
线程t3--12
线程t3--13
线程t3--14
线程t3--15
线程t3--16
线程t3--17
线程t3--18
线程t3--19

 参考文献：https://blog.csdn.net/pange1991/article/details/53860651