线程知识学习二（创建线程的五种方式及线程的状态）

创建线程的五种方式

1、继承Thread类（不建议使用，Java单继承，使用此方式不灵活）
2、实现Runnable接口
3、lambda表达式
4、使用ThreadPool（池子里面已经有线程，然后直接通过池子往外拿）
5、实现Callable接口（Runnable无返回值Callable有返回值）

public class HowToCreateThread {
    static class MyThread extends Thread {
        @Override
        public void run() {
            System.out.println("Hello MyThread!");
        }
    }

    static class MyRun implements Runnable {
        @Override
        public void run() {
            System.out.println("Hello MyRun!");
        }
    }

    static class MyCall implements Callable<String> {
        @Override
        public String call() {
            System.out.println("Hello MyCall");
            return "success";
        }
    }

    //启动线程的5种方式
    public static void main(String[] args) throws Exception {
        new MyThread().start();
        new Thread(new MyRun()).start();
        new Thread(() -> {
            System.out.println("Hello Lambda!");
        }).start();
		//自己启动线程装Callable
        FutureTask<String> task = new FutureTask<>(new MyCall());
        //new Thread()只能传Runnable，就需要用一个FutureTask，在里面放一个Callable
        Thread t = new Thread(task);
       //线程启动
        t.start();
        //阻塞等待
        System.out.println(task.get());

        ExecutorService service = Executors.newCachedThreadPool();
        //线程池执行Runnable接口的方法
        service.execute(() -> {
            System.out.println("Hello ThreadPool");
        });
		//线程池调用实现Callable接口的方法
        Future<String> f = service.submit(new MyCall());
        //Future是一个异步的概念，直接扔给线程一个任务，然后程序就可以继续往下执行了，就没必要再等着线程执行完。Future是将来拿到的一个值
        String s = f.get();
        //f.get()是一个阻塞的方法，等到拿到值为止才继续往下执行
        System.out.println(s);
        service.shutdown();

    }

}

线程的六种状态

NEW:线程刚刚创建，还没有启动
RUNNABLE:可运行状态，由线程调度器可以安排执行（Ready准备好了，Running正在执行）
WAITING:等待被唤醒（进入忙等待的状态，自旋的等待）
TIMED WAITING:隔一段时间自动唤醒（参数带时间的）
BLOCKED:被阻塞，正在等待锁（进入阻塞队列）
TERMINATED:线程结束
线程状态迁移图如下：

Thread.yield()方法暂时让出CPU让线程进入Ready状态，等待下次调用。
ThreadState状态转换演示：

//为了更直观的看以下演示的代码此处封装一个sleepSeconds方法
public class SleepHelper {
    public static void sleepSeconds(int seconds) {
        try {
            TimeUnit.SECONDS.sleep(seconds);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public static void sleepMilli(int i) {
        try {
            TimeUnit.MILLISECONDS.sleep(i);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

public class ThreadState {

    public static void main(String[] args) throws Exception {
        //===================================================
        Thread t1 = new Thread(() -> {
        //此处线程是正在执行的过程中所调用的实现了Runnable接口的匿名方法，所以此处的线程状态时RUNNABLE
            System.out.println("2: " + Thread.currentThread().getState());
            for (int i = 0; i < 3; i++) {
                SleepHelper.sleepSeconds(1);
                System.out.print(i + " ");
            }
            System.out.println();
        });
        //此处t1刚刚new出来但是还没调用start()方法，所以此处为NEW状态
        System.out.println("1: " + t1.getState());
        t1.start();
        t1.join();//等待t1线程结束所以最后输出为terminated
        System.out.println("3: " + t1.getState());

        //===================================================
        Thread t2 = new Thread(() -> {
            try {
                LockSupport.park();
                System.out.println("t2 go on!");
                TimeUnit.SECONDS.sleep(5);

            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        t2.start();
        TimeUnit.SECONDS.sleep(1);//此处让主线程等待sleep是为了让t2线程完全启动起来，执行park()方法，所以此处的输出为WAITING
        System.out.println("4: " + t2.getState());

        LockSupport.unpark(t2);
        TimeUnit.SECONDS.sleep(1);//此处确保t2是被叫醒了的，叫醒以后执行t2 go on，执行完成后t2线程执行sleep方法，所以此处的状态为TIMED_WAITING
        System.out.println("5: " + t2.getState());

        //===================================================
        final Object o = new Object();
        //t3需获得锁才能执行
        Thread t3 = new Thread(() -> {
            synchronized (o) {
                System.out.println("t3 得到了锁 o");
            }
        });

        new Thread(() -> {
            synchronized (o) {
                SleepHelper.sleepSeconds(5);
            }
        }).start();
		//确保上面带start()的线程已经被启动了，并且拿到锁
        SleepHelper.sleepSeconds(1);
	    //t3启动会一直等待之前的线程将锁释放出来，所以最后的输出为BLOCKED
        t3.start();
        SleepHelper.sleepSeconds(1);
        System.out.println("6: " + t3.getState());

        //===================================================
        final Lock lock = new ReentrantLock();
        Thread t4 = new Thread(() -> {
            lock.lock(); //省略try finally
            System.out.println("t4 得到了锁 o");
            lock.unlock();
        });

        new Thread(() -> {
            lock.lock();
            SleepHelper.sleepSeconds(5);
            lock.unlock();
        }).start();

        SleepHelper.sleepSeconds(1);

        t4.start();
        SleepHelper.sleepSeconds(1);
        //t4拿不到锁一直进入忙等待的状态为WAITING
        System.out.println("7: " + t4.getState());

        //===================================================
        Thread t5 = new Thread(() -> {
            LockSupport.park();
        });

        t5.start();

        SleepHelper.sleepSeconds(1);
		//park()也是进入WAITING状态
        System.out.println("8: " + t5.getState());
        LockSupport.unpark(t5);

    }
}

运行结果如下：

结论：只有synchronized会让线程进入到BLOCKED状态（因为经过操作系统的调度）。