Android线程和线程池(3)——线程池的使用

其他 2021-03-27 22:01:57 阅读次数: 0

目录

1.线程池的介绍

线程池是指在初始化一个多线程应用程序过程中创建一个线程集合，然后在需要执行新的任务时重用这些线程而不是新建一个线程（提高线程复用，减少性能开销）。线程池中线程的数量通常完全取决于可用内存数量和应用程序的需求。然而，增加可用线程数量是可能的。线程池中的每个线程都有被分配一个任务，一旦任务已经完成了，线程回到池子中然后等待下一次分配任务。

1.1 使用线程池的原因

在android开发中经常会使用多线程异步来处理相关任务，而如果用传统的newThread来创建一个子线程进行处理，会造成一些严重的问题：

  1. 每次new Thread新建对象性能差。
  2. 线程缺乏统一管理，可能无限制新建线程，相互之间竞争，及可能占用过多系统资源导致死机或oom。
  3. 缺乏更多功能，如定时执行、定期执行、线程中断。

总而言之：频繁地为每一个任务创建一个线程，缺乏统一管理，降低性能，并且容易出现问题。
 

1.2 使用线程池的好处

  1. 重用存在的线程，减少对象创建、消亡的开销，性能佳。
  2. 可有效控制最大并发线程数，提高系统资源的使用率，同时避免过多资源竞争，避免堵塞。
  3. 提供定时执行、定期执行、单线程、并发数控制等功能。

我们很多时候都需要用到多线程，但是线程的创建和摧毁时很消耗资源和性能的，如果你每需要一个任务就创建一个线程这样很没必要。而且这样创建线程也缺乏统一管理。所以我们可以让线程去执行任务，在执行完成后不摧毁他，接着继续去执行下一个任务，这样就可以避免这种情况了。Java就为我们引入了线程池。
 

2.线程池的使用说明

ThreadPoolExecutor是线程池的真正实现。

2.1 构造方法

ThreadPoolExecutor提供了4个有参构造方法：

public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue) {
    
    
        this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
             Executors.defaultThreadFactory(), defaultHandler);
    }

    
    public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              ThreadFactory threadFactory) {
    
    
        this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
             threadFactory, defaultHandler);
    }

   
    public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              RejectedExecutionHandler handler) {
    
    
        this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
             Executors.defaultThreadFactory(), handler);
    }

    
    public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              ThreadFactory threadFactory,
                              RejectedExecutionHandler handler) {
    
    
        if (corePoolSize < 0 ||
            maximumPoolSize <= 0 ||
            maximumPoolSize < corePoolSize ||
            keepAliveTime < 0)
            throw new IllegalArgumentException();
        if (workQueue == null || threadFactory == null || handler == null)
            throw new NullPointerException();
        this.corePoolSize = corePoolSize;
        this.maximumPoolSize = maximumPoolSize;
        this.workQueue = workQueue;
        this.keepAliveTime = unit.toNanos(keepAliveTime);
        this.threadFactory = threadFactory;
        this.handler = handler;
    }

2.2 参数解释

参数 解释
corePoolSize（必需） 核心线程数。即池中一直保持存活的线程数，即使这些线程处于空闲。但是将allowCoreThreadTimeOut参数设置为true后，核心线程处于空闲一段时间以上，也会被回收。
maximumPoolSize（必需） 池中允许的最大线程数。当核心线程全部繁忙且任务队列打满之后，线程池会临时追加线程，直到总线程数达到maximumPoolSize这个上限。
keepAliveTime（必需） 线程空闲超时时间。当非核心线程处于空闲状态的时间超过这个时间后，该线程将被回收。将allowCoreThreadTimeOut参数设置为true后，核心线程也会被回收。
unit（必需） keepAliveTime参数的时间单位。有：TimeUnit.DAYS（天）、TimeUnit.HOURS（小时）、TimeUnit.MINUTES（分钟）、TimeUnit.SECONDS（秒）、TimeUnit.MILLISECONDS（毫秒）、TimeUnit.MICROSECONDS（微秒）、TimeUnit.NANOSECONDS（纳秒）
workQueue（必需） 任务队列，采用阻塞队列实现。当核心线程全部繁忙时，后续由execute方法提交的Runnable将存放在任务队列中，等待被线程处理。
threadFactory（可选，不是那么重要） 线程工厂。指定线程池创建线程的方式。
handler（可选，不是那么重要） 拒绝策略。当线程池中线程数达到maximumPoolSize且workQueue打满时，后续提交的任务将被拒绝，handler可以指定用什么方式拒绝任务。

(1)任务队列
 
使用ThreadPoolExecutor需要指定一个实现了BlockingQueue接口的任务等待队列。在ThreadPoolExecutor线程池的API文档中，一共推荐了三种等待队列，它们是：SynchronousQueue、LinkedBlockingQueue和ArrayBlockingQueue；

种类 解释
SynchronousQueue 同步队列。这是一个内部没有任何容量的阻塞队列，任何一次插入操作的元素都要等待相对的删除/读取操作，否则进行插入操作的线程就要一直等待，反之亦然。
LinkedBlockingQueue 无界队列（严格来说并非无界，上限是Integer.MAX_VALUE），基于链表结构。使用无界队列后，当核心线程都繁忙时，后续任务可以无限加入队列，因此线程池中线程数不会超过核心线程数。这种队列可以提高线程池吞吐量，但代价是牺牲内存空间，甚至会导致内存溢出。另外，使用它时可以指定容量，这样它也就是一种有界队列了。
ArrayBlockingQueue 有界队列，基于数组实现。在线程池初始化时，指定队列的容量，后续无法再调整。这种有界队列有利于防止资源耗尽，但可能更难调整和控制。

 
(2)拒绝策略

扫描二维码关注公众号，回复： 12943972 查看本文章

线程池有一个重要的机制：拒绝策略。当线程池workQueue已满且无法再创建新线程池时，就要拒绝后续任务了。拒绝策略需要实现RejectedExecutionHandler接口，不过Executors框架已经为我们实现了4种拒绝策略：

种类 说明
AbortPolicy（默认） 丢弃任务并抛出RejectedExecutionException异常。
CallerRunsPolicy 直接运行这个任务的run方法，但并非是由线程池的线程处理，而是交由任务的调用线程处理。
DiscardPolicy 直接丢弃任务，不抛出任何异常。
DiscardOldestPolicy 将当前处于等待队列列头的等待任务强行取出，然后再试图将当前被拒绝的任务提交到线程池执行。

3.使用线程池

3.1 使用的流程


// 创建线程池
ThreadPoolExecutor threadPool = new ThreadPoolExecutor(CORE_POOL_SIZE,
                                             MAXIMUM_POOL_SIZE,
                                             KEEP_ALIVE,
                                             TimeUnit.SECONDS,
                                             sPoolWorkQueue,
                                             sThreadFactory);
// 向线程池提交任务
threadPool.execute(new Runnable() {
    
    
    @Override
    public void run() {
    
    
        ... // 线程执行的任务
    }
});
// 关闭线程池
threadPool.shutdown(); // 设置线程池的状态为SHUTDOWN，然后中断所有没有正在执行任务的线程
threadPool.shutdownNow(); // 设置线程池的状态为 STOP，然后尝试停止所有的正在执行或暂停任务的线程，并返回等待执行任务的列表

3.2 线程初始化

默认情况下，创建线程池之后，线程池中是没有线程的，需要提交任务之后才会创建线程。
在实际中如果需要线程池创建之后立即创建线程，可以通过以下两个方法办到：

//初始化一个核心线程
public boolean prestartCoreThread() {
    
    
    return addIfUnderCorePoolSize(null); //注意传进去的参数是null
}
//初始化所有核心线程，并返回初始化的线程数
public int prestartAllCoreThreads() {
    
    
    int n = 0;
    while (addIfUnderCorePoolSize(null))//注意传进去的参数是null
        ++n;
    return n;
}

3.3 线程池关闭

ThreadPoolExecutor提供了两个方法，用于线程池的关闭：

  • shutdown()：不会立即终止线程池，而是要等所有任务缓存队列中的任务都执行完后才终止，但再也不会接受新的任务
  • shutdownNow()：立即终止线程池，并尝试打断正在执行的任务，并且清空任务缓存队列，返回尚未执行的任务

3.4 线程池容量调整

ThreadPoolExecutor提供了动态调整线程池容量大小的方法：

  • setCorePoolSize：设置核心池大小
  • setMaximumPoolSize：设置线程池最大能创建的线程数目大小
    当上述参数从小变大时，ThreadPoolExecutor进行线程赋值，还可能立即创建新的线程来执行任务。

3.5 具体的demo

一个基于线程池的图片加载类，把加载到的图片显示到页面中

public interface UpdateUI {
    
    
    /*
    用于IntentService和主线程进行交互
     */
    void upData(Message message);
}

public class TPEUser {
    
    
    private final UpdateUI updateUI;	//和MainActivity交互的接口

    private final Context context;

    public TPEUser(Context context,UpdateUI updateUI) {
    
    		
        this.context  = context;
        this.updateUI = updateUI;


    }
    public void start(Object data){
    
    		//调用线程池获取图片并通过接口向主线程传递消息

        //创建线程池
        ThreadPoolExecutor threadPool = new ThreadPoolExecutor(3,5,5,
                TimeUnit.SECONDS, new ArrayBlockingQueue<>(5));
        //向线程池中提交任务
        String[] urls = (String[])data;
        for(int i = 0; i < urls.length; i++){
    
    
            int finalI = i;
            threadPool.execute(() -> {
    
    
                Bitmap bitmap = downloadUrlBitmap(urls[finalI]);
                Message msg = new Message();
                ImageModel imageModel = new ImageModel()
                imageModel.setBitmap(bitmap);
                msg.obj = imageModel;
                msg.what = finalI;
                if(updateUI!=null){
    
    
                    updateUI.upData(msg);
                }
            });
        }
        // 关闭线程池
        threadPool.shutdown(); // 设置线程池的状态为SHUTDOWN，然后中断所有没有正在执行任务的线程
        // threadPool.shutdownNow(); // 设置线程池的状态为STOP，然后尝试停止所有的正在执行或暂停任务的线程，并返回等待执行任务的列表，
        // 该方法要慎用，容易造成不可控的后果
    }
    //glide加载图片
    private Bitmap downloadUrlBitmap(String url) {
    
    
        FutureTarget<Bitmap> futureTarget =
                Glide.with(context)
                        .asBitmap()
                        .load(url).submit(100,100);

        Bitmap bitmap = null;
        try {
    
    
            bitmap = futureTarget.get();
        } catch (ExecutionException e) {
    
    
            e.printStackTrace();
        } catch (InterruptedException e) {
    
    
            e.printStackTrace();
        }
        return bitmap;
    }


}

4.功能线程池

Executors已经为我们封装好了4种常见的功能线程池，如下：

4.1 定长线程池（FixedThreadPool）

创建方法的源码：

// 使用默认线程工厂
public static ExecutorService newFixedThreadPool(int nThreads) {
    
    
    return new ThreadPoolExecutor(nThreads, nThreads,
                                  0L, TimeUnit.MILLISECONDS,
                                  new LinkedBlockingQueue<Runnable>());
}
// 需要自定义线程工厂
public static ExecutorService newFixedThreadPool(int nThreads, ThreadFactory threadFactory) {
    
    
    return new ThreadPoolExecutor(nThreads, nThreads,
                                  0L, TimeUnit.MILLISECONDS,
                                  new LinkedBlockingQueue<Runnable>(),
                                  threadFactory);
}

特点：只有核心线程，线程数量固定，执行完立即回收，任务队列为链表结构的有界队列。
应用场景：控制线程最大并发数。

使用示例：

// 1. 创建线程池对象，设置核心线程和最大线程数为5
ExecutorService fixedThreadPool = Executors.newFixedThreadPool(5);
// 2. 创建Runnable（任务）
Runnable task =new Runnable(){
    
    
  public void run() {
    
    
    ......
  }
};
// 3. 向线程池提交任务
fixedThreadPool.execute(task);

4.2 定时线程池（ScheduledThreadPool ）

public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {
    
    
    return new ScheduledThreadPoolExecutor(corePoolSize);
}

// 继承了 ThreadPoolExecutor
public class ScheduledThreadPoolExecutor extends ThreadPoolExecutor
        implements ScheduledExecutorService {
    
    
    // 构造函数，省略了自定义线程工厂的构造函数
	public ScheduledThreadPoolExecutor(int corePoolSize) {
    
    
    	super(corePoolSize, Integer.MAX_VALUE, 0, NANOSECONDS,
          	new DelayedWorkQueue());
	}
	
	// 延时执行任务
	public ScheduledFuture<?> schedule(Runnable command,
                                       long delay,
                                       TimeUnit unit) {
    
    
        ...
    }
	// 定时执行任务
	public ScheduledFuture<?> scheduleAtFixedRate(Runnable command,
                                                  long initialDelay,
                                                  long period,
                                                  TimeUnit unit) {
    
    ...}
}

特点：核心线程数量固定，非核心线程数量无限，执行完闲置10ms后回收，任务队列为延时阻塞队列。
应用场景：执行定时或周期性的任务。

使用示例：

// 1. 创建定时线程池
ExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);
// 2. 创建Runnable（任务）
Runnable task = new Runnable(){
    
    
  public void run() {
    
    
    ......
  }
};
// 3. 向线程池提交任务
scheduledThreadPool.schedule(task, 2, TimeUnit.SECONDS); // 延迟2s后执行任务
scheduledThreadPool.scheduleAtFixedRate(task,50,2000,TimeUnit.MILLISECONDS);// 延迟50ms后、每隔2000ms执行任务

4.3 可缓存线程池（CachedThreadPool）

public static ExecutorService newCachedThreadPool() {
    
    
    return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                  60L, TimeUnit.SECONDS,
                                  new SynchronousQueue<Runnable>());
}

特点：无核心线程，非核心线程数量无限，执行完闲置60s后回收，任务队列为不存储元素的阻塞队列。
应用场景：执行大量、耗时少的任务。

使用示例：

// 1. 创建缓存线程池
ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
// 2. 创建Runnable（任务）
Runnable task = new Runnable(){
    
    
  public void run() {
    
    
     ......
  }
};
// 3. 向线程池提交任务
cachedThreadPool.execute(task);

4.4 单线程化线程池（SingleThreadExecutor）

public static ExecutorService newSingleThreadExecutor() {
    
    
    return new FinalizableDelegatedExecutorService
        (new ThreadPoolExecutor(1, 1,
                                0L, TimeUnit.MILLISECONDS,
                                new LinkedBlockingQueue<Runnable>()));
}
// 为节省篇幅，省略了自定义线程工厂方式的源码

特点：只有1个核心线程，无非核心线程，执行完立即回收，任务队列为链表结构的有界队列。
应用场景：不适合并发但可能引起IO阻塞性及影响UI线程响应的操作，如数据库操作、文件操作等。

使用示例：

// 1. 创建单线程线程池
ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();
// 2. 创建Runnable（任务）
Runnable task = new Runnable(){
    
    
  public void run() {
    
    
    ......
  }
};
// 3. 向线程池提交任务
singleThreadExecutor.execute(task);

4.5 对比

在这里插入图片描述

5.参考博客

Java多线程：彻底搞懂线程池
深入Java线程池：从设计思想到源码解读

猜你喜欢

转载自blog.csdn.net/haazzz/article/details/115265102
今日推荐
“百模大战”必有一战 | 2024中国“百模大战”竞争格局分析
最强开源大模型 Llama 3 上架 Gitee AI
虽然老乡鸡开源的不是代码，但背后的原因却让人很暖心
富文本编辑器 Quill 2.0 重磅发布，特性、可靠性与开发者体验大幅提升
周排行
android 文件上传（模拟表单提交）
node中遇到的一些问题
zhuanzai
树莓派3B板载蓝牙与HC05蓝牙模块配对(shell命令实现)
configparser模块简介 configparser模块简介
度度熊的01世界
浅谈log4j-6-xml配置 转自godtrue
Kali无线渗透获取宿舍WiFi密码（WPA）
在VMware虚拟机中安装ubuntu
如何用微信公众号二维码事件做扫码登陆
每日归档
更多
2024-04-21(0)
2024-04-20(6)
2024-04-19(5)
2024-04-18(0)
2024-04-17(5)
2024-04-16(70)
2024-04-15(42)
2024-04-14(0)
2024-04-13(119)
2024-04-12(38)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022