Executor线程池的几种用法

最新推荐文章于 2024-08-07 08:00:00 发布

置顶 DroidMind

最新推荐文章于 2024-08-07 08:00:00 发布

阅读量3.1k

点赞数

分类专栏： Android开发文章标签：线程池

本文链接：https://blog.csdn.net/hp910315/article/details/49077257

版权

Android开发专栏收录该内容

175 篇文章 13 订阅

订阅专栏

下面将介绍线程池的几种用法
一、Executor执行Runnable任务

import java.util.concurrent.ExecutorService;   
import java.util.concurrent.Executors;   

public class TestCachedThreadPool{   
    public static void main(String[] args){     
        // 1、创建一个单线程池 
        ExecutorService executorService = Executors.newSingleThreadExecutor();  

        //2、往线程池中添加任务
        for (int i = 0; i < 5; i++){   
            executorService.execute(new TestRunnable());   
            System.out.println("************* a" + i + " *************");   
        }
        // 3、关闭线程池   
        executorService.shutdown();   
    }   
}   

class TestRunnable implements Runnable{   
    public void run(){   
        System.out.println(Thread.currentThread().getName() + "线程被调用了。");   
    }   
}

下面简单总结一下它的用法：
1、创建线程池
Executors提供了一系列工厂方法用于创先线程池，返回的线程池都实现了ExecutorService接口。

public static ExecutorService newFixedThreadPool(int nThreads)

创建固定数目线程的线程池。

public static ExecutorService newCachedThreadPool()

创建一个可缓存的线程池，调用execute将重用以前构造的线程（如果线程可用）。如果现有线程没有可用的，则创建一个新线程并添加到池中。终止并从缓存中移除那些已有 60 秒钟未被使用的线程。

public static ExecutorService newSingleThreadExecutor()

创建一个单线程化的Executor。

public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize)

创建一个支持定时及周期性的任务执行的线程池，多数情况下可用来替代Timer类。

2、添加Runnable任务

使用executorService的execute函数将任务添加到线程，线程就会自动的执行Runnable的run方法。

3、关闭线程池
ExecutorService的生命周期包括三种状态：运行、关闭、终止。创建后便进入运行状态，当调用了shutdown（）方法时，便进入关闭状态，此时意味着ExecutorService不再接受新的任务，但它还在执行已经提交了的任务，当所有已经提交了的任务执行完后，便到达终止状态。如果不调用shutdown（）方法，ExecutorService会一直处在运行状态，不断接收新的任务，执行新的任务，服务器端一般不需要关闭它，保持一直运行即可。

二、Executor执行Callable任务

Callable任务与Runnable任务不同的就是Callable任务有返回值，任务执行完成之后，它可以得到任务的返回值。返回Future对象，我们可以根据这个对象的isDone函数来判断是否这个对象已经得到了返回值，如果为ture，就表示已经得到了返回值，这样我使用Future的get方法就可以得到任务的返回值。

import java.util.ArrayList;   
import java.util.List;   
import java.util.concurrent.*;   

public class CallableDemo{   
    public static void main(String[] args){
        // 1、创建一个线程池 
        ExecutorService executorService = Executors.newCachedThreadPool();  
        // 创建一个List来存放任务的返回future 
        List<Future<String>> resultList = new ArrayList<Future<String>>();   

        //创建10个任务并执行   
        for (int i = 0; i < 10; i++){   
            //2、向线程中添加Callable任务，Callable任务的返回值存放在future中
            Future<String> future = executorService.submit(new TaskWithResult(i));   
            //将任务执行结果存储到List中   
            resultList.add(future);   
        }   

        //遍历任务的结果   
        for (Future<String> fs : resultList){   
                try{   
                    //Future返回如果没有完成，则一直循环等待，直到Future返回完成
                    while(!fs.isDone); 
                    //打印各个任务返回的结果   
                    System.out.println(fs.get());     
                }catch(InterruptedException e){   
                    e.printStackTrace();   
                }catch(ExecutionException e){   
                    e.printStackTrace();   
                }finally{   
                    //3、关闭线程池  
                    executorService.shutdown();   
                }   
        }   
    }   
}


class TaskWithResult implements Callable<String>{   
    private int id;   

    public TaskWithResult(int id){   
        this.id = id;   
    }   

    /**  
     * 任务的具体过程，一旦任务传给ExecutorService的submit方法， 
     * 则该方法自动在一个线程上执行 
     */   
    public String call() throws Exception {  
        System.out.println("call()方法被自动调用！！！    " + Thread.currentThread().getName());   
        //该返回结果将被Future的get方法得到  
        return "call()方法被自动调用，任务返回的结果是：" + id + "    " + Thread.currentThread().getName();   
    }   
}

下面简单总结一下它的用法：
1、创建线程池
这个跟上面一样

2、添加Callable任务到线程中

这个跟上面的不同就是它可以得到一个返回值future，我们可以通过future里面的isDone函数来判断是否结果以及被返回，如果Callable任务的结果还没有被返回，isDone函数的结果为false，否则为true，这样就可以通过future的get方法得到返回值，其实我们也可以不用判断，直接调用get函数，如果任务没有返回结果，他会被阻塞，直到结果返回。使用executorService的submit函数将任务添加到线程，线程会自动调用它的call方法。

3、关闭线程池
这个跟上面也一样

三、Executor执行FutureTask任务

FutureTask有一个cancel方法，我们可以调用这个方法来取消任务，如果任务被取消，那么任务就不会被运行。另外它也具备第二种方法的优点，它可以得到返回结果，不过不是通过返回值的形式。

package com.concretepage;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.FutureTask;
public class FutureTaskDemo {
    public static void main(String... args) throws InterruptedException, ExecutionException{
        // 1、创建一个线程池
        ExecutorService exService = Executors.newSingleThreadExecutor();
        // 2、创建一个FutureTask任务
        FutureTask<String> futureTask= new FutureTask<String>(new DemoTask());
        // 3、将任务放入线程池
        exService.execute(futureTask);
        //检测任务是否执行完成
        System.out.println(futureTask.isDone());
        //检测任务是否被取消
        System.out.println(futureTask.isCancelled());
        //获取返回结果
        System.out.println(futureTask.get());
    }
}
class DemoTask implements Callable<String>{
    public String call() {
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            System.out.println(e);
        }
        return "Task Done";
    }
}

四、自定义线程池
用ThreadPoolExecutor类创建线程池，我们直接来看代码。

import java.util.concurrent.ArrayBlockingQueue;   
import java.util.concurrent.BlockingQueue;   
import java.util.concurrent.ThreadPoolExecutor;   
import java.util.concurrent.TimeUnit;   

public class ThreadPoolTest{   
    public static void main(String[] args){   
        //1、创建等待队列   
        BlockingQueue<Runnable> bqueue = new ArrayBlockingQueue<Runnable>(20);   
        //2、创建线程池，池中保存的线程数为3，允许的最大线程数为5  
        ThreadPoolExecutor pool = new ThreadPoolExecutor(3,5,50,TimeUnit.MILLISECONDS,bqueue);   

        Runnable t1 = new MyThread();   
        Runnable t2 = new MyThread();   
        Runnable t3 = new MyThread();   
        Runnable t4 = new MyThread();   
        Runnable t5 = new MyThread();   
        Runnable t6 = new MyThread();   
        Runnable t7 = new MyThread();   
        //3、向线程池添加任务  
        pool.execute(t1);   
        pool.execute(t2);   
        pool.execute(t3);   
        pool.execute(t4);   
        pool.execute(t5);   
        pool.execute(t6);   
        pool.execute(t7);   
        //4、关闭线程池   
        pool.shutdown();   
    }   
}   

class MyThread implements Runnable{   
    @Override   
    public void run(){   
        System.out.println(Thread.currentThread().getName() + "正在执行。。。");   
        try{   
            Thread.sleep(100);   
        }catch(InterruptedException e){   
            e.printStackTrace();   
        }   
    }   
}