Java 线程的创建与线程状态

Java 线程的创建

Java 线程的创建有四种方式，如下：

1. 通过继承Thread类，重写run方法
2. 通过实现Runnable接口，实现run方法
3. 通过实现Callable接口，实现call方法，然后由线程池启动，Future对象获取线程情况
4. 通过实现Callable接口，实现call方法，然后由线程池启动，FutureTask对象获取线程情况

1、继承Thread类 

public class MyThreadClass {

    public static class MyThread extends Thread {
        public void run() {
            System.out.println("====== 小弟在银行排队取钱，排队中。。。");
            try {
                sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("====== 小弟排完队，取到了1000块钱");
        }
    }

    public static void main(String[] args) {
        Thread xiaodi = new MyThread();
        System.out.println("====== 小明安排小弟去银行取钱");
        xiaodi.start();
        System.out.println("====== 小明内心：这小弟不靠谱啊，不知道小弟懂不懂怎么取钱，也不知道有没有取到钱");
        /**
         * 1. run方法不是强制要重写的，用户可以不重写
         * 2. 任务处理结果没有告诉主线程
         */
    }
}

2、实现Runnable接口

import static java.lang.Thread.sleep;

public class MyRunnable {

    public static class MyThread implements Runnable{
        @Override
        public void run() {
            System.out.println("====== 小弟在银行排队取钱，排队中。。。");
            try {
                sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("====== 小弟排完队，取到了1000块钱");
        }
    }

    public static void main(String[] args) {
        Thread xiaodi = new Thread(new MyThread());
        System.out.println("====== 小明安排小弟去银行取钱");
        xiaodi.start();
        System.out.println("====== 小明内心：这小弟不靠谱啊，有没有取到钱也不说一声");
        /**
         * 1. 任务处理结果没有告诉主线程
         */
    }
}

3、Callable接口和Future对象

import java.util.concurrent.*;
import static java.lang.Thread.sleep;

public class MyCallable {

    public static class MyThread implements Callable<String>{
        @Override
        public String call() throws Exception {
            System.out.println("====== 小弟在银行排队取钱，排队中。。。");
            try {
                sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("====== 小弟排完队，取到了1000块钱");
            return "大哥，我取到1000块钱了";
        }
    }

    public static void main(String[] args) throws Exception {
        ExecutorService threadPool = Executors.newFixedThreadPool(1);
        System.out.println("====== 小明安排小弟去银行取钱");
        Future future = threadPool.submit(new MyThread());
        System.out.println("====== 小弟发消息回来，说："+future.get());
        // 关闭线程池
        threadPool.shutdown();
        System.out.println("====== 小明内心：这小弟不错，事事有回应，取到钱了能说一声");
    }
}

4、Callable接口和FutureTask对象

import java.util.concurrent.*;
import static java.lang.Thread.sleep;

public class MyCallable {

    public static class MyTask implements Callable {
        @Override
        public Object call() throws Exception {
            System.out.println("====== 小弟在银行排队取钱，排队中。。。");
            try {
                sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("====== 小弟排完队，取到了1000块钱");
            return "大哥，我取到1000块钱了";
        }
    }

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        ExecutorService threadPool = Executors.newFixedThreadPool(1);
        System.out.println("====== 小明安排小弟去银行取钱");
        FutureTask futureTask = new FutureTask(new MyTask()){
            @Override
            protected void done() {
                System.out.println("====== 小弟取钱回来，把钱放我桌子上了");
                super.done();
            }
        };
        threadPool.submit(futureTask);
        System.out.println("====== 小弟发消息回来，说："+futureTask.get());
        // 关闭线程池
        threadPool.shutdown();
        System.out.println("====== 小明内心：这小弟不错，事事有闭环，明年让他当话事人");
    }
}

Java 线程状态

Java中线程的状态分为六种，定义在Thread类的State枚举中。

public class Thread implements Runnable {
	...
	public enum State {
		NEW,
		RUNNABLE,
		BLOCKED,
		WAITING,
		TIMED_WAITING,
		TERMINATED;
	}
	...
}

NEW：初始状态，创建一个线程对象时，线程就处于该状态。
RUNNABLE：运行状态，它包含了就绪（READY）和运行中（RUNNING）两种状态。当线程对象创建后，调用该对象的 start() 方法就会进入就绪状态（READY）。该状态的线程位于可运行线程池中，等待被线程调度选中，获取 CPU 的使用权，在获得 CPU 时间片后会变为运行中状态（RUNNING）。
BLOCKED：阻塞状态，表示线程此时被阻塞了。
WAITING：等待状态，进入该状态的线程需要等待其他线程做出一些特定动作（通知或中断）。
TIMED_WAITING：超时等待状态，该状态与 WAITING 的不同点在于它可以指定等待时间，超过等待时间后，停止等待，自行返回。
TERMINATED：终止状态，表示该线程已经执行完。

下图是Java线程状态之间的切换