Java 线程的基本状态和操作

线程的几种状态

在Java当中，线程通常都有五种状态，创建、就绪、运行、阻塞和死亡。

• 第一是创建状态。在生成线程对象，并没有调用该对象的start方法，这是线程处于创建状态。

• 第二是就绪状态。当调用了线程对象的start方法之后，该线程就进入了就绪状态，
  但是此时线程调度程序还没有把该线程设置为当前线程，此时处于就绪状态。在线程运行之后，从等待或者睡眠中回来之后，也会处于就绪状态。

• 第三是运行状态。线程调度程序将处于就绪状态的线程设置为当前线程，此时线程就进入了运行状态，开始运行run函数当中的代码。

• 第四是阻塞状态。线程正在运行的时候，被暂停，通常是为了等待某个时间的发生(比如说某项资源就绪)之后再继续运行。
  sleep,suspend，wait等方法都可以导致线程阻塞。

• 第五是死亡状态。如果一个线程的run方法执行结束或者调用stop方法后，该线程就会死亡。
  对于已经死亡的线程，无法再使用start方法令其进入就绪。

操作线程的基本函数

wait()

当一个线程执行到wait()时, 他会进入到一个和该对象相关的等待池中,同时失去了对象的锁机制,使得其他线程可以访问.
用户可以使用notify或notifyAll来唤醒当前等待池中的线程

Note:wait()和notify(),notifyAll()必须放在Synchronized Block中,否则会抛出异常

notify()会随机唤醒一个,一般使用notifyAll()就可以

/**
 * Created by yangtianrui on 17-1-1.
 * 线程的wait, sleep, join, yield方法
 */
public class WaitAndNotifyDemo {

    // 用于等待唤醒的对象
    private final static Object sLockObject = new Object();

    public static void main(String[] args) {
        waitAndNotifyAll();
    }


    private static void waitAndNotifyAll() {
        System.out.println("主线程执行");
        Thread thread = new WaitThread();
        thread.start();
        long startTime = System.currentTimeMillis();
        try {
            synchronized (sLockObject) {
                System.out.println("主线程等待");
                sLockObject.wait();
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        long deltaTime = System.currentTimeMillis();
        System.out.println("主线程等待了 " + (deltaTime - startTime));
    }

    private static class WaitThread extends Thread {
        @Override
        public void run() {
            try {
                synchronized (sLockObject) {
                    Thread.sleep(3000);
                    // 释放当前锁
                    // 或者使用notifyAll();
                    sLockObject.notify();
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}


/*
    主线程执行
    主线程等待
    主线程等待了 3000
*/

sleep()

该函数是sleep的静态函数,作用是使调用线程进入睡眠状态,因此他不能改变对象的锁机制,所以当一个Synchronized块中调用sleep(),
并不会使使当前线程释放掉这个锁,即使睡眠也持有这个对象锁

join()

等待目标线程执行完成后再继续执行

/**
 * Created by yangtianrui on 17-1-1.
 * Join() 阻塞当前调用Join()函数所在的线程,直到接收线程执行完毕后在执行
 */
public class JoinDemo {

    public static void main(String[] args) {
        Thread thread1 = new WorkerThread("worker-1");
        Thread thread2 = new WorkerThread("worker-2");
        thread1.start();
        System.out.println("启动线程1");
        try {
            // worker1 的join函数后,主线程会一直阻塞到thread1执行完毕
            thread1.join();
            System.out.println("启动线程2");
            thread2.start();
            thread2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("主线程继续执行");
    }


    private static class WorkerThread extends Thread {
        public WorkerThread(String name) {
            super(name);
        }

        @Override
        public void run() {
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("work in  " + getName());
        }
    }
}

/*
    启动线程1
    work in  worker-1
    启动线程2
    work in  worker-2
    主线程继续执行
*/

yield()

线程礼让,目标线程由运行状态转换成就绪状态,也就是让出执行权限,让其他线程得以优先执行,但其他线程能否优先执行是未知的.

Note: 让出执行时间并不是让出持有的对象锁

/**
 * Created by yangtianrui on 17-1-1.
 * yield()使该函数所在的线程让出执行时间给其他已经就绪的线程
 * <p>
 * 让出执行时间并不是让出持有的对象锁
 */

public class YieldDemo {


    public static void main(String[] args) {
        Thread thread1 = new YieldThread("thread-1");
        Thread thread2 = new YieldThread("thread-2");

        thread1.start();
        thread2.start();
    }


    private static class YieldThread extends Thread {
        public YieldThread(String name) {
            super(name);
        }

        @Override
        public void run() {
            for (int i = 0; i < 50; i++) {
                System.out.println(getName() + " priority=" + getPriority() + " i=" + i);
                // 每两次,执行一次yield()
                if (i % 2 == 0) {
                    Thread.yield();
                }
            }
        }
    }
}
/*
    到偶数时,会切换一次线程
    thread-1 priority=5 i=0
    thread-2 priority=5 i=0
    thread-1 priority=5 i=1
    thread-1 priority=5 i=2
    thread-2 priority=5 i=1
    thread-1 priority=5 i=3
    thread-2 priority=5 i=2
    thread-1 priority=5 i=4
    thread-2 priority=5 i=3
    thread-2 priority=5 i=4
    thread-1 priority=5 i=5
    thread-1 priority=5 i=6
    thread-2 priority=5 i=5
    thread-2 priority=5 i=6
    thread-1 priority=5 i=7
 */

Note: yield()调用之后,其他线程并不一定会抢占到 执行时间