这是我参与更文挑战的第 9 天，活动详情查看

前言：

线程是程序中的执行线程。Java 虚拟机允许应用程序并发地运行多个执行线程。

每个线程都有一个优先级，高优先级线程的执行优先于低优先级线程。每个线程都可以或不可以标记为一个守护程序。当某个线程中运行的代码创建一个新 Thread 对象时，该新线程的初始优先级被设定为创建线程的优先级，并且当且仅当创建线程是守护线程时，新线程才是守护程序。

当 Java 虚拟机启动时，通常都会有单个非守护线程（它通常会调用某个指定类的 main 方法）。Java 虚拟机会继续执行线程，直到下列任一情况出现时为止：

调用了 Runtime 类的 exit 方法，并且安全管理器允许退出操作发生。非守护线程的所有线程都已停止运行，无论是通过从对 run 方法的调用中返回，还是通过抛出一个传播到 run 方法之外的异常。

一.线程创建的几种方式

继承Thread类,重写run方法
实现Runnable接口
使用Callable和Future
使用线程池例如用Executor框架

1.继承Thread类进行创建

定义Thread类的子类，并重写该类的run()方法
创建Thread子类的实例，也就是创建了线程对象
启动线程，即调用线程的start()方法

public class ThreadTest extends Thread {
    @Override
    public void run() {
        System.out.println("继承Thread类，重写run方法创建线程;"+ Thread.currentThread().getName());
    }
}
class Main{
    public static void main(String[] args) {
        ThreadTest threadTest = new ThreadTest();
        threadTest.start();
    }
}

2.实现Runnabel

定义Runnable接口的实现类，一样要重写run()方法，这个run（）方法和Thread中的run()方法一样是线程的执行体
创建Runnable实现类的实例，并用这个实例作为Thread的target来创建Thread对象，这个Thread对象才是真正的线程对象
第三部依然是通过调用线程对象的start()方法来启动线程

class ThreadRunnable implements Runnable{
    @Override
    public void run() {
        System.out.println("实现Runnable接口，重写run方法创建线程;"+ Thread.currentThread().getName());
    }
}
class Main{
    public static void main(String[] args) {
        ThreadRunnable runnable = new ThreadRunnable();
        Thread thread = new Thread(runnable);
        thread.start();
    }
}

3.使用Callable和Future创建线程

创建Callable接口的实现类，并实现call()方法，该call()方法将作为线程执行体，且该call()方法没有返回值，再创建Callable实现类的实例。（从java8开始，可以直接使用Lambda表达式创建Callable对象）
使用FutureTask类来包装Callable对象，该FutureTask对象封装了该Callable对象的call()方法的返回值。
使用FutureTask作为Thread对象的target创建并启动新线程。
调用FutureTask对象的get方法来获得子线程执行结束后的返回值。

class ThreadCallable implements Callable<String>{
    @Override
    public String call() throws Exception {
        System.out.println("实现Callable接口，重写call方法创建线程;线程名："+ Thread.currentThread().getName());
        return "有返回的线程Call";
    }
}
class Main{
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //FutureTask futureTask = new FutureTask((Callable) new ThreadRunnable());
        //java8 Lambda表达式
        FutureTask<String> futureTask = new FutureTask<String>(new ThreadCallable());
        Thread thread = new Thread(futureTask);
        thread.start();
        System.out.println(futureTask.get());

        //Lambda
        FutureTask<Integer> task = new FutureTask<Integer>((Callable<Integer>)()->{
            int i = 0;
            for (;i<10;i++){
                System.out.println(Thread.currentThread().getName()+"===="+i);
            }
            return i;
        });
        new Thread(task).start();
        System.out.println(task.get());

    }
}

4.使用线程池例如用Executor框架(主要由三大部分组成)

1.任务
执行任务需要实现的Runnable接口或Callable接口。Runnable接口或Callable接口实现类都可以被ThreadPoolExecutor或ScheduledThreadPoolExecutor执行。（Runnable接口不会返回结果但是Callable接口可以返回结果。后面介绍Executors类的一些方法的时候会介绍到两者的相互转换）
2.执行任务
如下图所示，包括任务执行机制的核心接口Executor ，以及继承自Executor 接口的ExecutorService接口。ScheduledThreadPoolExecutor和ThreadPoolExecutor这两个关键类实现了ExecutorService接口。

3.获得结果
Future接口以及Future接口的实现类FutureTask类。当我们把Runnable接口或Callable接口的实现类提交（调用submit方法）给ThreadPoolExecutor或ScheduledThreadPoolExecutor时，会返回一个FutureTask对象。

Executor 框架的使用示意图

1.主线程首先要创建实现Runnable或者Callable接口的任务对象。
2.然后可以把创建完成的Runnable对象直接交给ExecutorService执行
3.如果执行ExecutorService.submit（…），ExecutorService将返回一个实现Future接口的对象
4.最后，主线程可以执行FutureTask.get()方法来等待任务执行完成。主线程也可以执行FutureTask.cancel（boolean mayInterruptIfRunning）来取消此任务的执行。

二、Thread（线程)的五种状态

创建，就绪，运行，挂起（包括阻塞，睡眠，等待），结束

新建状态（New）：新创建了一个线程对象。

    // 刚创建上但是不调用start()方法
      Thread t1 = new Thread(() -> {
          System.out.println("t1");
      }, "t1");

就绪状态（Runnable）：线程对象创建后，其他线程调用了该对象的start()方法。该状态的线程位于可运行线程池中，变得可运行，等待获取CPU的使用权。

       //  等待获取CPU的使用权
        Thread t2 = new Thread(() -> {
            System.out.println("t2 run");
        }, "t2");
        t2.start();

运行状态（Running）：就绪状态的线程获取了CPU，执行程序代码。

       //  一直处于在运行的状态
        Thread t2 = new Thread(() -> {
            while (true) {
 		 System.out.println("t2 run");
            }
        }, "t2");
        t2.start();

阻塞状态（Blocked）：阻塞状态是线程因为某种原因放弃CPU使用权，暂时停止运行。直到线程进入就绪状态，才有机会转到运行状态。阻塞的情况分三种：

 （一）、等待阻塞：运行的线程执行wait()方法，JVM会把该线程放入等待池中。
 （二）、同步阻塞：运行的线程在获取对象的同步锁时，若该同步锁被别的线程占用，则JVM会把该线程放入锁池中。
 （三）、其他阻塞：运行的线程执行sleep()或join()方法，或者发出了I/O请求时，JVM会把该线程置为阻塞状态。
 当sleep()状态超时、join()等待线程终止或者超时、或者I/O处理完毕时，线程重新转入就绪状态。

 // TIMED_WAITING    TimeUnit.SECONDS.sleep()就是timed_waiting
    Thread t3 = new Thread(() -> {
        synchronized (ThreadStateDemo.class) {
            try {
                    // TimeUnit底层也是调用Thread.sleep()方法对
                TimeUnit.SECONDS.sleep(5000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }, "t3");
    t3.start();
    
    //WAIT join()就是wait
    Thread t4 = new Thread(() -> {
        try {
            t2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }, "t4");
    t4.start();

//由于上面的t3线程已经对ThreadStateDemo.class上锁  t5线程就拿不到这个对象就会陷入Blocked的阻塞状态
    Thread t5 = new Thread(() -> {
        synchronized (ThreadStateDemo.class) {
            log.info("BLOCKED...");
        }
    }, "t5");
    t5.start();
    
//线程已完成执行。
    Thread t6 = new Thread(() -> {
        log.info("就一行代码");
    }, "t6");
    t6.start();

结束状态（Dead）：线程执行完了或者因异常退出了run()方法，该线程结束生命周期。

三、Thread的方法

1.sleep

睡眠几秒钟，让出CPU让别人执行。

2.yield

短暂的让一下CPU，谁能抢到就执行，抢不到还是原来的执行。

3.join

有ab两个线程。a线程在某一时刻调用了join(b线程)，此时a线程sleep，直到b线程执行结束，a继续执行。注意自己join自己是不行的。

4.getState

得到线程的状态、一共六种：

Thread 线程的创建方式及状态剖析

前言：