多线程系列之 Java多线程的个人理解(一)

2019-01-03 09:56:34来源：博客园阅读 ()

前言：多线程常常是程序员面试时会被问到的问题之一，也会被面试官用来衡量应聘者的编程思维和能力的重要参考指标；无论是在工作中还是在应对面试时，多线程都是一个绕不过去的话题。本文重点围绕多线程，借助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 }