标签：top 计数器 reading shutdown 多进程 panel focus relative logs
前言：多线程常常是程序员面试时会被问到的问题之一，也会被面试官用来衡量应聘者的编程思维和能力的重要参考指标；无论是在工作中还是在应对面试时，多线程都是一个绕不过去的话题。本文重点围绕多线程，借助Java语言来展开讨论
如上图所示，以window操作系统为例，在win10操作系统进程管理，可以清楚的的看到在我们使用计算机的时候，后台是有很多像这样一个一个的进程在运行，这样一个一个的进程其实就是一个正在运行的程序；系统进行资源分配和调度的基本单位，竟争计算机系统资源的基本单位，是并发执行的程序在执行过程中分配和管理资源的基本单位。
如上图所示,可以看到操作系统上现在有185个进程，有2815个线程；线程是进程的一个实体,是CPU调度和分派的基本单位，它是比进程更小的能独立运行的基本单位。线程自己基本上不拥有系统资源，只拥有一点在运行中必不可少的资源；（程序计数器，一组寄存器和栈），但是它可与同属一个进程的其他的线程共享进程所拥有的全部资源。
百度上是这么说的，多线程（英语：multithreading），是指从软件或者硬件上实现多个线程并发执行的技术。 个人理解，线程是要依赖于进程而存在的，毕竟他不能单独运行，所有在一个进程里面只有一个线程实例在执行就可以理解为单线程，有多个实例在执行则可以理解为多线程。
换句话说，使用多线程到底有什么好处？
首先要说一下，本文是基于Java语言来实现的多线程编程。在面向对象的编程思想指导下，实现多线程的方式有：
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()里的逻辑 。
如果自己的类已经继承另一个类，由于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源代码：
执行结果：
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方法很少使用。
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个方法，下面依次解释每个方法的作用：
也就是说Future提供了三种功能：
1）判断任务是否完成；
2）能够中断任务；
3）能够获取任务执行结果;
因为Future只是一个接口，所以是无法直接用来创建对象使用的，因此就有了下面的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 作为底层任务的结果。
(项目中多线程的分享下次再写吧。。。。)
部分参自：http://www.cnblogs.com/dolphin0520/
标签：top 计数器 reading shutdown 多进程 panel focus relative logs
原文地址：https://www.cnblogs.com/ft-greate/p/10209607.html
