Android 线程池 工作调度

最新推荐文章于 2020-09-30 17:00:31 发布
最新推荐文章于 2020-09-30 17:00:31 发布
阅读量384 收藏
点赞数
分类专栏： Android 线程消息工作
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_31726827/article/details/50544472
版权

我想网上面一大堆关于线程池的文章和资料,这里面介绍一些需要注意和最好能够了解的部分.

一般使用线程池就会想到类ExecutorService和Executors

不知道是否有人看过他们的源代码,他们的关系如下:

public interface ExecutorService extends Executor

当然可以知道Executors也是个接口:

public interface Executor {

这个里面个人觉得需要注意ExecutorService.java中的

<T> Future<T> submit(Callable<T> task);


其中重点的Future类:

public interface Future<V> {

线程池管理着一堆的线程,如何获取这些线程运行状态呢?那么就需要了解Future类的作用了.我个人觉得这个类的作用主要是"占坑",当线程被submit的时候,返回一个Future对象,通过获取这个Future对象,并且调用其get()方法来获取线程的基本运行状态.虽然它能够让人知道线程池中的线程运行状态,但是由于这个状态是通过反馈回来的,如果线程池中的线程没有运行完,它就迟迟不会受到反馈信息,如果没有收到反馈信息,它就会阻塞它所在的线程,如果放在UI线程中,那么一旦运行,那么UI线程就会卡住,所以一般最好是放在异步线程中,比如说向服务确认身份认证,那么就要一直等待服务器反馈正确信息后,才能够执行向服务器请求的其他工作.

private void futureForPool(){

        mPool=Executors.newFixedThreadPool(10);

        Future<String> future=mPool.submit(new Callable<String>() {

            @Override
            public String call() throws Exception {
                Thread.sleep(2500);
                Log.i(TAG,"future callback !");
                return "zhibao.liu !";
            }

        });

        try {
            String msg=future.get().toString();
            Log.i(TAG,"future msg : "+msg);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }

    }

另外一个FutureTask类:

public class FutureTask<V> implements RunnableFuture<V> {


public interface RunnableFuture<V> extends Runnable, Future<V> {

可以看出它也是Future机制的.

private void futureTaskForPool(){

        mPool=Executors.newFixedThreadPool(10);

        FutureTask<String> mft=new FutureTask<String>(new Callable<String>() {
            @Override
            public String call() throws Exception {
                Thread.sleep(2500);
                Log.i(TAG,"FutureTask work !");
                return null;
            }
        });

        mPool.execute(mft);

        try {
            mft.get(500, TimeUnit.MILLISECONDS);
        } catch (InterruptedException e) {
            boolean iswork=mft.isDone();
            if(!iswork){
                Log.i(TAG,"FutureTask is still working !");
            }
            mft.cancel(true);
//            e.printStackTrace();
        } catch (ExecutionException e) {
            boolean iswork=mft.isDone();
            if(!iswork){
                Log.i(TAG,"FutureTask is still working !");
            }
            mft.cancel(true);
//            e.printStackTrace();
        } catch (TimeoutException e) {
            boolean iswork=mft.isDone();
            if(!iswork){
                Log.i(TAG,"FutureTask is still working !");
            }
            mft.cancel(true);
//            e.printStackTrace();
        }finally {
            mPool.shutdown();
        }

        Log.i(TAG,"FutureTask i : finish !");

    }
下面的需要注意: 

mft.get(500, TimeUnit.MILLISECONDS);

线程中的任务需要在500ms时间的时候给出反馈,无论事情是否做完,如果事情还没有做完将会报出timeout异常,在处理异常中可以继续判断事情是否做完,如果没有做完,我们将其抛弃:

mft.cancel(true);

工作将不再继续执行.

就像食品有效日期一样,如果在有效日内,就可以继续食用,如果超出指定的有效日,就没有必要继续食用了.事情也是这样,有些事情只有在规定的时间内完成才有意义,如果超出了时间就没什么意义了.

 


下面给出整个工程源码:

package org.durian.durianexecutors;

import android.os.Bundle;
import android.support.v7.app.ActionBarActivity;
import android.util.Log;
import android.view.Menu;
import android.view.MenuItem;
import android.view.View;
import android.widget.Button;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.FutureTask;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class DurianMainActivity extends ActionBarActivity implements View.OnClickListener {

    private final static String TAG="DurianMainActivity";

    private Button mCachePoolButton;
    private Button mFixPoolButton;
    private Button mSchedulePoolButton;
    private Button mSinglePoolButton;
    private Button mFutureButton;

    private Button mFactoryButton;

    private ExecutorService mPool;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.durian_main);

        mCachePoolButton=(Button)findViewById(R.id.cachepool);
        mCachePoolButton.setOnClickListener(this);

        mFixPoolButton=(Button)findViewById(R.id.fixpool);
        mFixPoolButton.setOnClickListener(this);

        mSchedulePoolButton=(Button)findViewById(R.id.schedulepool);
        mSchedulePoolButton.setOnClickListener(this);

        mSinglePoolButton=(Button)findViewById(R.id.singlepool);
        mSinglePoolButton.setOnClickListener(this);

        mFutureButton=(Button)findViewById(R.id.future);
        mFutureButton.setOnClickListener(this);

        mFactoryButton=(Button)findViewById(R.id.fixpoolforfactory);
        mFactoryButton.setOnClickListener(this);

    }

    @Override
    public void onClick(View v) {

        int id=v.getId();
        switch (id){
            case R.id.future:
                futureTaskForPool();
                break;
            case R.id.cachepool:
                cachePoolForThread();
                break;
            case R.id.fixpool:
                fixPoolForThread();
                break;
            case R.id.schedulepool:
                schedulePoolForThread();
                break;
            case R.id.singlepool:
                singlePoolForThread();
                break;
            case R.id.fixpoolforfactory:
                fixPoolForFactoryThread();
                break;
            default:
                break;
        }

    }

    private int count=0;

    private void futureForPool(){

        mPool=Executors.newFixedThreadPool(10);

        Future<String> future=mPool.submit(new Callable<String>() {

            @Override
            public String call() throws Exception {
                Thread.sleep(2500);
                Log.i(TAG,"future callback !");
                return "zhibao.liu !";
            }

        });

        try {
            String msg=future.get().toString();
            Log.i(TAG,"future msg : "+msg);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }

    }

    private void futureTaskForPool(){

        mPool=Executors.newFixedThreadPool(10);

        FutureTask<String> mft=new FutureTask<String>(new Callable<String>() {
            @Override
            public String call() throws Exception {
                Thread.sleep(2500);
                Log.i(TAG,"FutureTask work !");
                return null;
            }
        });

        mPool.execute(mft);

        try {
            mft.get(500, TimeUnit.MILLISECONDS);
        } catch (InterruptedException e) {
            boolean iswork=mft.isDone();
            if(!iswork){
                Log.i(TAG,"FutureTask is still working !");
            }
            mft.cancel(true);
//            e.printStackTrace();
        } catch (ExecutionException e) {
            boolean iswork=mft.isDone();
            if(!iswork){
                Log.i(TAG,"FutureTask is still working !");
            }
            mft.cancel(true);
//            e.printStackTrace();
        } catch (TimeoutException e) {
            boolean iswork=mft.isDone();
            if(!iswork){
                Log.i(TAG,"FutureTask is still working !");
            }
            mft.cancel(true);
//            e.printStackTrace();
        }finally {
            mPool.shutdown();
        }

        Log.i(TAG,"FutureTask i : finish !");

    }

    private void cachePoolForThread(){

        mPool=Executors.newCachedThreadPool();

        count=0;

        for(int i=0;i<20;i++){

            Thread thread=new Thread(new Runnable() {
                @Override
                public void run() {
                    try {

                        Thread.sleep(2500);
                        Log.i(TAG,"cachePoolForThread i : "+count++);

                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            });

            mPool.execute(thread);

        }

    }

    private void fixPoolForThread(){

        mPool=Executors.newFixedThreadPool(10);

        count=0;

        for(int i=0;i<10;i++){

            Thread thread=new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        Thread.sleep(1500);
                        Log.i(TAG,"fixpool i="+count++);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            });

            Future<String> future=mPool.submit(new Callable<String>() {

                @Override
                public String call() throws Exception {
                    Thread.sleep(500);
                    Log.i(TAG,"future callback !");
                    return "zhibao.liu !";
                }

            });

            try {
                String msg=future.get().toString();
                Log.i(TAG,"future msg : "+msg);
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (ExecutionException e) {
                e.printStackTrace();
            }

            mPool.execute(thread);

            Future<String> m=mPool.submit(new Runnable() {
                @Override
                public void run() {
                    try {
                        Thread.sleep(500);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    Log.i(TAG,"future callback !");
                }
            },"durian from zhibao.liu");

            try {
                Log.i(TAG,"future msg : "+m.get().toString());
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (ExecutionException e) {
                e.printStackTrace();
            }

        }

    }


    private void fixPoolForFactoryThread(){

        count=0;

        /*
        * ThreadFactory : 作用
        * <1> : 设置线程池中线程属性
        * <2> : 代码debug
        * <3> : 异常捕获
        * */
        mPool=Executors.newFixedThreadPool(10, new ThreadFactory() {
            @Override
            public Thread newThread(Runnable runable) {
                Thread t=new Thread(runable);
                t.setDaemon(true);
                t.setPriority(Thread.MAX_PRIORITY);
                return t;
            }
        });

        for (int i=0;i<10;i++){

            mPool.execute(new Runnable() {
                @Override
                public void run() {
                    try {
                        Thread.sleep(500);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    Log.i(TAG,"fixPoolForFactoryThread work : "+count++);
                }
            });

        }

    }

    private void schedulePoolForThread(){

        ScheduledExecutorService schedule=Executors.newScheduledThreadPool(10);

        count=0;
        for (int i=0;i<1;i++){

            Log.i(TAG,"schedule work ...");

            schedule.schedule(new Runnable() {
                @Override
                public void run() {

                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    Log.i(TAG,"schedule work after 1000 delays : "+count++);

                }
            },3000,TimeUnit.MILLISECONDS);

        }

    }

    private void singlePoolForThread(){

        mPool=Executors.newSingleThreadExecutor();

        count=0;

        for (int i=0;i<10;i++){

            mPool.execute(new Runnable() {
                @Override
                public void run() {
                    try {
                        Thread.sleep(2500);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    Log.i(TAG,"single work in the same thread : "+count++);
                }
            });

        }

    }



}

布局文件:

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical"
    tools:context="org.durian.durianexecutors.DurianMainActivity">

    <Button
        android:id="@+id/future"
        android:text="future mode"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content" />

    <Button
        android:id="@+id/cachepool"
        android:text="newCachedThreadPool"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content" />

    <Button
        android:id="@+id/fixpool"
        android:text="newFixedThreadPool"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content" />

    <Button
        android:id="@+id/schedulepool"
        android:text="newScheduledThreadPool"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content" />

    <Button
        android:id="@+id/singlepool"
        android:text="newSingleThreadExecutor"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content" />

    <Button
        android:id="@+id/fixpoolforfactory"
        android:text="fixPoolForFactory"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content" />

</LinearLayout>

我们需要注意的是newSingleThreadExecutor返回的对象,这个我个人的理解是分配的N件事情,但是N件事情都是在同一个线程中完成的:从下面可以看出N件事情只在同一个线程中完成


Thread 1是app的主线程,Thread 6是虚拟机中的.

从Thread 28才是,只看见一个吧,下面给个cache的参照:从下面图中可以看出,N件事在N个线程中执行:


另外附加了一个FactoryThread

private void fixPoolForFactoryThread(){

        count=0;

        /*
        * ThreadFactory : 作用
        * <1> : 设置线程池中线程属性
        * <2> : 代码debug
        * <3> : 异常捕获
        * */
        mPool=Executors.newFixedThreadPool(10, new ThreadFactory() {
            @Override
            public Thread newThread(Runnable runable) {
                Thread t=new Thread(runable);
                t.setDaemon(true);
                t.setPriority(Thread.MAX_PRIORITY);
                return t;
            }
        });

        for (int i=0;i<10;i++){

            mPool.execute(new Runnable() {
                @Override
                public void run() {
                    try {
                        Thread.sleep(500);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    Log.i(TAG,"fixPoolForFactoryThread work : "+count++);
                }
            });

        }

    }

参照上面的注解,至于线程池中的四种应用,没什么特别要说的.










喝醉了的熊猫
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
进程的Binder线程池工作过程
01-27
【进程的Binder线程池工作过程】 在Android系统中，Binder是实现进程间通信（IPC）的核心机制。当系统启动后，诸如ActivityManager、PackageManager等关键服务都在名为`system_server`的进程中运行。应用程序需要...
android线程池demo
11-10
本文将深入探讨`android线程池`的概念、工作原理以及如何在实际项目中实现一个简单的应用。 ### 线程池简介 线程池是由多个线程组成的集合，它预先创建了一定数量的线程，当有任务需要执行时，线程池会从已存在的...
Android线程调度机制
OsBelief的专栏
02-24 4047
在Android Weekly上看到了一篇关于Android线程调度的文章，感觉挺不错的，试着将其翻译了一下，原文地址http://www.androiddesignpatterns.com/2014/01/thread-scheduling-in-android.html。 这篇文章是关于Android中线程是如何调度的，以及怎么样显示设置线程优先级保证应用程序在多个线程在后台运行时保持响应。
Android 中的线程调度
wzzushx的专栏
06-15 674
ZZ：http://stackvoid.com/Thread-Scheduling-in-Android/ 本文概述了 Android 中的线程是如何调度的，并通过设置线程优先级来优化 APP-UI，使其流畅运行。 线程调度听起来很学术，是操作系统中的概念：线程调度决定系统中不同线程运行，运行时间，何时运行。Android 中的线程调度很操作系统中的线程调度类似，主要使用 nice 和 cgr
Android 中的线程是如何调度
vigoss_xianyu的博客
09-14 299
本文概述了 Android 中的线程是如何调度的，并通过设置线程优先级来优化 APP-UI，保证 UI 线程优先级最高，从而提高用户体验。线程调度听起来很学术，是操作系统中的概念：线程调度决定系统中不同线程运行，运行时间，何时运行。Android 中的线程调度很操作系统中的线程调度类似，主要使用 nice 和 cgroups 这两个变量来调度线程(本质上来说还是通过设置线程优先级，让 Linux 内
android线程管理--线程池
知识搬运工，资料任你拿，包括书籍、电影、电视剧、网站、软件等，VX公人人人号：向前书局
07-26 2214
原文：https://www.jianshu.com/p/51c386e4a618   为什么要引入线程池？ 1.new Thread()的缺点 每次new Thread()耗费性能 调用new Thread()创建的线程缺乏管理，被称为野线程，而且可以无限制创建，之间相互竞争，会导致过多占用系统资源导致系统瘫痪。 不利于扩展，比如如定时执行、定期执行、线程中断 2.采用线程池的优点 ...
android线程池案例
12-28
"android线程池案例"提供了这样的示例，用于演示如何在Android应用程序中有效地使用线程池，并结合进度条来显示任务的执行状态。 线程池的核心概念包括： 1. **ExecutorService**: Java的`ExecutorService`接口是...
在Android线程池里运行代码任务实例
01-05
流程是，添加一个任务到线程池的工作队列，当有线程可用时(执行完其他任务，空闲，或者还没执行任务),ThreadPoolExecutor会从队列里取任务，并在线程里运行。 本课同时向你展示了如何停止正在运行的任务。 在线程池...
android线程池管理工具类
07-02
android线程池管理工具类,用来管理线程的一些操作，避免重复new线程造成的资源浪费
Android多线程及异步任务消息处理机制 一 Handler的使用
08-26
Android多线程及异步任务消息处理机制 一 Handler的使用博文源代码 想要学习更多有关于Android的知识 请关注博客http: blog csdn net yegongheng
Android的线程池：ExecutorService和Executors
行吟阁
05-30 1376
ExecutorService是线程池的一个服务，可以随时关闭线程池，是继承Executor的。Executors是个工厂类，专门创建各种线程池。 Android常用的线程池有一下几种，在Executors里面对应的方法： 1. newFixedThreadPool 创建一个可重用固定线程数的线程池，以共享的无界队列方式来运行这些线程。在任意点，在大多数 nThreads 线程会处于处理任务
线程调度
不浪漫罪名的博客
03-26 540
什么是线程调度 ？ 线程调度就是按照特定的机制为多个线程分配CPU使用权，有两种调度模型：分时调度模型和抢占式调度模型。 分时调度模型：让所有线程轮流获得CPU使用权，并且平均分配每个线程占用CPU的时间片。 抢占式调度模型：java虚拟机采用的线程调度模型。它是指优先让可运行池中优先级高的线程占用CPU，如果线程的优先级相同，就随机选择一个占用CPU。 注意：线程的调度不是跨平台的，它...
AsyncTask中线程池调度分析
Android学习之旅
01-10 3007
在Android中，和异步执行相关的两个类就是Handler和AsyncTask，所以Android开发人员对于这两个类是再熟悉不过了，所以这里我不是讲解AsyncTask怎么使用，而是想分析一下AsyncTask中线程池的调度过程，然后简单的介绍一下AsyncTask的源码以及Android3.0前后，AsyncTask中线程池的区别。
Android Handler线程间的调度
不懂事的小屁孩
12-12 108
最简单的线程，就是用到了一个Hnadler 线程Handler使用.zip 是主线程，子线程之间的调度 用到了looper 线程-时钟动态显示.rar 一个时钟控件，一个TextView随着时间改变不停的改变...
Android 线程池的使用
后时代的觉悟的专栏
10-15 6234
线程池优点 提到线程池就必须先说一下线程池的优点，线程池的优点可以概括为以下四点： * 重用线程池中的线程，避免因为线程的创建和销毁所带来的性能开销； * 线程池旨在线程的复用，就避免了创建线程和销毁线程所带来的时间消耗，减少线程频繁调度的开销，从而节约系统资源，提高系统吞吐量； * 能有效控制线程池的最大并发数，避免大量的线程之间因互相抢占系统资源而导致的阻塞现象； * 能够对
android 多线程实现方式、并发与同步学习总结
mingtiannihao623的博客
09-18 3995
参考地址：http://blog.csdn.net/qq_30379689/article/details/72550701#面向对象和面向过程的区别 http://blog.csdn.net/csdn_aiyang/article/details/65442540多线程的三种实现方式 继承Thread类，重写run函数方法 实现Runnable接口，重写run函数方法 实现Callable接口，
多线程学习总结
qq_16657805的博客
09-30 277
为什么使用多线程 为了更高效的完成任务和利用CPU资源，现在的操作系统设计为多任务操作系统，而多进程和多线程是实现多任务的方式。 进程和线程 程序：是为完成特定任务，用某种语言编写的一组指令的集合，即指一段静态的代码，静态对象。 进程：是程序的一次执行过程，或是正在运行的一个程序，是一个动态的过程，有它自身的产生，存在和消亡的过程。-------生命周期 线程：进程可进一步细化为线程，是一个程序内部的一条执行路径 同步和异步&并发和并行 同步：排队执行，效率低但是安全 异步：同时执行，效
Android 线程池
最新发布
07-20
Android线程池是用来管理和执行多线程任务的框架。它可以帮助我们合理地管理线程，避免线程过多或过少的情况，提高应用程序的性能和稳定性。 Android提供了两种类型的线程池：ThreadPoolExecutor和...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值