四种线程池

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

    }

}

我们看一下运行的效果

定时执行任务