线程的三种创建方式 &amp； 6种状态

操作系统线程和Java线程的区别

他们之间的状态是不同的，看下面的介绍

Java提供两个线程：守护线程和用户线程

守护线程又称为”服务进程、后台线程“。是指在程序在运行时在后台提供一种通用的服务的线程，对应程序来说时非必要的
用户线程，JVM内部提供的，比如main主线程和GC线程（垃圾回收机制）

#线程的三种实现方式：

1. 继承Thread类，重写run方法
2. 实现Runnable接口，重写run方法
3. 实现Cllable接口，重写call方法

方法三的功能更加强大：
call方法有返回值，可抛异常
run方法无返回值，不可抛异常

callable

类似于Runnable,但是会抛异常，有返回值，方法不同，不是run是call方法

Callabel<T> {
	@Override
	T call(){}
}

T就是方法的返回类型

开启线程只能用 new Thread().start()的方法，里面只能放Runnable接口，
但是Runnable接口有一个实现了FutureTask（Callable callable）
所以，可以使用 new Thread(new FutureTask(实现了callable接口的类)).start()开启线程。

返回值获取futureTask（）.get();

注意 & 代码：

• 实现Callable的时候可以确定泛型，从而让任务的返回值类型确定
• 获取返回值的时候可以设置超时时间，防止阻塞

public class test implements Callable {
    public static void main(String[] args) throws ExecutionException, InterruptedException, TimeoutException {
        test test = new test();
        FutureTask task = new FutureTask<>(test);
        Thread thread = new Thread(task);
        thread.start();
        Object o = task.get(100,  TimeUnit.MILLISECONDS); // 获得任务的返回值，且设置超时时间，防止阻塞
        System.out.println(o.toString());
    }

    @Override
    public Object call() throws Exception {
        System.out.println("kaishi");
        return "1";
    }
}

总结

从上面可以看出，无论使用何种方式，其基本都是Thread类的体现，所以，线程的一些方法都封装在Thread中。

• String getName();获得当前线程的名称
• void start();开启线程，执行run方法
• static void sleep(Long time);休眠，毫秒值
• static Thread currentThread(); 返回现在执行的线程对象的引用
• void setNaME(String name);设置线程名称

线程的状态（生命周期）

操作系统进程大致可以分为五状态：

• 1. 新建(NEW)，又称为创建状态，初始状态
• 2. 可运行(RUNNABLE)，又称为就绪状态
• 3. 运行(RUNNING)
• 4. 阻塞(BLOCKED)
• 5. 死亡(DEAD)

但是,Java的线程是六种状态： （这儿很多人容易混淆）

1. 初始(NEW)：新创建了一个线程对象，但还没有调用start()方法。

2. 运行(RUNNABLE)：Java线程中将就绪（ready）和运行中（running）两种状态笼统的称为“运行”。
   线程对象创建后，其他线程(比如main线程）调用了该对象的start()方法。该状态的线程位于可运行线程池中，等待被线程调度选中，获取CPU的使用权，此时处于就绪状态（ready）。就绪状态的线程在获得CPU时间片后变为运行中状态（running）。

3. （锁）阻塞(BLOCKED)：表示线程阻塞于锁。当线程持有锁时进入RUNNABLE

4. 等待(WAITING)：进入该状态的线程需要等待其他线程做出一些特定动作（通知或中断）。不能自动唤醒，必须等待另一个线程调用notify或者notifuAll方法。

5. 超时等待(TIMED_WAITING)：该状态不同于WAITING，它可以在指定的时间后自行返回。可自动唤醒（wait，sleep方法就是）

6. 终止(TERMINATED)：表示该线程已经执行完毕。run正常退出而死亡或者抛异常

看Thread的源码可以看到这么一段话

示例图

就绪状态(RUNNABLE之READY)

就绪状态只是说你资格运行，调度程序没有挑选到你，你就永远是就绪状态。
调用线程的start()方法，此线程进入就绪状态。
当前线程sleep()方法结束，其他线程join()结束，等待用户输入完毕，某个线程拿到对象锁，这些线程也将进入就绪状态。
当前线程时间片用完了，调用当前线程的yield()方法，当前线程进入就绪状态。
锁池里的线程拿到对象锁后，进入就绪状态。

运行中状态(RUNNABLE之RUNNING)

线程调度程序从可运行池中选择一个线程作为当前线程时线程所处的状态。这也是线程进入运行状态的唯一的一种方式。

阻塞状态(BLOCKED)

阻塞状态是线程阻塞在进入synchronized关键字修饰的方法或代码块(获取锁)时的状态。

等待(WAITING)

处于这种状态的线程不会被分配CPU执行时间，它们要等待被显式地唤醒，否则会处于无限期等待的状态。

超时等待(TIMED_WAITING)

处于这种状态的线程不会被分配CPU执行时间，不过无须无限期等待被其他线程显示地唤醒，在达到一定时间后它们会自动唤醒。

终止状态(TERMINATED)

当线程的run()方法完成时，或者主线程的main()方法完成时，我们就认为它终止了。这个线程对象也许是活的，但是它已经不是一个单独执行的线程。线程一旦终止了，就不能复生。
在一个终止的线程上调用start()方法，会抛出java.lang.IllegalThreadStateException异常。

等待队列

调用obj的wait(), notify()方法前，必须获得obj锁，也就是必须写在synchronized(obj) 代码段内。
与等待队列相关的步骤和图：

1. 线程1获取对象A的锁，正在使用对象A。
2. 线程1调用对象A的wait()方法。
3. 线程1释放对象A的锁，并马上进入等待队列。
4. 锁池里面的对象争抢对象A的锁。
5. 线程5获得对象A的锁，进入synchronized块，使用对象A。
6. 线程5调用对象A的notifyAll()方法，唤醒所有线程，所有线程进入同步队列。若线程5调用对象A的notify()方法，则唤醒一个线程，不知道会唤醒谁，被唤醒的那个线程进入同步队列。
7. notifyAll()方法所在synchronized结束，线程5释放对象A的锁。
8. 同步队列的线程争抢对象锁，但线程1什么时候能抢到就不知道了。

同步队列状态

当前线程想调用对象A的同步方法时，发现对象A的锁被别的线程占有，此时当前线程进入同步队列。简言之，同步队列里面放的都是想争夺对象锁的线程。
当一个线程1被另外一个线程2唤醒时，1线程进入同步队列，去争夺对象锁。
同步队列是在同步的环境下才有的概念，一个对象对应一个同步队列。
线程等待时间到了或被notify/notifyAll唤醒后，会进入同步队列竞争锁，如果获得锁，进入RUNNABLE状态，否则进入BLOCKED状态等待获取锁。

几个方法的比较

Thread.sleep(long millis)，一定是当前线程调用此方法，当前线程进入TIMED_WAITING状态，但不释放对象锁，millis后线程自动苏醒进入就绪状态。作用：给其它线程执行机会的最佳方式。
Thread.yield()，一定是当前线程调用此方法，当前线程放弃获取的CPU时间片，但不释放锁资源，由运行状态变为就绪状态，让OS再次选择线程。作用：让相同优先级的线程轮流执行，但并不保证一定会轮流执行。实际中无法保证yield()达到让步目的，因为让步的线程还有可能被线程调度程序再次选中。Thread.yield()不会导致阻塞。该方法与sleep()类似，只是不能由用户指定暂停多长时间。
thread.join()/thread.join(long millis)，当前线程里调用其它线程t的join方法，当前线程进入WAITING/TIMED_WAITING状态，当前线程不会释放已经持有的对象锁。线程t执行完毕或者millis时间到，当前线程一般情况下进入RUNNABLE状态，也有可能进入BLOCKED状态（因为join是基于wait实现的）。
obj.wait()，当前线程调用对象的wait()方法，当前线程释放对象锁，进入等待队列。依靠notify()/notifyAll()唤醒或者wait(long timeout) timeout时间到自动唤醒。
obj.notify()唤醒在此对象监视器上等待的单个线程，选择是任意性的。notifyAll()唤醒在此对象监视器上等待的所有线程。
LockSupport.park()/LockSupport.parkNanos(long nanos),LockSupport.parkUntil(long deadlines), 当前线程进入WAITING/TIMED_WAITING状态。对比wait方法,不需要获得锁就可以让线程进入WAITING/TIMED_WAITING状态，需要通过LockSupport.unpark(Thread thread)唤醒。

##拓展
等待队列里许许多多的线程都wait()在一个对象上，此时某一线程调用了对象的notify()方法，那唤醒的到底是哪个线程？随机？队列FIFO？or sth else？Java文档就简单的写了句：选择是任意性的（The choice is arbitrary and occurs at the discretion of the implementation）。