android 网络应用轻量框架

最新推荐文章于 2024-05-30 17:23:06 发布

小林爱

最新推荐文章于 2024-05-30 17:23:06 发布

阅读量2.6k

点赞数

分类专栏： android 文章标签： android Android 多线程框架网络设计模式

本文链接：https://blog.csdn.net/b275518834/article/details/8247685

版权

android 专栏收录该内容

35 篇文章 0 订阅

订阅专栏

框架代码下载地址：Demo代码下载

关于框架有意见欢迎联系我一起探讨。

联系方式我的QQ是275518834 问答是happy

操作方式：输入文本框设置线程数
点击第一个按钮请求10个地址信息
点击第二个按钮中断10个地址信息

1：判断当前网络环境

2：编写了3套方案
Old_GridViewActivity 简单线程回调
AsyncTask_GridViewActivity 使用android自带的AsyncTask类实现
Demo_GridViewActivity 队列任务管理线程控制

1：队列优先级（如果想要listview中移动的区域优先被显示，而不是从上到下显示图片，可以把新建的任务提到任务队列前端）

2：实现了：中断任务的功能（比如进入一个Activity会开启大量任务，如果退出这个Activity 则应该停止此Activity中驻留的任务）

3：为何采用drawable不用bitmap
bitmap优点是位图运算效率优秀
但drawable的存储体积比bitmap小

4：如果任务被起名字则禁止重复提交任务（避免某些请求未处理完又被创建）

5：先执行缓存数据后执行请求数据（缓存性能）

6：使用状态模式观察者模式更好的处理多线程

最初的想法：网络优化开发框架 (移除任务未完成）
网络稳定，系统运行稳定性，大内存消耗稳定，长时间运行稳定性

（旧的系统症结所在）
开启过多线程，导致系统频繁切换多个线程，导致处理速度过慢，经常出现未响应。
代码经常写的换繁多无序，维护困难。

使用类似银行叫号系统
线程池内等待网络请求的任务=（排队的人）
最大三个线程=（银行柜台处理业务的窗口）
依次处理任务=（将排队的人依次被叫到处理的号，完成业务的窗口叫号后面排队的人）
如果抛出异常则通知相关单位=（如果银行柜台处理不了一个人的业务就打电话给大堂经理）
设置柜台的监听回调=（A委托B去银行请求数据，当B去银行处理业务失败了，通知A。）
设置撤销机制和线程安全=
某机关让A和B去银行申请业务，A在排队，B正在柜台处理业务，此时机关打来电话说，
这申请业务的需求现在不做，A取消排队,B也‘礼貌的退出’
《例如退出A页面时，终止A页面所有的请求》

任务状态标示-还没处理处理中处理结束处理异常（有结果但不通知）=（排队人的状态）
任务名排队人的名字
强制退出

强制退出抛出强制退出的异常

package lxz.utils.android.network;

import java.util.HashMap;
import java.util.HashSet;
import java.util.Observable;
import java.util.Observer;

import android.content.Context;
import android.os.Handler;

public abstract class Task implements Runnable, Observer {
	String debug = getClass().getSimpleName();

	// 名字映射
	private static HashMap<String, Task> nameTasks = new HashMap<String, Task>();

	public static HashMap<String, Task> getNameTask() {
		return nameTasks;

	}

	public void setSingletonName(String singletonName) {
		this.singletonName = singletonName;
	}

	public String getSingletonName() {
		return singletonName;
	}

	public interface OnStartListen {
		void onStart(int taskID);
	}

	public interface OnProgressListen {
		void onProgress(int taskID, int progress);
	}

	public interface OnFinishListen {
		Boolean OnFinish(int taskID, Object data);
	}

	public interface OnSystemStartListen {
		void onSystemStart(int taskID);
	}

	public interface OnSystemFinishListen {
		Boolean OnSystemFinish(int taskID, Object data, Task t);
	}

	/** 请求参数 */
	protected Object parameter;
	/** 任务开始监听 */
	protected OnStartListen onStartListen;
	/** 任务进度监听 */
	protected OnProgressListen onProgressListen;
	/** 任务完成监听 */
	protected OnFinishListen onFinishListen;
	/** 任务在队列中完成 监听 */
	protected OnSystemStartListen onSystemStartListen;
	/** 任务在队列中开始 监听 */
	protected OnSystemFinishListen onSystemFinishListen;
	/** 用于任务完成后发送消息 */
	protected Handler handler;
	/** 结果 */
	protected Object result;
	/** 任务编号标示 */
	protected int taskID;
	/** 任务名字标示 */
	/** 设置此任务名是否为单例，单例模式下，如果相同名字的任务未执行完，则无法添加新任务 */
	protected String singletonName;

	/** 保存一个对象 */
	protected Object tag;
	/** 获得当前自身线程的引用 在threadRun方法 */
	protected Thread thread;
	/** 重连次数 */
	protected int tryAgainCount = 1;
	/** 重连间隔 */
	protected int tryAgainTime = 1000;
	/** 视图绑定 */
	protected TaskViewHolder taskViewHolder;

	/** 任务观察者 */
	protected TaskObservable taskObservable;

	protected Context context;

	protected Task() {
	}

	protected Task(TaskViewHolder taskViewHolder) {
		super();
		this.taskViewHolder = taskViewHolder;
		this.handler = taskViewHolder.getActivityHandler();
		this.taskViewHolder.getTaskObservable().addObserver(this);
		this.context = taskViewHolder.getContext();
		this.taskObservable = this.taskViewHolder.getTaskObservable();
	}

	protected Task(TaskObservable taskObservable) {
		super();
		taskObservable.addObserver(this);
	}

	public TaskViewHolder getTaskViewHolder() {
		return taskViewHolder;
	}

	public void setTaskViewHolder(TaskViewHolder taskViewHolder) {
		this.taskViewHolder = taskViewHolder;
	}

	/** 状态 */
	int status = UNTREATED;

	final static int ERROR = -1;
	final static int UNTREATED = 0;
	final static int FINSH = 1;
	final static int TREATEDING = 2;

	// 不处理
	final static int WITHOUT = 3;

	/** 启动线程 */
	public void threadRun() {
		thread = new Thread(this);
		thread.start();
	}

	// 中断Execute方法
	public abstract void shutDownExecute();

	public abstract Object cacheData(Object parameter);

	// 禁止被重写
	public final Object Execute() throws Exception {
		// TODO Auto-generated method stub
		if (onStartListen != null)
			onStartListen.onStart(taskID);

		// 队列中回调
		if (onSystemStartListen != null)
			onSystemStartListen.onSystemStart(taskID);
		// 状态从未处理改变为处理中
		status = TREATEDING;

		// 是否有缓存数据如果没有
		if ((result = cacheData(parameter)) == null) {

			// 失败重联次数
			for (int i = 0; i < tryAgainCount; i++) {
				try {
					result = obtainData(result, parameter);
					break;
				} catch (Exception e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
					try {
						Thread.sleep(tryAgainTime);
					} catch (Exception e1) {
						// TODO Auto-generated catch block
						e1.printStackTrace();
					}
				}
			}
		}
      
		// 如果状态改变为处理完但不通知
		if (status != WITHOUT) {

			if (handler != null) {
				handler.obtainMessage(taskID, result).sendToTarget();
			}
			if (onFinishListen != null) {
				onFinishListen.OnFinish(taskID, result);
			}
		}
		  if (onSystemFinishListen != null) {
				onSystemFinishListen.OnSystemFinish(taskID, result, this);
			}

		status = FINSH;
		return result;
	}

	public int getTryAgainCount() {
		return tryAgainCount;
	}

	public void setTryAgainCount(int tryAgainCount) {
		this.tryAgainCount = tryAgainCount;
	}

	public int getTryAgainTime() {
		return tryAgainTime;
	}

	public void setTryAgainTime(int tryAgainTime) {
		this.tryAgainTime = tryAgainTime;
	}

	public abstract Object obtainData(Object result, Object parameter)
			throws Exception;

	@Override
	public void update(Observable observable, Object data) {
		// 移除观察
		observable.deleteObserver(this);
		// 中断 停止关闭连接
		this.shutDownExecute();
		this.setWithout();
		if (this.thread != null) {
			this.thread.interrupt();
		}
		// 错误尝试次数为0
		this.tryAgainCount = 0;
	};

	@Override
	public void run() {

		try {
			Execute();
		} catch (Exception e) {
			taskID = ERROR;

			// 如果状态改变为处理完但不通知
			if (status != WITHOUT) {
				if (handler != null) {
					handler.obtainMessage(taskID, e).sendToTarget();
				}
				if (onFinishListen != null) {
					onFinishListen.OnFinish(taskID, e);
				}
			}
			if (onSystemFinishListen != null) {
				onSystemFinishListen.OnSystemFinish(taskID, e, this);
			}
		}

	}

	public void setWithout() {
		this.status = WITHOUT;
	}

	public Object getTag() {
		return tag;
	}

	public void setTag(Object tag) {
		this.tag = tag;
	}

	public Thread getThread() {
		return thread;
	}

	public int getStatus() {
		return status;
	}

	public void setStatus(int status) {
		this.status = status;
	}

	public Object getParameter() {
		return parameter;
	}

	public void setParameter(Object parameter) {
		this.parameter = parameter;
	}

	public OnStartListen getOnStartListen() {
		return onStartListen;
	}

	public void setOnStartListen(OnStartListen onStartListen) {
		this.onStartListen = onStartListen;
	}

	public OnProgressListen getOnProgressListen() {
		return onProgressListen;
	}

	public void setOnProgressListen(OnProgressListen onProgressListen) {
		this.onProgressListen = onProgressListen;
	}

	public OnFinishListen getOnFinishListen() {
		return onFinishListen;
	}

	public void setOnFinishListen(OnFinishListen onFinishListen) {
		this.onFinishListen = onFinishListen;
	}

	public OnSystemStartListen getOnSystemStartListen() {
		return onSystemStartListen;
	}

	public OnSystemFinishListen getOnSystemFinishListen() {
		return onSystemFinishListen;
	}

	public void setOnSystemFinishListen(
			OnSystemFinishListen onSystemFinishListen) {
		this.onSystemFinishListen = onSystemFinishListen;
	}

	public Handler getHandler() {
		return handler;
	}

	public void setHandler(Handler handler) {
		this.handler = handler;
	}

	public int getTaskID() {
		return taskID;
	}

	public void setTaskID(int taskID) {
		this.taskID = taskID;
	}

	public Object getResult() {
		return result;
	}

	public void setResult(Object result) {
		this.result = result;
	}

	public void cacheClear() {
		if(parameter!=null)parameter=null;
		if(onStartListen!=null)onStartListen=null;
		if(onProgressListen!=null)onProgressListen=null;
		if(onFinishListen!=null)onFinishListen=null;
		if(onSystemStartListen!=null)onSystemStartListen=null;
		if(onSystemFinishListen!=null)onSystemFinishListen=null;
		if(handler!=null)handler=null;
		if(result!=null)result=null;
		if(singletonName!=null)singletonName=null;
		if(tag!=null)tag=null;
		if(thread!=null)thread=null;
		if(taskViewHolder!=null)taskViewHolder=null;
		if(taskObservable!=null)taskObservable=null;
		if(context!=null)context=null;
	}

}

package lxz.utils.android.network;

import java.util.ArrayList;
import java.util.LinkedList;

import android.util.Log;

import lxz.utils.android.network.Task.OnSystemFinishListen;



public class TaskQueue implements Runnable, OnSystemFinishListen {
	static String debug = "TaskQueue";
	@SuppressWarnings("unchecked")
	// 在等待的任务队列
	static LinkedList<Task> tasks_wait = new LinkedList<Task>();
	// 正在执行的任务
	static ArrayList<Task> tasks_running = new ArrayList<Task>();
	// 是否持续运行
	public static boolean isRun;
	// 队列线程
	private static Thread taskQueueThread;
	// runnable保证线程安全
	private static TaskQueue runnable = new TaskQueue();;
	// 最大线程数
	static int ThreadMaxNum = 1;

	// 如果队列线程为空或者停止则重新开启
	public static void serivesRun() {
		// TODO Auto-generated method stub

		if (taskQueueThread == null
				|| (taskQueueThread != null && taskQueueThread.getState() == Thread.State.TERMINATED)) {
			taskQueueThread = new Thread(runnable);
			// taskQueueThread.setPriority(Thread.MAX_PRIORITY);
			taskQueueThread.start();

		}
	}

	// 线程锁 如果等待队列的任务数不为空，并且当前线程数字少于最大线程数
	public static boolean taskRun() {
		synchronized (tasks_wait) {
			synchronized (tasks_running) {
				return !tasks_wait.isEmpty()
						&& tasks_running.size() < ThreadMaxNum;
			}
		}
	}

	public void run() {
		// 线程锁 如果等待队列的任务数不为空，并且当前线程数字少于最大线程数
	
		while (taskRun()) {
			// 添加带执行中动态数组中
			Task h;
			synchronized (tasks_wait) {
				// 从等待任务的队列中获取并移除此列表的头（第一个元素）
				h = tasks_wait.poll();

				// 如果h为空则从队列重新取对象或者任务绑定的状态变化了
				if (h == null || h.status == Task.WITHOUT) {
					Log.i(debug , "任务取消 编号" + h.getTaskID());
      		        //移除此名字映射
		             if(h.getSingletonName()!=null)
		             {
		            	 Task.getNameTask().remove(h.getSingletonName());
		             }
					
					continue;
				}
				synchronized (tasks_running) {
					tasks_running.add(h);
				}
					 Log.i(debug , "正在执行任务数"
				 + tasks_running.size()+ "/上限" + ThreadMaxNum);


				// 为h设置完成或者报错进行监听
				h.setOnSystemFinishListen(runnable);
				// 启动此线程
				
			}
                h.threadRun();
		}

	}

	@Override
	public Boolean OnSystemFinish(int taskID, Object data, Task t) {
		// TODO Auto-generated method stub
		synchronized (tasks_running) {
			// 从处理中的动态数组中移除此任务
			tasks_running.remove(t);
			Log.i(debug,"执行队列中移除任务taskid=" + t.taskID);
			// 通知执行后续未处理的任务
			 Log.i(debug , "正在执行任务数"
					 + tasks_running.size()+ "/上限" + ThreadMaxNum);
			 
			 //移除此名字映射
             if(t.getSingletonName()!=null)
             {
            	 Task.getNameTask().remove(t.getSingletonName());
             }
		}
		runnable.run();
		synchronized (tasks_wait) {

			// 如果等待队列中的任务
			if (tasks_wait.isEmpty())
				taskQueueThread = null;
		}
		t.cacheClear();
		return true;
	}	
}
框架代码下载地址：Demo代码下载