四种线程池

第一种：单线程的线程池 这个线程池只有一个线程在工作，也就是相当于单线程串行执行所有任务。如果这个唯一的线程因为异常结束，那么会有一个新的线程来替代它。此线程池保证所有任务的执行顺序按照任务的提交顺序执行。
下面我们通过一个小例子来实现 首先在java工程中创建一个类

public class MyThread extends Thread {    @Override    public void run() {        System.out.println(Thread.currentThread().getName() + "正在执行。。。");    }}

主方法中开启五个线程 添加到线程池

import com.lcjl.fragment.LoginFragment;import com.lcjl.utils.FragmentUtils;import android.os.Bundle;import android.support.v4.app.FragmentActivity;import android.support.v4.app.FragmentTransaction;public class MyTextActivity extends FragmentActivity {    private LoginFragment loginFragment;    @Override    protected void onCreate(Bundle savedInstanceState) {        super.onCreate(savedInstanceState);        setContentView(R.layout.main);        FragmentTransaction transaction = FragmentUtils.getInstance().MyFragmentUtils(this);        loginFragment = new LoginFragment();        transaction.add(R.id.rel, loginFragment).commit();    }}

下面看一下我们的运行效果

从效果图我们可以看到只有一个线程在运行

第二种：创建固定大小的线程池 每次提交一个任务就创建一个线程，直到线程达到线程池的最大大小。线程池的大小一旦达到最大值就会保持不变，如果某个线程因为执行异常而结束，那么线程池会补充一个新线程。
和上面一样我们写一个小demo
首先是一个线程

public class MyThread extends Thread {    @Override    public void run() {        System.out.println(Thread.currentThread().getName() + "正在执行。。。");    }}

主方法中的实现代码

import java.util.concurrent.ExecutorService;import java.util.concurrent.Executors;public class MainThread {    public static void main(String[] args) {         //创建一个可重用固定线程数的线程池  单线程的线程池        ExecutorService pool = Executors. newFixedThreadPool(2);        //创建myThread的实例        Thread t1 = new MyThread();        Thread t2 = new MyThread();        Thread t3 = new MyThread();        Thread t4 = new MyThread();        Thread t5 = new MyThread();        //将线程放入池中进行执行        pool.execute(t1);        pool.execute(t2);        pool.execute(t3);        pool.execute(t4);        pool.execute(t5);        //关闭线程池        pool.shutdown();    }}

我们看一下我们允许的是两个线程运行 我们看一下运行的效果

第三种：创建一个可以缓存的线程池 如果线程池的大小超过了处理任务所需要的线程，

那么就会回收部分空闲（60秒不执行任务）的线程，当任务数增加时，此线程池又可以智能的添加新线程来处理任务。此线程池不会对线程池大小做限制，线程池大小完全依赖于操作系统（或者说JVM）能够创建的最大线程大小。
和上面一样 话不多说 看一下我们的实现代码

线程类中的实现代码

public class MyThread extends Thread {    @Override    public void run() {        System.out.println(Thread.currentThread().getName() + "正在执行。。。");    }}

主方法中的实现代码

import java.util.concurrent.ExecutorService;import java.util.concurrent.Executors;public class MainThread {    public static void main(String[] args) {         //创建一个可重用固定线程数的线程池  单线程的线程池//        ExecutorService pool = Executors. newSingleThreadExecutor();        ExecutorService pool = Executors. newCachedThreadPool();        //创建myThread的实例        for (int i = 0; i < 100; i++) {            Thread iThread = new MyThread();            pool.execute(iThread);        }        //关闭线程池        pool.shutdown();    }}

下面看一下我们的运行效果哦

代码中我们开启了100个线程但是我们的运行效果中最大也就是到达了30个线程 这个就是可缓存的线程 这个线程在实际中是最实用的

下面介绍我们的最后一种线程池
第四种：大小无限的线程池 此线程池支持定时以及周期性执行任务的需求。

下面看一个例子 主方法中的实现代码

import java.util.concurrent.ScheduledThreadPoolExecutor;import java.util.concurrent.TimeUnit;public class MainThread {    public static void main(String[] args) {         ScheduledThreadPoolExecutor exec = new ScheduledThreadPoolExecutor(1);            exec.scheduleAtFixedRate(new Runnable() {//每隔一段时间就触发异常                          @Override                          public void run() {                               //throw new RuntimeException();                               System.out.println("================");                          }                      }, 1000, 5000, TimeUnit.MILLISECONDS);            exec.scheduleAtFixedRate(new Runnable() {//每隔一段时间打印系统时间，证明两者是互不影响的                          @Override                          public void run() {                               System.out.println(System.nanoTime());                          }                      }, 1000, 2000, TimeUnit.MILLISECONDS);    }}

我们看一下运行的效果

定时执行任务