android 基本任务 的执行原理分析

最新推荐文章于 2024-11-20 15:59:44 发布
最新推荐文章于 2024-11-20 15:59:44 发布
阅读量610 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： android 之旅
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/user_define_race/article/details/41628507
本文介绍了一个用于Android平台的基本异步任务管理类BaseTask及其配套的并发执行管理类ConcurrenceExcutor。BaseTask提供了任务的状态管理和执行流程控制，而ConcurrenceExcutor则实现了多个BaseTask的串行执行，支持任务的添加、取消和执行状态的检查。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

package com.example.basetask;


import android.R.integer;
import android.content.Context;


/**
 * <code>BaseTask</code>
 * @description: TODO(基本异步任务信息) 
 * @version  1.0
 * @author  yourname
 * @since 2012-2-3
 */
public abstract class BaseTask {
	//任务是否已退出。
	//private boolean canceled = false;
	//标识任务状态
	private int status = 0;
	//是否任务取消标志
	private boolean cancelFlag = false;
	//任务是否成功标志
	private boolean successFlag = false;
	public boolean isSuccess() {
		return successFlag;
	}
	public void setSuccessFlag(boolean successFlag) {
		setFinishStatus();
		this.successFlag = successFlag;
	}
	//错误信息
	private String errorMessage;
	public String getErrorMessage() {
		return errorMessage;
	}
	public void setErrorMessage(String errorMessage) {
		this.errorMessage = errorMessage;
	}
	public RuntimeException getException() {
		return exception;
	}
	public void setException(RuntimeException exception) {
		this.exception = exception;
	}
	//任务异常
	private RuntimeException exception;
	//等待开始状态
	private static final int WAIT = 0;
	//任务执行中
	private static final int PROCESS = 1;
	//任务取消
	 //private static final int CANCEL = 2;
	//任务完成
	private static final int FINISH = 3;
	public void resetTask(){
		status = WAIT;
	}
	/**
	 * 退出任务
	 */
	public void cancelTask(){
		//setCancle(true);
		cancelFlag = true;
		
	}
	private void setFinishStatus(){
		status = FINISH;
	}
	/**
	 * 命令任务退出
	 * @param canceled
	 */
/*	private void setCancle(boolean canceled)
	{
		this.canceled = canceled;
	}*/
	public boolean isCancel()
	{
		return cancelFlag;
	}
	public boolean isCancelAtDialogDismiss() {
		return false;
	}
	/**
	 * <code>prepareTask</code>
	 * @description: TODO(执行前准备函数) 
	 * @param params
	 * @since   2012-2-3    yourname
	 */
	public void prepareTask(Void... params){
		status=PROCESS;
	};
	/**
	 * <code>doTask</code>
	 * @description: TODO(执行任务) 
	 * @throws POAException
	 * @since   2012-2-3    yourname
	 */
	public abstract void doTask() throws RuntimeException;
	/**
	 * <code>success</code>
	 * @description: TODO(成功处理函数) 
	 * @since   2012-2-3    yourname
	 */
	public void success(){
		setFinishStatus();
	};
	public boolean hasFinish(){
		return status == FINISH;
	}
	/**
	 * <code>fail</code>
	 * @description: TODO(失败处理函数) 
	 * @param errorMessage
	 * @since   2012-2-3    yourname
	 */
	public void fail(RuntimeException e){
		if(e!=null)
			fail(e.getMessage());
		else
			fail("");
	//	setFinishStatus();
	};
	/**
	 * <code>fail</code>
	 * @description: TODO(失败处理函数) 
	 * @param errorMessage
	 * @since   2012-2-3    yourname
	 */
	public void fail(String errorMessage){
		setFinishStatus();
	};
	/**
	 * 取消任务后调用函数
	 */
	public void cancel(){
		if(cancelListener!=null){
			cancelListener.cancel(this);
		}
	};
	public Context getContext(){return null;};
	private ITaskCancel cancelListener;
	ITaskCancel getCancelListener() {
		return cancelListener;
	}
	void setCancelListener(ITaskCancel cancelListener) {
		this.cancelListener = cancelListener;
	}
	public interface ITaskCancel{
		 void cancel(BaseTask task);
	}
}


package com.example.basetask;



import java.util.LinkedList;

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

import android.content.Context;
import android.os.Handler;
import android.os.Looper;
import android.util.Log;


/**
 * 串行执行任务
 * @author jhzhangnan1
 *
 */
public class ConcurrenceExcutor {

	protected Handler mainHandler ;
	protected Vector<BaseTask> waitTasks,tmptasks,processTasks;
//	protected BaseTask currentTask;
	private int maxThreads = 10;
	private ExecutorService executorService; 
	
	private ConcurrenceExcutor(){
		this(10);
	}
	public static ConcurrenceExcutor getInstance(){
		return excutor;
	} 
	private static ConcurrenceExcutor excutor = new ConcurrenceExcutor();
	/**
	 *?
	 */
/*	private void cancelTaskAtDialogDismiss(){
		if(currentTask!=null&¤tTask.isCancelAtDialogDismiss())
		{
			cancelCurrentTask();
		}
	}
	private void cancelCurrentTask(){
		removeTask(currentTask);
	}*/
	public ConcurrenceExcutor(int maxThreadCount)
	{
		this.maxThreads = maxThreadCount;
		mainHandler = new Handler(Looper.getMainLooper());//
		waitTasks = new Vector<BaseTask>();
		tmptasks = new Vector<BaseTask>();
		processTasks = new Vector<BaseTask>();
		executorService = Executors.newFixedThreadPool(maxThreads); 
		
	}
	public void cancelTask(BaseTask task){
		if(task!=null)
		{
			waitTasks.remove(task);
			processTasks.remove(task);
			finishExecute();
			task.cancelTask();
		}
	}
	public void addTaskFirst(BaseTask task)
	{
		waitTasks.add(0,task);
		start();
	}
	public void addTask(BaseTask task)
	{
		waitTasks.add(task);
		start();
	}
	
	public void removeTask(BaseTask task){
		if (waitTasks!=null && waitTasks.contains(task)) {
			waitTasks.remove(task);
		}
		/*if (processTasks!=null && processTasks.contains(task)) {
			processTasks.remove(task);
		}*/
	}
	
	
	public void appendTask(BaseTask task)
	{
		waitTasks.add(task);
		start();
	}
	public void start()
	{
		iterateTask();
	}
	/**
	 * 是否存在任务
	 * @param task
	 * @return
	 */
	public boolean hasTask(BaseTask task) {
		synchronized (waitTasks) {
			if (waitTasks != null) {
				// return allTasks.contains(task);
				if (waitTasks.contains(task))
					return true;
				else if (processTasks != null && processTasks.contains(task)) {
					return true;
				}
				return false;

			} else {
				if (processTasks != null && processTasks.contains(task)) {
					return true;
				}
				return false;
			}
		}

		// return allTasks.contains(task)||processTasks.contains(task);
	}
	/**
	 * 如果任务不在执行时，则添加到任务中，否则不做任何处理
	 * @param task
	 */
	public void executeTaskIfNotExist(BaseTask task){
		if(!hasTask(task)){
			appendTask(task);
		}
	}
	/**
	 * 如果任务正在执行，则先取消任务，然后再加入到任务队列中。
	 * @param task
	 */
	public void cancelBeforeExecute(BaseTask task){
		if(task!=null){
			cancelTask(task);
		}
	}
	static abstract class BaseRunnable implements Runnable
	{
		public BaseTask currentTask;
		public BaseRunnable(BaseTask currentTask)
		{
			this.currentTask = currentTask;
		}
		@Override
		public void run() {
			// TODO Auto-generated method stub
			
		}
	}
	protected  void iterateTask() {
			if(waitTasks != null&&waitTasks.size()>0)
			{
				while(waitTasks.size()>0)
				{
					BaseTask currentTask;						
					if(processTasks.size()>=maxThreads){
							break;
					}
					synchronized(this)
					{		
						if(processTasks.size()>=maxThreads){
							break;
						}
						currentTask = waitTasks.remove(0);
						if(currentTask!=null)
						processTasks.add(currentTask);
					}

					if(currentTask!=null)
					{
						//processTasks.add(currentTask);
						if(!currentTask.isCancel())
						{
							mainHandler.post(new BaseRunnable(currentTask) {
							
							@Override
							public void run() {
								// TODO Auto-generated method stub
								if(currentTask!=null)
								{
									if(!currentTask.isCancel())
										prepare(currentTask);
									else
									{
										cancelTask(currentTask);
										iterateTask();
									}
										
								}
								else
								{
									iterateTask();
								}
							}
							});
						}
						else
						{
							currentTask.cancel();
						}
					}
				}
	/*			executorService.submit(new Runnable() {
					private BaseTask currentTask;
					@Override
					public void run() {
						// TODO Auto-generated method stub
				//		Looper.prepare();
						if(tasks != null&&tasks.size()>0)
						{
							currentTask = null;
							while(tasks.size()>0)
							{
								currentTask = tasks.remove(0);
								if(currentTask!=null&&!currentTask.isCancel())
								{
									mainHandler.post(new BaseRunnable(currentTask) {
										
										@Override
										public void run() {
											// TODO Auto-generated method stub
											if(currentTask!=null)
											{
												if(!currentTask.isCancel())
													excute(currentTask);
												else
													currentTask.cancel();
											}
											else
											{
												iterateTask();
											}
										}
									});
								}
							}
						}
					}
				});*/
			}
	}
	void prepare(BaseTask currentTask) {
		if(currentTask!=null)
		{
	//		ConcurrenceExcutor.this.currentTask = currentTask;
			if(!currentTask.isCancel())
			{
				currentTask.prepareTask();
				executorService.submit(new BaseRunnable(currentTask) {

					@Override
					public void run() {
						// TODO Auto-generated method stub
						super.run();
						try {
							doInBackground(currentTask);
						} catch (final RuntimeException e) {
							// TODO Auto-generated catch block
							e.printStackTrace();
							taskFailed(currentTask, e);
						}
						 catch (final Exception e) {
								// TODO Auto-generated catch block
								e.printStackTrace();
								taskFailed(currentTask, new RuntimeException(e));
						}
					}

				});
			}
			else
			{
				cancelTask(currentTask);
			}
		}
	}
	private void doInBackground(BaseTask currentTask)
			throws RuntimeException {
		if(!currentTask.isCancel())
		{
		//	currentTask.setSuccessFlag(true);
		//	Log.e("doTask", "doTask");
			currentTask.doTask();
			if(!currentTask.hasFinish()){
				currentTask.setSuccessFlag(true);
			}
			if(currentTask.isSuccess()){
			//	Log.e("doTask", "isSuccess");
				mainHandler.post(new BaseRunnable(currentTask){

					@Override
					public void run() {
						// TODO Auto-generated method stub
						super.run();
						if(currentTask!=null)
						{
							if(!currentTask.isCancel())
							{
								currentTask.success();
								processTasks.remove(currentTask);
								finishExecute();
							}
							else
								cancelTask(currentTask);
						}
				//		ConcurrenceExcutor.this.currentTask = null;
						iterateTask();
					}});
			}
			else{
			//	Log.e("doTask", "failed");
				if(currentTask.getException()!=null){
					taskFailed(currentTask, currentTask.getException());
				}
				else{
					taskFailed(currentTask,new RuntimeException(currentTask.getErrorMessage()));
				}
			}
		}
		else
		{
			mainHandler.post(new BaseRunnable(currentTask){
				@Override
				public void run() {
					cancelTask(currentTask);
				}
			});
			iterateTask();
		}
	}

	private void taskFailed(BaseTask currentTask, final RuntimeException e) {
		currentTask.setSuccessFlag(false);
		currentTask.setException(e);
		mainHandler.post(new BaseRunnable(currentTask) {

			@Override
			public void run() {
				// TODO Auto-generated method stub
				super.run();
				if (currentTask != null) {
					if (!currentTask.isCancel()) {
						currentTask.fail(e);
						processTasks.remove(currentTask);
						finishExecute();
					} else
						cancelTask(currentTask);
				}
				// ConcurrenceExcutor.this.currentTask = null;
				iterateTask();
			}

		});
	}
	//所有任务执行完成后执行的操作
	
	private AllTaskFinish allFinish;
	/**
	 * 设置所有任务完成后的回调
	 * @param allFinish
	 */
	public void setTaskFinishCallBack(AllTaskFinish allFinish){
		this.allFinish = allFinish;
	}
	private void finishExecute(){
		if(waitTasks.size()==0&&processTasks.size()==0&&allFinish!=null){
			allFinish.finish();
		}
	}
	public void exit()
	{
		if(waitTasks!=null)
		{
			tmptasks.clear();
			for(BaseTask task:waitTasks)
				task.cancelTask();
			waitTasks.clear();
			processTasks.clear();
			tmptasks = null;
			waitTasks = null;
		}
		
	}
	public void clearall()
	{
		if(waitTasks!=null)
		{
			for(BaseTask task:waitTasks)
				task.cancelTask();
			waitTasks.clear();
			processTasks.clear();
		}
		
	}
	public void exit(Context context)
	{
		if(waitTasks!=null)
		{
			tmptasks.clear();
			for(BaseTask task:waitTasks)
			{
				if(task!=null)
				{
					if(task.getContext()==null||task.getContext()!=context)
						tmptasks.add(task);
					else
						task.cancelTask();
				}
			}
			waitTasks.clear();
			waitTasks.addAll(tmptasks);
		}
	}

}


package com.example.basetask;

import java.util.Random;

import android.util.Log;


public class TestTask extends BaseTask{
	private int id;
    public TestTask(int id){ 
    	this.id=id;
    }
	@Override
	public void doTask() throws RuntimeException {
		for(int i=0;i<100;i++){
			try {
				Thread.sleep(new Random().nextInt(100));
				/*if(i==99){
					int m=1/0;
				}*/
			} catch (InterruptedException e) {
				//Log.i("zhouke", "error");
				e.printStackTrace();
			}
		}
	
	}
	@Override
	public void success() {
		// TODO Auto-generated method stub
		Log.i("zhouke", "doTask..over success"+Thread.currentThread().getName()+id);
		super.success();
	}
	@Override
	public void fail(String errorMessage) {
		Log.i("zhouke", "doTask..fail"+Thread.currentThread().getName());
		super.fail(errorMessage);
	}

}


package com.example.basetask;

public interface AllTaskFinish {
	public void finish();
}


Android Jetpack 从使用到源码深耕【调度任务组件WorkManager 从实践到原理 】（一）
itbird的专栏
04-01 2084
本文，我们对Jetpack的调度任务组件WorkManager ，由使用入手，对其源码进行深入学习、总结一下。
今天我把APP的编译速度缩短了近5倍，android实战项目源码
m0_66264856的博客
01-24 599
在优化之前我们的一次完整编译时间是****2分21秒 具体的耗时任务在Run Tasks中： 可以看到具体的耗时任务如上，主要是kapt相关的编译和编译kotlin代码，以及最后的transformClassedWithXXX。 优化之后的完整编译时间****31s 优化之后的增量编译时间****15s 看完这里大家是不是已经开始直呼，**，这样也可以！别着急，下面就带大家一起来搞一搞，好东西一定要分享不是吗？ 优化步骤 ==== 1.优化gradle配置： 在项目根目录创建一个gradle.pro
Android Task的应用
a85809291的博客
04-30 1129
在Android应用中，默认是只有一个Task的，而为了方便应用的管理，我们也可以手动的让多个Activity分别依附于多个Task中。Task添加让Activity运行于另一个Activity需要两步设置：Intent的Flag；manifest的taskAffinity。Intent-Flag这一点就很明显了，有个FLAG_ACTIVITY_NEW_TASK选项，顾名思义启动Activity在新
BaseTask 任务分类
zhengyongbo的博客
09-11 1961
有时候类里面的业务逻辑比较多，可以分离出去，新建base类 1.BaseCheckTask public class BaseCheckTask { protected BaseCheckTask next; public BaseCheckTask(BaseCheckTask next) { this.next = next; } public voi
Gradle学习系列（六）：Gradle 源码解析
R.先森的博客
06-10 1736
概述 又开始了一个新的系列，这个系列学习Gradle，目标就是彻底理解Gradle,主要还是做下自己理解的笔记，防止忘记 Gradle系列（一）：Groovy学习 Gradle学习系列（二）：Gradle核心解密 Gradle学习系列（三）：Gradle插件 Gradle学习系列（四）：Gradle依赖 Gradle学习系列（五）：Gradle Transform Gradle学习系列（六）：Gradle 源码解析 Gradle 源码解析 gradlew 首先我们平时打包时用的命令 ./gradlew as
Android Studio Run程序时自动执行自定义task
jingzailongxin的专栏
03-11 5899
android { compileSdkVersion 19 buildToolsVersion "25.0.2" defaultConfig { applicationId "xxxxxxxxxxxxxx" minSdkVersion 8 targetSdkVersion 19 } buildTypes
android 动画原理分析
最新发布
我的专栏
11-20 844
--windowcontainer.applyanimationunchecked -----surfaceanimator.startanimation--(创建leash然后Transaction.reparent(surface,leash))android 动画分为app内的view动画和系统动画。直接来看下系统动画里面的本地动画：app启动动画。动画的触发，动画的加载，动画的启动，动画的关闭。这里大概写下流程，下面有具体的调用堆栈。先来看下app启动时候的动画加载。二 动画执行循环流程。
基于安卓Android的任务管理器源码.zip
10-02
通过深入研究这份源码，你将能掌握Android系统如何管理应用程序的生命周期，理解Activity和Service之间的交互，以及Android是如何根据用户行为和系统状态来调整任务执行的。这对于进行Android毕业设计或者提升开发...
Android图片占用内存全面分析
09-04
本文将全面分析Android图片占用内存的情况，解答关于图片内存占用的疑惑。 首先，我们要理解Android系统中Bitmap对象的工作原理。Bitmap是Android用于存储图像数据的核心类，它代表了图像像素数据。当我们在应用中...
FB面经 Prepare: Task Schedule
weixin_30794851的博客
01-16 254
tasks has cooldown time, give an input task id array, output finish time input: AABCA A--ABCA output:7 1 package fb; 2 3 import java.util.*; 4 5 public class Scheduler { ...
prepareStatement的用法和解释
苇草的博客
03-10 2万+
1.PreparedStatement是预编译的,对于批量处理可以大大提高效率. 也叫JDBC存储过程2.使用 Statement 对象。在对数据库只执行一次性存取的时侯，用 Statement 对象进行处理。PreparedStatement 对象的开销比Statement大，对于一次性操作并不会带来额外的好处。3.statement每次执行sql语句，相关数据库都要执行sql语句的编译，pre...
Android studio Gradle:Executing tasks - 一直卡在Gradle:Build Running
diao_no_why的专栏
04-12 5066
我发现我的老项目也是一直卡在Gradle:Build Running，Gradle:Executing tasks， 尝试了网上的各种方法，皆没用。后面直接关机重启。成功gradle~
android studio的run,Android Studio点击Run背后发生了什么？
weixin_39531688的博客
05-27 969
Android Studio中点击运行按钮(下图中的Run)即可对编写的代码进行编译，打包(生成APK)，安装APK到目标设备，运行APP。1711aa087117413d.jpgbuild按钮：对应的是Make Project，编译Project下所有Module，一般是自上次编译后Project下有更新的文件，不生成apk。Apply Changes按钮：将代码和资源更改推送到正在运行的应用，...
android studio 一直卡在Gradle:Build Running的解决办法
热门推荐
哈怂的博客
09-13 15万+
在使用AS开发安卓应用程序的时候经常会遇到Gradle build running一直在运行甚至卡死的情况，本文列出了几种解决方法以供参考。
android 上传图片 客户端与 服务端 方案总结 （包括获取当前的进度）
user_define_race的专栏
12-03 3105
第一种:        客户端:         package com.hexiaochun; import java.io.ByteArrayOutputStream; import java.io.File; import java.util.ArrayList; import java.util.List; import org.apache.http.HttpEntity; im
rx java android
user_define_race的专栏
06-16 2073
public class MainActivity extends Activity { private Button btn; @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activ
Android隐藏任务栏实现原理与源码分析
### 隐藏任务栏的基本原理 要在Android中隐藏系统状态栏，通常需要修改系统的UI布局参数，通过设置活动（Activity）的窗口标志（Window flags）来实现。在一些特定版本的Android系统中，还可能需要使用特定的API调...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值