android 网络访线程池问题！handler looper

          我就是创建了一个线程池，每次网络请求，都要走这个线程池，方便管理维护，然后让handler，发送数据到主线程，但是当线程池的数量达到指定值时

，就没有办法访问，网络数据了（致使我的网络访问框架不能用了）！

   原因我也没查，可能就是 looper 或者 handler  占住线程不放了，致使线程在使用后不销毁，很快线程池装满，不再执行网络请求！

 解决办法：

 如果不用线程池，每次开启一个线程就没事了！ 

 但是这样会浪费资源的，每次都创建线程！

  如果有高人 请指条明道！！感谢，再感谢！！

附加我的代码 ：

/public class HTTPClientService {
 private static Map<String, Class<?>> actMap = new HashMap<String, Class<?>>();
 private static Map<String, BaseAction> actInsMap = new HashMap<String, BaseAction>();
 /** 线程池维护线程的最少数量 **/
 private static int corePoolSize = 50;
 /** 程池维护线程的最大数量 **/
 private static int maxPoolSize = 100;
 /** 线程池维护线程所允许的空闲时间　 **/
 private static int threadKeepAliveTime = 60;
 private static ThreadPoolExecutor threadPool = null;
 // 初始化命令
 static {
  // login
  actMap.put(ActTypeConst.ACTTYPE_LOGIN, LoginAction.class);
  // add
  actMap.put(NewsConst.CMD_ADD_NEWS, PublishAction.class);
  // search
  actMap.put(NewsConst.CMD_SEARCH_NEWS, SearchAction.class);
  threadPool = new ThreadPoolExecutor(corePoolSize, maxPoolSize,
    threadKeepAliveTime, TimeUnit.SECONDS,
    new LinkedBlockingQueue<Runnable>());
 }

 /**
  * 执行网络请求
  *
  * @param msg
  *            请求消息类型
  * @param cmd
  *            请求命令
  * @param params
  *            参数成對出現
  */
 public static void sendAction(Object... params) {
  Log.e("[HttpCilentService].sendAction", "--------------");
  Hashtable<String, Object> tableHashtable = new Hashtable<String, Object>();
  for (int i = 0; i < params.length; i += 2) {
   tableHashtable.put((String) params[i], params[i + 1]);
  }
  //threadPool.execute(new RequestHandlerRunner(tableHashtable));
  new Thread(new RequestHandlerRunner(tableHashtable)).start();
 }

 public static void sendAction(Hashtable<String, Object> table) {
  //threadPool.execute(new RequestHandlerRunner(table));
  new Thread(new RequestHandlerRunner(table)).start();
 }

 public static void AddCookiedCookie(String key, String val) {
  GetPostNet.AddCookie(key, val);
 }

 // 消息线程类 网络交互
 private static final class RequestHandlerRunner implements Runnable {
  private Hashtable<String, Object> requestHandleParam = null;

  public RequestHandlerRunner(Hashtable<String, Object> requestHandleParam) {
   this.requestHandleParam = requestHandleParam;
  }

  public void run() {
   Looper.prepare();
   Log.e("[HttpCilentService].RequestHandlerRunner", "--------------");

   HTTPClientService.sendMsg(requestHandleParam);
   Looper.loop();
  }
 }

 // 开始线程池 执行网络请求
 private static void sendMsg(Hashtable<String, Object> val) {
  Context context = null;
  String uri = null;
  // 过滤掉 服务器不需要的参数
  if (null != val.get(ConstantUtil.CURRENT_CONTEXT)) {
   context = (Context) val.get(ConstantUtil.CURRENT_CONTEXT);
   val.remove(ConstantUtil.CURRENT_CONTEXT);
  }
  if (null != val.get(BaseConst.URI_MSG)) {
   uri = (String) val.get(BaseConst.URI_MSG);
   val.remove(BaseConst.URI_MSG);
  }

  // 发送网络请求
  String retString = GetPostNet.sendPost(uri, val);
  Log.e("[HttpClientManager].sendMsg----------:", retString.toString());
  // 重新添加 环境参数
  if (null != context) {
   val.put(ConstantUtil.CURRENT_CONTEXT, context);
  }
  RetDispatchMsg(val, retString);
 }

 /** 回归主线程 **/
 public static void RetDispatchMsg(Hashtable<String, Object> send, String ret) {
  Hashtable<String, Object> table = new Hashtable<String, Object>();
  table.put(BaseConst.SEND_PARAM, send);
  table.put(BaseConst.RECV_PARAM, ret);
  Message msg = new Message();
  msg.obj = table;
  msg.what = 1;

  ToolUtil.getMsgHandler().dispatchMessage(msg);
 }

 /** 主线程 处理返回结果 **/
 public static void exeAction(Hashtable<String, Object> param) {
  try {
   // 得到返回的数据
   String back_datas = (String) param.get(BaseConst.RECV_PARAM);
   // 自己发送的请求的参数
   Hashtable<String, Object> send = (Hashtable<String, Object>) param
     .get(BaseConst.SEND_PARAM);
   JSONObject json = new JSONObject(back_datas);
   json.put(BaseConst.SEND_PARAM, send);
   // 得到Action指令的参数
   String retMsg = (String) send.get(BaseConst.CMD);
   System.out.println("[HTTPClientManager.exeAction()_msg:" + retMsg);
   BaseAction insAction = null;
   // 检索参数请求
   if (actInsMap.containsKey(retMsg)) {
    insAction = actInsMap.get(retMsg);
    insAction.doProcess(json);
   } else {
    // 添加新的参数请求
    Class<?> cls = actMap.get(retMsg);
    insAction = (BaseAction) cls.newInstance();
    actInsMap.put(retMsg, insAction);
    insAction.doProcess(json);
   }
  } catch (JSONException e) {
   e.printStackTrace();
  } catch (InstantiationException e) {
   e.printStackTrace();
  } catch (IllegalAccessException e) {
   e.printStackTrace();
  }
 }
}