前言：多线程常常是程序员面试时会被问到的问题之一，也会被面试官用来衡量应聘者的编程思维和能力的重要参考指标；无论是在工作中还是在应对面试时，多线程都是一个绕不过去的话题。本文重点围绕多线程，借助Java语言来展开讨论
文章结构
- 什么是多线程
- 为什么要使用多线程
- 如何实现多线程
- 在实际项目中遇到的多线程问题
1.什么是多线程
1.1 先来聊一聊什么是进程
如上图所示，以window操作系统为例，在win10操作系统进程管理，可以清楚的的看到在我们使用计算机的时候，后台是有很多像这样一个一个的进程在运行，这样一个一个的进程其实就是一个正在运行的程序；系统进行资源分配和调度的基本单位，竟争计算机系统资源的基本单位，是并发执行的程序在执行过程中分配和管理资源的基本单位。
1.2 什么是线程
如上图所示,可以看到操作系统上现在有185个进程，有2815个线程；线程是进程的一个实体,是CPU调度和分派的基本单位，它是比进程更小的能独立运行的基本单位。线程自己基本上不拥有系统资源，只拥有一点在运行中必不可少的资源；（程序计数器，一组寄存器和栈），但是它可与同属一个进程的其他的线程共享进程所拥有的全部资源。
1.3 什么是多线程
百度上是这么说的，多线程（英语：multithreading），是指从软件或者硬件上实现多个线程并发执行的技术。 个人理解，线程是要依赖于进程而存在的，毕竟他不能单独运行，所有在一个进程里面只有一个线程实例在执行就可以理解为单线程，有多个实例在执行则可以理解为多线程。
1.4 多线程与多进程的区别
- 多进程：操作系统能同时运行多个任务（程序)。
- 多线程：同一程序中有多个顺序流（线程)在执行。
2.为什么要使用多线程
换句话说，使用多线程到底有什么好处？
- 线程在程序中是独立的，并发的执行流，但是，与分隔的进程相比，进程中的线程之间的隔离程度要小。它们共享内存，文件句柄和其他每个进程应有的状态。
- 线程比进程具有更高的性能，这是由于同一个进程中的线程都有共性:多个线程将共享同一个进程虚拟空间。线程共享的环境包括：进程代码段，进程的公有数据等。利用这些共享的数据等,线程很容易实现相互之间的通信。
- 当操作系统创建一个进程时，必须为进程分配独立的内存空间，并分配大量相关资源：但创建一个线程则简单很多，因此使用多线程来实现并发比使用多进程实现并发的性能要高得多。
- 总结起来，使用多线程编程包含如下几个优点： （1）进程间不能共享内存，但线程之间可以共享内存非常容易。 （2）系统创建进程需要为该进程重新分配系统资源，但创建线程则代价小的多，因此使用多线程来实现多任务并发比多进程的效率高。 （3）Java语言内置多线程功能支持，而不是单纯地作为底层操作系统的调度方式，从而简化了Java的多线程编程。
3.如何实现多线程
首先要说一下，本文是基于Java语言来实现的多线程编程。在面向对象的编程思想指导下，实现多线程的方式有：
- 继承Thread类创建多线程
- 实现Runnable接口创建多线程
- 实现Callable接口通过FutureTask包装器来创建Thread线程
3.1继承Thread类实现多线程
JDK 为我们提供了一个线程类Thread 我们可以继承这个类并重写run()方法 ，如下：
1 package com.ultrapower.Mutilthread; 2 /** 3 * @Description: 继承Thread类实现多线程 4 * @author fangtao 5 */ 6 public class myThread extends Thread { 7 private int index=0; 8 9 @Override 10 public void run(){ 11 while(true){ 12 try { 13 Thread.sleep(1000); 14 System.out.println("进程号:"+this.currentThread().getId()+"执行-->"+(index++)); 15 } catch (InterruptedException e) { 16 e.printStackTrace(); 17 } 18 } 19 } 20 }
执行结果：
小节： 通过继承Thread 类并重写run()方法 就可以启动新线程并执行自己定义在run()里的逻辑 。
3.2 实现Runnable接口创建多线程
如果自己的类已经继承另一个类，由于Java语言的单继承特性，就无法直接继承Thread；此时，可以实现一个Runnable接口，如下：
1 package com.ultrapower.Mutilthread; 2 /** 3 * @Description: 实现Runable接口 4 * @author fangtao 5 * @date 2019-1-2 下午4:03:38 6 */ 7 public class myThread2 implements Runnable { 8 9 @Override 10 public void run(){ 11 while(true){ 12 try { 13 Thread.sleep(1000); 14 System.out.println(Thread.currentThread().getId()+" I'm running!"); 15 } catch (InterruptedException e) { 16 e.printStackTrace(); 17 } 18 } 19 } 20 }
执行结果:
1 public class TestmyThread { 2 3 public static void main(String[] args) { 4 Thread t1=new Thread(new myThread2()); 5 Thread t2=new Thread(new myThread2()); 6 Thread t3=new Thread(new myThread2()); 7 t1.start();t2.start();t3.start(); 8 } 9 10 }
执行结果：
事实上，当传入一个Runnable target参数给Thread后，Thread的run()方法就会调用target.run()，参考JDK源代码：
执行结果：
3.3 实现Callable接口通过FutureTask包装器来创建Thread线程
3.3.1 Callable
Callable位于java.util.concurrent包下，它也是一个接口，在它里面也只声明了一个方法，只不过跟Runnable接口不一样，这个方法比较叫做call()；
1 public interface Callable<V> { 2 /** 3 * Computes a result, or throws an exception if unable to do so. 4 * 5 * @return computed result 6 * @throws Exception if unable to compute a result 7 */ 8 V call() throws Exception; 9 }
可以看到，这是一个泛型接口，call()函数返回的类型就是传递进来的V类型。
那么怎么使用Callable呢？一般情况下是配合ExecutorService来使用的，在ExecutorService接口中声明了若干 个submit方法的重载版本：
1 <T> Future<T> submit(Callable<T> task);
2 <T> Future<T> submit(Runnable task, T result);
3 Future<?> submit(Runnable task);
第一个submit方法里面的参数类型就是Callable。
暂时只需要知道Callable一般是和ExecutorService配合来使用的，具体的使用方法讲在后面讲述。
一般情况下我们使用第一个submit方法和第三个submit方法，第二个submit方法很少使用。
3.3.2 Future
Future就是对于具体的Runnable或者Callable任务的执行结果进行取消、查询是否完成、获取结果。必要时 可以通过get方法获取执行结果，该方法会阻塞直到任务返回结果。
Future类位于java.util.concurrent包下，它是一个接口：
1 public interface Future<V> { 2 boolean cancel(boolean mayInterruptIfRunning); 3 boolean isCancelled(); 4 boolean isDone(); 5 V get() throws InterruptedException, ExecutionException; 6 V get(long timeout, TimeUnit unit) 7 throws InterruptedException, ExecutionException, TimeoutException; 8 }
在Future接口中声明了5个方法，下面依次解释每个方法的作用：
- cancel方法用来取消任务，如果取消任务成功则返回true，如果取消任务失败则返回false。参数mayInterruptIfRunning表示是否允许取消正在执行却没有执行完毕的任务，如果设置true，则表示可以取消正在执行过程中的任务。如果任务已经完成，则无论mayInterruptIfRunning为true还是false，此方法肯定返回false，即如果取消已经完成的任务会返回false；如果任务正在执行，若mayInterruptIfRunning设置为true，则返回true，若mayInterruptIfRunning设置为false，则返回false；如果任务还没有执行，则无论mayInterruptIfRunning为true还是false，肯定返回true。
- isCancelled方法表示任务是否被取消成功，如果在任务正常完成前被取消成功，则返回 true。
- isDone方法表示任务是否已经完成，若任务完成，则返回true；
- get()方法用来获取执行结果，这个方法会产生阻塞，会一直等到任务执行完毕才返回；
- get(long timeout, TimeUnit unit)用来获取执行结果，如果在指定时间内，还没获取到结果，就直接返回null。
也就是说Future提供了三种功能：
1）判断任务是否完成；
2）能够中断任务；
3）能够获取任务执行结果;
因为Future只是一个接口，所以是无法直接用来创建对象使用的，因此就有了下面的FutureTask。
3.3.3 FutureTask
我们先来看一下FutureTask的实现：
1 public class FutureTask<V> implements RunnableFuture<V>
FutureTask类实现了RunnableFuture接口，我们看一下RunnableFuture接口的实现：
1 public interface RunnableFuture<V> extends Runnable, Future<V> { 2 void run(); 3 }
可以看出RunnableFuture继承了Runnable接口和Future接口，而FutureTask实现了RunnableFuture接口。所以它既可以作为Runnable被线程执行，又可以作为Future得到Callable的返回值。
FutureTask提供了2个构造器：
1 public FutureTask(Callable<V> callable) { }
3 public FutureTask(Runnable runnable, V result) { }
事实上，FutureTask是Future接口的一个唯一实现类
代码示例：
1) 使用Callable+Future获取执行结果
1 public class Test { 2 public static void main(String[] args) { 3 ExecutorService executor = Executors.newCachedThreadPool(); 4 Task task = new Task(); 5 Future<Integer> result = executor.submit(task); 6 executor.shutdown(); 7 8 try { 9 Thread.sleep(1000); 10 } catch (InterruptedException e1) { 11 e1.printStackTrace(); 12 } 13 14 System.out.println("主线程在执行任务"); 15 16 try { 17 System.out.println("task运行结果"+result.get()); 18 } catch (InterruptedException e) { 19 e.printStackTrace(); 20 } catch (ExecutionException e) { 21 e.printStackTrace(); 22 } 23 24 System.out.println("所有任务执行完毕"); 25 } 26 } 27 class Task implements Callable<Integer>{ 28 @Override 29 public Integer call() throws Exception { 30 System.out.println("子线程在进行计算"); 31 Thread.sleep(3000); 32 int sum = 0; 33 for(int i=0;i<100;i++) 34 sum += i; 35 return sum; 36 } 37 }
执行结果：
2）使用Callable+FutureTask获取执行结果
1 public class Test { 2 public static void main(String[] args) { 3 //第一种方式 4 ExecutorService executor = Executors.newCachedThreadPool(); 5 Task task = new Task(); 6 FutureTask<Integer> futureTask = new FutureTask<Integer>(task); 7 executor.submit(futureTask); 8 executor.shutdown(); 9 10 //第二种方式，使用的是ExecutorService，一个使用的是Thread 11 12 13 try { 14 Thread.sleep(1000); 15 } catch (InterruptedException e1) { 16 e1.printStackTrace(); 17 } 18 19 System.out.println("主线程在执行任务"); 20 21 try { 22 System.out.println("task运行结果"+futureTask.get()); 23 } catch (InterruptedException e) { 24 e.printStackTrace(); 25 } catch (ExecutionException e) { 26 e.printStackTrace(); 27 } 28 29 System.out.println("所有任务执行完毕"); 30 } 31 } 32 class Task implements Callable<Integer>{ 33 @Override 34 public Integer call() throws Exception { 35 System.out.println("子线程在进行计算"); 36 Thread.sleep(3000); 37 int sum = 0; 38 for(int i=0;i<100;i++) 39 sum += i; 40 return sum; 41 } 42 }
如果为了可取消性而使用 Future 但又不提供可用的结果，则可以声明 Future<?> 形式类型、并返回 null 作为底层任务的结果。
(项目中多线程的分享下次再写吧。。。。)