认识Java里的线程

---

Java 程序天生就是多线程的

  一个 Java 程序从 main()方法开始执行，然后按照既定的代码逻辑执行，看似没有其他线程参与，但实际上 Java 程序天生就是多线程程序，因为执行 main()方法的是一个名称为 main 的线程。而一个 Java 程序的运行就算是没有用户自己开启的线程，实际也有有很多
JVM 自行启动的线程，一般来说有：

[6] Monitor Ctrl-Break //监控 Ctrl-Break 中断信号的
[5] Attach Listener //内存 dump，线程 dump，类信息统计，获取系统属性等
[4] Signal Dispatcher // 分发处理发送给 JVM 信号的线程
[3] Finalizer // 调用对象 finalize 方法的线程
[2] Reference Handler//清除 Reference 的线程
[1] main //main 线程，用户程序入口

尽管这些线程根据不同的 JDK 版本会有差异，但是依然证明了 Java 程序天生就是多线程的。

代码如下（示例）：

		//Java虚拟机线程系统的管理接口
		ThreadMXBean threadMXBean = ManagementFactory.getThreadMXBean();
		//不需要获取同步monitor和synchronizer信息，仅仅获取线程和线程堆栈信息
		ThreadInfo[] threadInfos = threadMXBean.dumpAllThreads(false, false);
		//遍历线程信息，打印线程ID和线程名称信息
		for(ThreadInfo threadInfo:threadInfos){
			System.out.println("["+threadInfo.getThreadId()+"]"+threadInfo.getThreadName());
		}

线程的启动和终止

启动

启动线程的方式有：
1、X extends Thread;，然后 X.start

2、X implements Runnable；然后交给 Thread 运行

如果需要获取线程的返回值，可以使用Callable，将Callable用FutureTask包装一下，用Future的get()方法获取返回值

代码如下（示例）：

	public static void main(String[] args) throws InterruptedException, ExecutionException {
        UseCallable useCallable = new UseCallable();
        //包装
        FutureTask<Integer> futureTask = new FutureTask<>(useCallable);
        new Thread(futureTask).start();
        //Thread.sleep(1);
        System.out.println("Get UseCallable result = "+futureTask.get());
    }

    private static class UseCallable implements Callable<Integer>{
        private int sum;
        @Override
        public Integer call() throws Exception {
            System.out.println("Callable子线程开始计算！");
            for(int i = 0;i<5000;i++){
                if(Thread.currentThread().isInterrupted()){
                    System.out.println("Callable子线程计算任务中断！");
                    return null;
                }
                sum = sum + i;
                System.out.println("sum = "+sum);
            }
            System.out.println("Callable子线程计算结束！结果为："+sum);
            return sum;
        }
    }

中止

线程自然终止

  要么是 run 执行完成了，要么是抛出了一个未处理的异常导致线程提前结束。

stop

  暂停、恢复和停止操作对应在线程 Thread 的 API 就是 suspend()、resume()和 stop()。但是这些 API 是过期的，也就是不建议使用的。不建议使用的原因主要有：以 suspend()方法为例，在调用后，线程不会释放已经占有的资源（比如锁），而是占有着资源进入睡眠状态，这样容易引发死锁问题。同样，stop()方法在终结一个线程时不会保证线程的资源正常释放，通常是没有给予线程完成资源释放工作的机会，因此会导致程序可能工作在不确定状态下。正因为 suspend()、resume()和 stop()方法带来的副作用，这些方法才被标注为不建议使用的过期方法。

中断

  安全的中止则是其他线程通过调用某个线程 A 的 interrupt()方法对其进行中断操作, 中断好比其他线程对该线程打了个招呼，“A，你要中断了”，不代表线程 A 会立即停止自己的工作，同样的 A 线程完全可以不理会这种中断请求。线程通过检查自身的中断标志位否被置为 true 来进行响应。
  线程通过方法 isInterrupted()来进行判断是否被中断，也可以调用静态方法Thread.interrupted()来进行判断当前线程是否被中断，不过 Thread.interrupted()会同时将中断标识位改写为 false。如果一个线程处于了阻塞状态（如线程调用了thread.sleep、thread.join、thread.wait 等），则在线程在检查中断标示时如果发现中断标示为 true，则会在这些阻塞方法调用处抛出 InterruptedException 异常，并且在抛出异常后会立即将线程的中断标示位清除，即重新设置为 false。
  不建议自定义一个取消标志位来中止线程的运行。因为 run 方法里有阻塞调用时会无法很快检测到取消标志，线程必须从阻塞调用返回后，才会检查这个取消标志。这种情况下，使用中断会更好，因为，
  一、一般的阻塞方法，如 sleep 等本身就支持中断的检查，
  二、检查中断位的状态和检查取消标志位没什么区别，用中断位的状态还可以避免声明取消标志位，减少资源的消耗。
注意：处于死锁状态的线程无法被中断

源代码如下：

Thread 和 Runnable 的区别

  Thread 才是 Java 里对线程的唯一抽象，Runnable 只是对任务（业务逻辑）的抽象。Thread 可以接受任意一个 Runnable 的实例并执行。

Callable、Future 和 FutureTask

  Runnable 是一个接口，在它里面只声明了一个 run()方法，由于 run()方法返回值为 void 类型，所以在执行完任务之后无法返回任何结果。
  Callable 位于 java.util.concurrent 包下，它也是一个接口，在它里面也只声明了一个方法，只不过这个方法叫做 call()，这是一个泛型接口，call()函数返回的类型就是传递进来的 V 类型。
  Future 就是对于具体的 Runnable 或者 Callable 任务的执行结果进行取消、查询是否完成、获取结果。必要时可以通过 get 方法获取执行结果，该方法会阻塞直到任务返回结果。



  FutureTask 类实现了 RunnableFuture 接口，RunnableFuture 继承了 Runnable接口和 Future 接口，而 FutureTask 实现了 RunnableFuture 接口。所以它既可以作为 Runnable 被线程执行，又可以作为 Future 得到 Callable 的返回值。

  因此我们通过一个线程运行 Callable，但是 Thread 不支持构造方法中传递Callable 的实例，所以我们需要通过 FutureTask 把一个 Callable 包装成 Runnable，然后再通过这个 FutureTask 拿到 Callable 运行后的返回值。

面试题：新启线程有几种方式？

按照 Java 源码中 Thread 上的注释：

  官方说法是在 Java 中有两种方式创建一个线程用以执行，一种是派生自Thread 类，另一种是实现 Runnable 接口。
  当然本质上 Java 中实现线程只有一种方式，都是通过 new Thread()创建线程对象，调用 start 启动线程。
  至于基于 Callable 接口的方式，因为最终是要把实现了 callable 接口的对象通过 FutureTask 包装成 Runnable，再交给 Thread 去执行，所以这个其实可以和实现 Runnable 接口看成同一类。
  而线程池的方式，本质上是池化技术，是资源的复用，和新启线程没什么关系

深入理解 run()和 start()

  Thread类是Java里对线程概念的抽象，可以这样理解：我们通过new Thread()其实只是 new 出一个 Thread 的实例，还没有操作系统中真正的线程挂起钩来。只有执行了 start()方法后，才实现了真正意义上的启动线程。
  从 Thread 的源码可以看到，Thread 的 start 方法中调用了 start0()方法，而start0()是个 native 方法，这就说明 start 一定和操作系统是密切相关的。
  start()方法让一个线程进入就绪队列等待分配 cpu，分到 cpu 后才调用实现的 run()方法，start()方法不能重复调用，如果重复调用会抛出异常（注意，此处可能有面试题：多次调用一个线程的 start 方法会怎么样？）。
  而 run 方法是业务逻辑实现的地方，本质上和任意一个类的任意一个成员方法并没有任何区别，可以重复执行，也可以被单独调用