转载注明出处 ：http://blog.csdn.net/codingandroid/article/details/41748743
作为1个框架，肯定要去处理1些比较复杂的情况，正常情况下固然不会阻塞，当情况比较复杂的时候，会出现前多个网络要求的情况，那对这类情况我们规范去管应当然是最好的了，因而我们需要1个线程池。
首先解释1下，甚么叫线程池 ：
每当启动1个线程的时候，我们通常代码是 new Thead(){}.start(); new 1个对象 里面又要new1个runnable 这个是相对照较耗时的，资源我们能省就省，这个线程池就相当与说：我保护1个池子，例如里面放5个现成的线程，要求来了也不用重新去new 直接就可以使用，超过5个的时候需要等待1下 对android的开发的来讲 就类似于 soundpool吧
理解这个就好，代码没几行，放上来哦
package com.clxu.netframe.abstractinterface;
import java.util.concurrent.AbstractExecutorService;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
/***
* @function 线程池
* @author CLXU
*
* 2014⑴1⑵5
*/
public class DefaultThreadPool {
/**
* 用于保存等待履行的任务的阻塞队列。(有序的先进先出阻塞队列)
*/
private static ArrayBlockingQueue<Runnable> mBlockingQueue = new ArrayBlockingQueue<Runnable>(15, true);
/**
* 线程池
*/
private static AbstractExecutorService mThreadPoolExecutor
= new ThreadPoolExecutor(5, 7, 25, TimeUnit.SECONDS, mBlockingQueue,
new ThreadPoolExecutor.DiscardOldestPolicy());
private static DefaultThreadPool instance = null;
public static DefaultThreadPool getInstance() {
if (instance == null) {
instance = new DefaultThreadPool();
}
return instance;
}
/**
* 履行任务
* @param r
*/
public void execute(Runnable r) {
mThreadPoolExecutor.execute(r);
}
/**
* 关闭，并等待任务履行完成，不接受新任务
*/
public static void shutdown() {
if (mThreadPoolExecutor != null) {
mThreadPoolExecutor.shutdown();
}
}
/**
* 关闭，立即关闭，并挂起所有正在履行的线程，不接受新任务
*/
public static void shutdownRightnow() {
if (mThreadPoolExecutor != null) {
mThreadPoolExecutor.shutdownNow();
try {
// 设置超时极短，强迫关闭所有任务
mThreadPoolExecutor.awaitTermination(1, TimeUnit.MICROSECONDS);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
上1篇中使用的时候有1句代码 mDefaultThreadPool.execute(asyncBaseRequest);那就是线程池了，不过下面那个是甚么呢？
mAsyncRequests.add(asyncBaseRequest);这行的代码的作用是 保护当前的 activity的所有的要求，当前页面关闭的时候，方便结束掉所有的要求
这里面有触及1个基本的要求类 AsyncBaseRequest 这个类，这个是个要求的基类，在里面我们设定网络要求的各个流程，和对异常的处理
package com.clxu.netframe.abstractinterface;
import java.io.IOException;
import java.io.Serializable;
import java.net.HttpURLConnection;
import java.net.SocketTimeoutException;
import java.util.Map;
import java.util.concurrent.TimeoutException;
import org.apache.http.conn.ConnectTimeoutException;
import org.apache.http.conn.HttpHostConnectException;
import com.clxu.netframe.R;
import com.clxu.netframe.constant.Constant;
import com.clxu.netframe.exception.MyException;
import com.clxu.netframe.net.callback.ParseCallback;
import com.clxu.netframe.net.callback.ResultCallback;
import com.clxu.netframe.util.LogUtil;
/**
* 功能描写：网络要求线程基类
* @author clxu
* 创建日期：2014⑴2⑷
*/
public abstract class AsyncBaseRequest implements Runnable, Serializable {
private static final long serialVersionUID = 1L;
/** LOG打印标签*/
private static final String TAG = "AsyncBaseRequest";
/** 网络连接超时，默许值为10秒*/
protected int connectTimeout = 10 * 1000;
/** 网络数据读取超时，默许值为10秒*/
protected int readTimeout = 10* 1000;
private boolean interrupted;
public boolean isInterrupted() {
return interrupted;
}
public void setInterrupted(boolean interrupted) {
this.interrupted = interrupted;
}
protected void setConnectTimeout(int connectTimeout) {
this.connectTimeout = connectTimeout;
}
protected void setReadTimeout(int readTimeout) {
this.readTimeout = readTimeout;
}
protected String requestUrl;
protected Map<String, String> parameter;
private ParseCallback parseHandler;
private ResultCallback requestCallback;
protected HttpURLConnection mHttpURLConn;
protected String mInStream;
private MyException ex;
public AsyncBaseRequest(String url, Map<String, String> parameter, ParseCallback handler, ResultCallback requestCallback) {
this.parseHandler = handler;
this.requestUrl = url;
this.parameter = parameter;
this.requestCallback = requestCallback;
}
/**
* 发送网络要求
* @return 网络要求返回的InputStream数据流
* @throws Exception
*/
protected abstract String getRequestResult() throws Exception;
@Override
public void run() {
if (interrupted) {
LogUtil.i(TAG, "访问网络前中断业务处理线程(终止)");
return;
}
try {
//访问网络，获得到返回数据
mInStream = getRequestResult();
if (mInStream != null) {
Object obj = null;
if(parseHandler != null){
//回调 数据解析接口
obj = parseHandler.parse(mInStream);
}
if(requestCallback!=null){
requestCallback.onSuccess(obj);
}
} else {
LogUtil.e(TAG, "get InputStream By HttpURLConnection return result is NULL.");
ex = new MyException(R.string.network_request_fail, Constant.NETWORK_REQUEST_RETUN_NULL, R.string.network_request_return_null);
requestCallback.onFail(ex); // 网络要求返回NULL
}
}catch(SocketTimeoutException e){
//SocketTimeoutException 这个超时异常是说明要求已到达
服务器，返回数据进程中超时了，如果是定单类的要求要注意了，需要避免重复提交
ex = new MyException(e);
requestCallback.onFail(ex);
}catch(ConnectTimeoutException e){
//ConnectTimeoutException 这个是连接异常（例如根本没有打开网络等情况下），数据还没有到达
服务器，所以就算是定单类的也没有关系，可以再次提交
ex = new MyException(e);
requestCallback.onFail(ex);
}catch (TimeoutException e) {
//TimeoutException 这个是总的超时异常，这里还是捕捉1下
ex = new MyException(e);
requestCallback.onFail(ex); // IO异常标识
}catch (HttpHostConnectException e) {
//HttpHostConnectException 出现这个异常，检查程序是不是添加网络权限
ex = new MyException(e);
requestCallback.onFail(ex);
}catch (IOException e) {
ex = new MyException(e);
requestCallback.onFail(ex); // IO异常标识
} catch (Exception e) {
ex = new MyException(e);
requestCallback.onFail(ex); // 未知异常标识
}
}
public HttpURLConnection getRequestConn() {
return mHttpURLConn;
}
}
固然，需要两个接口
package com.clxu.netframe.net.callback;
import org.json.JSONException;
/***
* @function 网络要求返回的数据解析接口
* @author CLXU
* 2014⑴1⑵5
*/
public interface ParseCallback {
/**
* 对网络要求返回的数据进行解析
* @param json 要解析的字符串，JSON格式
* @return 解析的结果
* @throws JSONException JSON异常（普通字符串转换成JSON字符串时，格式出错会抛此异常）
*/
public Object parse(String json) throws JSONException;
}
package com.clxu.netframe.net.callback;
import com.clxu.netframe.exception.MyException;
/**
* 功能描写：网络要求返回的结果回调接口
* <span style="font-family: Arial, Helvetica, sans-serif;">@author CLXU</span>
* 创建日期：2014⑴1⑴9
*/
public interface ResultCallback {
public void onSuccess(Object obj);
public void onFail(MyException e);
}
框架源码下载地址：http://download.csdn.net/detail/brightshadow11111/8228287