192.m1-线程的优化利用线程池启动线程

之前每一次调用show都需要new一个Thread这样做不是很好，现在使用线程池来实现相关的内容，来回创建线程很消耗cpu

使用线程池创建线程BaseFragment.java

package com.ldw.market.fragment;

import com.ldw.market.R;
import com.ldw.market.manager.ThreadManager;
import com.ldw.market.utils.ViewUtils;

import android.os.Bundle;
import android.os.SystemClock;
import android.support.v4.app.Fragment;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.view.View.OnClickListener;
import android.widget.Button;
import android.widget.FrameLayout;
import android.widget.FrameLayout.LayoutParams;

public abstract class BaseFragment extends Fragment {

	//初始化页面加载的5种状态
		public static final int STATE_UNKOWN = 0;
		public static final int STATE_LOADING = 1;
		public static final int STATE_ERROR = 2;
		public static final int STATE_EMPTY = 3;
		public static final int STATE_SUCCESS = 4;
		public int state = STATE_UNKOWN;
		
		private View loadingView;// 加载中的界面
		private View errorView;// 错误界面
		private View emptyView;// 空界面
		private View successView;// 加载成功的界面
		private FrameLayout frameLayout;
		
		//创建一个View对象
		@Override
		public View onCreateView(LayoutInflater inflater, ViewGroup container,
				Bundle savedInstanceState) {
			if(frameLayout == null){
				frameLayout = new FrameLayout(getActivity());
				init(); // 在FrameLayout中 添加4种不同的界面：加载中, 加载错误,加载为空 ,加载成功
			}else{
				ViewUtils.removeParent(frameLayout);
			}
			//show();// 根据服务器的数据 切换状态
			
			return frameLayout;
			
		}
		
		// 在FrameLayout中 添加4种不同的界面：加载中, 加载错误,加载为空 ,加载成功
		private void init() {
			// 创建了加载中的界面
			loadingView = createLoadingView(); 
			if (loadingView != null) {
				frameLayout.addView(loadingView, new FrameLayout.LayoutParams(
						LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT));
			}
			// 加载错误界面
			errorView = createErrorView(); 
			if (errorView != null) {
				frameLayout.addView(errorView, new FrameLayout.LayoutParams(
						LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT));
			}
			// 加载空的界面
			emptyView = createEmptyView(); 
			if (emptyView != null) {
				frameLayout.addView(emptyView, new FrameLayout.LayoutParams(
						LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT));
			}
			// 根据不同的状态显示不同的界面
			showPage();
		}
		

		//根据不同的状态显示不同的界面
		private void showPage(){
			//利用||,显示加载界面
			if (loadingView != null) {
				loadingView.setVisibility(state == STATE_UNKOWN
						|| state == STATE_LOADING ? View.VISIBLE : View.INVISIBLE);
			}
			//利用||,显示错误界面
			if (errorView != null) {
				errorView.setVisibility(state == STATE_ERROR ? View.VISIBLE
						: View.INVISIBLE);
			}
			//利用||,显示空界面
			if (emptyView != null) {
				emptyView.setVisibility(state == STATE_EMPTY ? View.VISIBLE
						: View.INVISIBLE);
			}
			if (state == STATE_SUCCESS) {
				//创建成功的时候加载成功页面
				successView = createSuccessView();
				if (successView != null) {
					frameLayout.addView(successView, new FrameLayout.LayoutParams(
							LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT));
					successView.setVisibility(View.VISIBLE);
				}
			}else{
				//不成功的时候让页面隐藏
				if(successView != null){
					successView.setVisibility(View.INVISIBLE);
				}
			}
		}
		
		//加载成功的界面
		public abstract View createSuccessView();
		
		/* 创建加载中的界面 */
		private View createErrorView() {
			View view = View.inflate(getActivity(), R.layout.loadpage_error, null);
			//点击按钮重新请求服务器更新界面
			Button page_bt = (Button) view.findViewById(R.id.page_bt);
			page_bt.setOnClickListener(new OnClickListener() {

				@Override
				public void onClick(View v) {
					show();
				}
			});
			return view;
		}
		
		/* 加载错误界面 */
		private View createEmptyView() {
			View view = View.inflate(getActivity(), R.layout.loadpage_empty, null);
			return view;
		}
		
		/* 加载空的界面 */
		private View createLoadingView() {
			View view = View.inflate(getActivity(), R.layout.loadpage_loading, null);
			return view;
		}
		
		//更具服务器获取的状态显示界面
		public void show() {
			//更新状态，当加载错误以后或者加载了空页面时候需要更新一下状态
			if (state == STATE_ERROR || state == STATE_EMPTY) {
				state = STATE_LOADING;
			}
			// 请求服务器 获取服务器上数据 进行判断
			// 请求服务器 返回一个结果
			//子线程中请求服务器，同时休眠一下
			//使用线程池管理
			ThreadManager.getInstance().createLongPool().execute(new Runnable(){

				@Override
				public void run() {
					//休眠2s
					SystemClock.sleep(2000);
					final LoadResult result = load();
						//主线程刷新界面
						getActivity().runOnUiThread(new Runnable() {
		
							@Override
							public void run() {
								if(result != null){
									//更新状态
									state = result.getValue();
									//更新界面
									showPage();
								}
							}
						});
					}
				
			});
			showPage();
		}
		
		//服务器返回的数据
		protected abstract LoadResult load();
		
		//服务器返回的枚举结果，来显示界面
		public enum LoadResult{
			error(2), empty(3), success(4);

			int value;
			//获取服务器返回的结果
			LoadResult(int value) {
				this.value = value;
			}

			//获取到value
			public int getValue() {
				return value;
			}

		}
		
		
}

线程池的创建ThreamManager.java

package com.ldw.market.manager;

import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

/*
 * 线程管理，线程池
 */
public class ThreadManager {
	//构造方法
	private ThreadManager() {

	}
	//线程管理者
	private static ThreadManager instance = new ThreadManager();
	private ThreadPoolProxy longPool;
	private ThreadPoolProxy shortPool;
	
	public static ThreadManager getInstance() {
		return instance;
	}
	
	//联网耗时
	//创建一个线程池
	public synchronized ThreadPoolProxy createLongPool(){
		if(longPool == null){
			longPool = new ThreadPoolProxy(5, 5, 5000L);
		}
		return longPool;
		
	}
	
	//创建一个线程池
	public synchronized ThreadPoolProxy createShortPool(){
		if(shortPool == null){
			ThreadPoolProxy shortPool = new ThreadPoolProxy(3, 3, 5000L);
		}
		return shortPool;
		
	}
	
	public class ThreadPoolProxy {
		//java提供的线程池
		private ThreadPoolExecutor pool;
		private int corePoolSize;//线程池中线程的大小
		private int maximumPoolSize;
		private long time;//线程存活的时间

		//构造方法，初始化线程池的大小
		public ThreadPoolProxy(int corePoolSize, int maximumPoolSize, long time) {
			this.corePoolSize = corePoolSize;
			this.maximumPoolSize = maximumPoolSize;
			this.time = time;

		}
		/**
		 * 执行任务
		 * @param runnable
		 */
		public void execute(Runnable runnable) {
			//如果线程池是空的，创建线程池
			if (pool == null) {
				// 创建线程池
				/*
				 * 1. 线程池里面管理多少个线程2. 如果排队满了, 额外的开的线程数3. 如果线程池没有要执行的任务 存活多久4.
				 * 时间的单位 5 如果 线程池里管理的线程都已经用了,剩下的任务 临时存到LinkedBlockingQueue对象中 排队
				 */
				pool = new ThreadPoolExecutor(corePoolSize, maximumPoolSize,
						time, TimeUnit.MILLISECONDS,
						new LinkedBlockingQueue<Runnable>(10));
			}
			// 调用线程池 执行异步任务
			pool.execute(runnable); 
		}
		/**
		 * 取消任务
		 * @param runnable
		 */
		public void cancel(Runnable runnable) {
			//线程池不为空，没有崩溃也没有停止
			if (pool != null && !pool.isShutdown() && !pool.isTerminated()) {
				pool.remove(runnable); // 取消异步任务
			}
		}
	}
}