线程池/安全停止线程

多线程编程中最最基础的条件要保证数据的完整性.

> 致可能丢失的博客：

话题一 Android进程保活；

Android 进程常驻、进程守护、进程保活技术的总结- http://blog.csdn.net/wangbaochu/article/details/50943335
关于 Android 进程保活，你所需要知道的一切- http://www.jianshu.com/p/63aafe3c12af#

话题二 Android Java线程池；

话题三 Android黑科技；

Android 上 App 无限自启的黑科技究竟是怎么做到的？- https://www.zhihu.com/question/27634878

话题四 Android Java多线程

> 线程池

 在什么情况下使用线程池？
1.单个任务处理的时间比较短
2.将需处理的任务的数量大
 使用线程池的好处:
1.减少在创建和销毁线程上所花的时间以及系统资源的开销
2.如不使用线程池，有可能造成系统创建大量线程而导致消耗完系统内存以及”过度切换”。

JDK 自带线程池总类介绍介绍：
1、newFixedThreadPool 创建一个指定工作线程数量的线程池。每当提交一个任务就创建一个工作线程，如果工作线程数量达到线程池初始的最大数，则将提交的任务存入到池队列中。
2、newCachedThreadPool 创建一个可缓存的线程池。这种类型的线程池特点是：
  1).工作线程的创建数量几乎没有限制(其实也有限制的,数目为Interger. MAX_VALUE), 这样可灵活的往线程池中添加线程。
  2).如果长时间没有往线程池中提交任务，即如果工作线程空闲了指定的时间(默认为1 分钟)，则该工作线程将自动终止。终止后，如果你又提交了新的任务，则线程池重新创建一个工作线程。
3、newSingleThreadExecutor 创建一个单线程化的Executor，即只创建唯一的工作者线程来执行任务，如果这个线程异常结束，会有另一个取代它，保证顺序执行(我觉得这点是它的特色)。单工作线程最大的特点是可保证顺序地执行各个任务，并且在任意给定的时间不会有多个线程是活动的。
4、newScheduleThreadPool 创建一个定长的线程池，而且支持定时的以及周期性的任务执行，类似于Timer。(这种线程池原理暂还没完全了解透彻)

Android 多线程 线程池原理 封装线程池- http://blog.csdn.net/smartbetter/article/details/52056272
Java通过Executors提供四种线程池- http://blog.csdn.net/mack415858775/article/details/51508831
线程池封装类—借鉴ImageLoader的线程工厂- http://blog.csdn.net/brian512/article/details/50684532
java线程池学习（二）实现一个简单的线程池- http://blog.csdn.net/great_smile/article/details/48878733
java线程池demo- http://download.csdn.net/detail/u010395804/8354097
java ThreadPoolExecutor 自定义线程池demo- http://blog.csdn.net/woshimike/article/details/53906382
线程池Demo写的很好，易理解- http://download.csdn.net/download/luoxiong94/9631946
Android开发之线程池使用总结- http://blog.csdn.net/u012702547/article/details/52259529

> 停止线程thread
如何终止java线程- http://blog.csdn.net/anhuidelinger/article/details/11746365
* 在Java5的java.util.concurrent中得到了回答：使用interrupt()，让线程在run方法中停止，但还得设置个标志。不要去使用stop(),产生了不完整的残废数据。
1. 使用violate boolean变量来标识线程是否停止
2. 停止线程时，需要调用停止线程的interrupt()方法，因为线程有可能在wait()或sleep(), 提高停止线程的即时性
3. 对于blocking IO的处理，尽量使用InterruptibleChannel来代替blocking IO

 > 安全的关闭线程池或线程
Java关闭线程的安全方法- http://www.cnblogs.com/simbachen/p/4009562.html
线程池动态并安全地中断所有线程- http://blog.csdn.net/a1053904672/article/details/72170289
java多线程]如何安全的退出线程- http://blog.csdn.net/Zzrdark_/article/details/78291073

-----------------------------

> 线程池的使用
1.shutDown()  关闭线程池，不影响已经提交的任务
2.shutDownNow() 关闭线程池，并尝试去终止正在执行的线程
3.allowCoreThreadTimeOut(boolean value) 允许核心线程闲置超时时被回收
4.submit 一般情况下我们使用execute来提交任务，但是有时候可能也会用到submit，使用submit的好处是submit有返回值

a.自定义线程池
public void customThreadPool(View view) {  
    final MyThreadPool myThreadPool = new MyThreadPool(3, 5, 1, TimeUnit.MINUTES, new LinkedBlockingDeque<Runnable>());  
    for (int i = 0; i < 10; i++) {  
        final int finalI = i;  
        Runnable runnable = new Runnable(){  
            @Override  
            public void run() {  
                SystemClock.sleep(100);  
                Log.d("google_lenve_fb", "run: " + finalI);  
            }  
        };  
        myThreadPool.execute(runnable);  
    }  
}  
class MyThreadPool extends ThreadPoolExecutor{  
  
    public MyThreadPool(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue) {  
        super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue);  
    }  
  
    @Override  
    protected void beforeExecute(Thread t, Runnable r) {  
        super.beforeExecute(t, r);  
        Log.d("google_lenve_fb", "beforeExecute: 开始执行任务！");  
    }  
  
    @Override  
    protected void afterExecute(Runnable r, Throwable t) {  
        super.afterExecute(r, t);  
        Log.d("google_lenve_fb", "beforeExecute: 任务执行结束！");  
    }  
  
    @Override  
    protected void terminated() {  
        super.terminated();  
        //当调用shutDown()或者shutDownNow()时会触发该方法  
        Log.d("google_lenve_fb", "terminated: 线程池关闭！");  
    }  
}  

b.submit提交线程池后，取回执行结果future.get()
public void submit(View view) {  
    List<Future<String>> futures = new ArrayList<>();  
    ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(3, 5, 1,  
            TimeUnit.SECONDS, new LinkedBlockingDeque<Runnable>());  
    for (int i = 0; i < 10; i++) {  
        Future<String> taskFuture = threadPoolExecutor.submit(new MyTask(i));  
        //将每一个任务的执行结果保存起来  
        futures.add(taskFuture);  
    }  
    try {  
        //遍历所有任务的执行结果  
        for (Future<String> future : futures) {  
            Log.d("google_lenve_fb", "submit: " + future.get());  
   //future.get()
        }  
    } catch (InterruptedException e) {  
        e.printStackTrace();  
    } catch (ExecutionException e) {  
        e.printStackTrace();  
    }  
}  
class MyTask implements Callable<String> {  
  
    private int taskId;  
  
    public MyTask(int taskId) {  
        this.taskId = taskId;  
    }  
  
    @Override  
    public String call() throws Exception {  
        SystemClock.sleep(1000);  
        //返回每一个任务的执行结果  
        return "call()方法被调用----" + Thread.currentThread().getName() + "-------" + taskId;  
    }  
}