学步园

package com.threadpooltest;

import java.util.concurrent.Callable;
import java.util.concurrent.CompletionService;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorCompletionService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.ThreadFactory;

import android.app.Activity;
import android.os.Bundle;
import android.text.format.Formatter;
import android.util.Log;

import com.threadpooltest.util.CommonThreadPoolExector;
import com.threadpooltest.util.CommonThreadPoolFactory;
import com.threadpooltest.util.RunTimeConstant;

public class MainActivity extends Activity {
	
	private static final String  TAG = "ThreadTest";

	@Override
	protected void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		setContentView(R.layout.activity_main);
		
		Log.i(TAG, "CPU "+RunTimeConstant.CURRENT_PROCESSOR_COUNT);
		Log.i(TAG, "avaiable "+Formatter.formatFileSize(this, RunTimeConstant.MEMORY_AVAILABLE));
		Log.i(TAG, "max "+Formatter.formatFileSize(this, RunTimeConstant.MEMORY_MAX));
		Log.i(TAG, "total "+Formatter.formatFileSize(this, RunTimeConstant.MEMORY_TOTAL));
		
		
//		for (int i = 0; i < 10; i++) {
//			//用submit可以有返回值，用execute没有返回值 ,但是，如果你直接提交一个Runable也不会得到想要的返回值，要用Callable
////			CommonThreadPoolFactory.getDefaultExecutor().submit(runnable);
//			Future<String> future = CommonThreadPoolFactory.getDefaultExecutor().submit(callable);
//			try {
//				System.out.println(future.get());
//			} catch (InterruptedException e) {
//				e.printStackTrace();
//			} catch (ExecutionException e) {
//				e.printStackTrace();
//			}
//		}
		
		//上面的想要获得数据只能是同步的，这样非常不好，想要异步获取数据怎么办，线程池去执行任务，一旦有一个执行完就打出一个,
		//那么就使用CompleteService，它限制于数据已知的请示，如果未知也没招。
		CompletionService<String> completionService = new 
				ExecutorCompletionService<String>(new CommonThreadPoolExector(Executors.defaultThreadFactory()));
		for (int i = 0; i < 10; i++) {
			completionService.submit(callable);
		}
		for (int i = 0; i < 10; i++) {
			try {
				System.out.println(completionService.take().get()+" "+i);
			} catch (InterruptedException e) {
				e.printStackTrace();
			} catch (ExecutionException e) {
				e.printStackTrace();
			}
		}
		
		CommonThreadPoolFactory.shutDownAllPools();
		
	}
	
	Callable<String> callable = new Callable<String>() {

		@Override
		public String call() throws Exception {
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			Log.i(TAG, "斑马斑马");
			return "erbai";
		}
	};
	
	Runnable  runnable = new Runnable() {
		
		@Override
		public void run() {
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			Log.i(TAG, "斑马斑马");
		}
	};
	
	@Override
	public void onBackPressed() {
		CommonThreadPoolFactory.shutDownAllPools();
		super.onBackPressed();
	};

}

<pre name="code" class="java">package com.threadpooltest.util;

import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.ThreadFactory;

public class CommonThreadPoolFactory {

	private static volatile ScheduledExecutorService threadPoolExecutor;

	public static final ScheduledExecutorService getDefaultExecutor() {
		if (threadPoolExecutor == null) {
			synchronized (CommonThreadPoolFactory.class) {
				ThreadFactory sThreadFactory = new ThreadFactory() {
					
					@Override
					public Thread newThread(Runnable r) {
						Thread t = new Thread(r);
					    t.setPriority(Thread.MIN_PRIORITY);
						return t;
					}
				};
				threadPoolExecutor = new CommonThreadPoolExector(sThreadFactory);
			}
		}
		return threadPoolExecutor;
	}
	
	public static void shutDownAllPools(){
		if (threadPoolExecutor != null) {
			threadPoolExecutor.shutdown();
			threadPoolExecutor = null;
		}
	}
}

package com.threadpooltest.util;

import java.util.concurrent.RejectedExecutionHandler;
import java.util.concurrent.ScheduledThreadPoolExecutor;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;


public class CommonThreadPoolExector extends ScheduledThreadPoolExecutor {
	
	private static final int CORE_POOL_SIZE = RunTimeConstant.CURRENT_PROCESSOR_COUNT + 1;
	private static final int MAXIMUM_POOL_SIZE = RunTimeConstant.CURRENT_PROCESSOR_COUNT * 2 + 1;
	private static final int KEEP_ALIVE = 1;
	
	private static final RejectedExecutionHandler handler = new RejectedExecutionHandler() {

		@Override
		public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {

		}

	};

	public CommonThreadPoolExector(ThreadFactory threadFactory) {
		super(CORE_POOL_SIZE, threadFactory, handler);
		super.setKeepAliveTime(KEEP_ALIVE, TimeUnit.SECONDS);
		super.setMaximumPoolSize(MAXIMUM_POOL_SIZE);
	}
	
	CommonThreadPoolExector(int corePoolSize, int maxSize,
			int keepAliveSeconds, ThreadFactory threadFactory,
			RejectedExecutionHandler handler) {
		super(corePoolSize, threadFactory, handler);
		super.setKeepAliveTime(keepAliveSeconds, TimeUnit.SECONDS);
		super.setMaximumPoolSize(maxSize);
	}

	
	@Override
	protected void afterExecute(Runnable r, Throwable t) {
		super.afterExecute(r, t);
	}
	
	@Override
	protected void terminated() {
		super.terminated();
	}

}

package com.threadpooltest.util;

public class RunTimeConstant {

	public static final Runtime CURRENT_RUNTIME = Runtime.getRuntime();
	//手机共有几个内核
	public static final int CURRENT_PROCESSOR_COUNT = CURRENT_RUNTIME.availableProcessors();
	
	public static final long MEMORY_AVAILABLE = CURRENT_RUNTIME.freeMemory();
	public static final long MEMORY_MAX =  CURRENT_RUNTIME.maxMemory();
	public static final long MEMORY_TOTAL = CURRENT_RUNTIME.totalMemory();
	
}