直奔主题
首先我们来看看Java的线程通讯基础
//产品
static class ProductObject{
//线程操作变量可见
public volatile static String value;
}
//生产者线程
static class Producer extends Thread{
Object lock;
public Producer(Object lock) {
this.lock = lock;
}
@Override
public void run() {
//不断生产产品
while(true){
synchronized (lock) { //互斥锁
//产品还没有被消费，等待
if(ProductObject.value != null){
try {
lock.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
//产品已经消费完成，生产新的产品
ProductObject.value = "NO:"+System.currentTimeMillis();
Log.i(TAG,"生产产品："+ProductObject.value);
lock.notify(); //生产完成，通知消费者消费
}
}
}
}
//消费者线程
static class Consumer extends Thread{
Object lock;
public Consumer(Object lock) {
this.lock = lock;
}
@Override
public void run() {
while(true){
synchronized (lock) {
//没有产品可以消费
if(ProductObject.value == null){
//等待，阻塞
try {
lock.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
Log.i(TAG,"消费产品："+ProductObject.value);
ProductObject.value = null;
lock.notify(); //消费完成，通知生产者，继续生产
}
}
}
}
复制代码调用:
Object lock = new Object();
new Producer(lock).start();
new Consumer(lock).start();
复制代码Log:
这是一些简单的线程通讯基础，两个线程进行交互的用法。
接下来分析一下 Java中的FutureTask
我们先来看看类图
//异步任务
static class Task implements Callable<Integer> {
//返回异步任务的执行结果
@Override
public Integer call() throws Exception {
int i = 0;
for (; i < 10; i++) {
try {
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
Log.i(TAG, Thread.currentThread().getName() + "_" + i);
}
return i;
}
}
复制代码初始化执行
Task work = new Task();
FutureTask<Integer> future = new FutureTask<Integer>(work) {
//异步任务执行完成，回调
@Override
protected void done() {
try {
Log.i(TAG, "done:" + get());
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
}
};
//线程池（使用了预定义的配置）
ExecutorService executor = Executors.newCachedThreadPool();
executor.execute(future);
try {
Thread.sleep(1000);
} catch (InterruptedException e1) {
e1.printStackTrace();
}
//取消异步任务
// future.cancel(true);
try {
//阻塞，等待异步任务执行完毕
Log.i(TAG, "" + future.get());
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
复制代码Log：
Future
package java.util.concurrent;
public interface Future<V> {
boolean cancel(boolean mayInterruptIfRunning);
boolean isCancelled();
boolean isDone();
V get() throws InterruptedException, ExecutionException;
V get(long timeout, TimeUnit unit)
throws InterruptedException, ExecutionException, TimeoutException;
}
复制代码Runnable
package java.lang;
public interface Runnable {
public abstract void run();
}
复制代码RunnableFuture
package java.util.concurrent;
public interface RunnableFuture<V> extends Runnable, Future<V> {
void run();
}
复制代码FutureTask
package java.util.concurrent;
import java.util.concurrent.locks.LockSupport;
public class FutureTask<V> implements RunnableFuture<V> {
......以下只截取部分代码
/** The underlying callable; nulled out after running */
private Callable<V> callable;
/** The thread running the callable; CASed during run() */
private volatile Thread runner;
public FutureTask(Callable<V> callable) {
if (callable == null)
throw new NullPointerException();
this.callable = callable;
this.state = NEW; // ensure visibility of callable
}
public boolean cancel(boolean mayInterruptIfRunning) {
if (!(state == NEW &&
U.compareAndSwapInt(this, STATE, NEW,
mayInterruptIfRunning ? INTERRUPTING : CANCELLED)))
return false;
try { // in case call to interrupt throws exception
if (mayInterruptIfRunning) {
try {
Thread t = runner;
if (t != null)
t.interrupt();
} finally { // final state
U.putOrderedInt(this, STATE, INTERRUPTED);
}
}
} finally {
finishCompletion();
}
return true;
}
/**
* @throws CancellationException {@inheritDoc}
*/
public V get() throws InterruptedException, ExecutionException {
int s = state;
if (s <= COMPLETING)
s = awaitDone(false, 0L);
return report(s);
}
protected void done() { }
protected void set(V v) {
if (U.compareAndSwapInt(this, STATE, NEW, COMPLETING)) {
outcome = v;
U.putOrderedInt(this, STATE, NORMAL); // final state
finishCompletion();
}
}
protected void setException(Throwable t) {
if (U.compareAndSwapInt(this, STATE, NEW, COMPLETING)) {
outcome = t;
U.putOrderedInt(this, STATE, EXCEPTIONAL); // final state
finishCompletion();
}
}
public void run() {
if (state != NEW ||
!U.compareAndSwapObject(this, RUNNER, null, Thread.currentThread()))
return;
try {
Callable<V> c = callable;
if (c != null && state == NEW) {
V result;
boolean ran;
try {
result = c.call();
ran = true;
} catch (Throwable ex) {
result = null;
ran = false;
setException(ex);
}
if (ran)
set(result);
}
} finally {
// runner must be non-null until state is settled to
// prevent concurrent calls to run()
runner = null;
// state must be re-read after nulling runner to prevent
// leaked interrupts
int s = state;
if (s >= INTERRUPTING)
handlePossibleCancellationInterrupt(s);
}
}
private void finishCompletion() {
// assert state > COMPLETING;
for (WaitNode q; (q = waiters) != null;) {
if (U.compareAndSwapObject(this, WAITERS, q, null)) {
for (;;) {
Thread t = q.thread;
if (t != null) {
q.thread = null;
LockSupport.unpark(t);
}
WaitNode next = q.next;
if (next == null)
break;
q.next = null; // unlink to help gc
q = next;
}
break;
}
}
done();
callable = null; // to reduce footprint
}
......以上只截取部分代码
}
复制代码从上面代码可以看出
Java FutureTask 异步任务操作提供了便利性
1.获取异步任务的返回值--> V get()
2.监听异步任务的执行完毕-->finishCompletion()-->done()
3.取消异步任务-->cancel(boolean mayInterruptIfRunning)
从上面的例子，我们可以看到Executors去调用这个Future那么这个Executors又是啥玩意呢？！
像刚才看Future那样我们点进去看看这个Executors我们可以发现很多东西，然而，其实这个就是鼎鼎大名的 线程池 ！ 我们还是先看看类图
因为实现类方法太多了，还是直接看api文档比较好。
一个任务
static class MyTask implements Runnable {
int i;
public MyTask(int i) {
this.i = i;
}
@Override
public void run() {
Log.i(TAG, Thread.currentThread().getName() + ";i:" + i);
}
}
复制代码初始化-->运行线程池
int CPU_COUNT = Runtime.getRuntime().availableProcessors(); //可用的CPU个数
Log.i(TAG, "CPU_COUNT-->" + CPU_COUNT);
int CORE_POOL_SIZE = CPU_COUNT + 1; //5(corePoolSize - 池中所保存的线程数，包括空闲线程。)
Log.i(TAG, "CORE_POOL_SIZE-->" + CORE_POOL_SIZE);
int MAXIMUM_POOL_SIZE = CPU_COUNT * 2 + 1; //9(maximumPoolSize - 池中允许的最大线程数。)
Log.i(TAG, "MAXIMUM_POOL_SIZE-->" + MAXIMUM_POOL_SIZE);
int KEEP_ALIVE = 1;//(keepAliveTime - 当线程数大于核心时，此为终止前多余的空闲线程等待新任务的最长时间。)
//任务队列（128）(workQueue - 执行前用于保持任务的队列。此队列仅由保持 execute 方法提交的 Runnable 任务。)
final BlockingQueue<Runnable> sPoolWorkQueue = new LinkedBlockingQueue<Runnable>(128);
//线程工厂(threadFactory - 执行程序创建新线程时使用的工厂。)
ThreadFactory sThreadFactory = new ThreadFactory() {
private final AtomicInteger mCount = new AtomicInteger(1);
public Thread newThread(Runnable r) {
String name = "Thread #" + mCount.getAndIncrement();
Log.i(TAG, "newThread-->" + name);
return new Thread(r, name);
}
};
//线程池
Executor THREAD_POOL_EXECUTOR = new ThreadPoolExecutor(CORE_POOL_SIZE, MAXIMUM_POOL_SIZE, KEEP_ALIVE,
//(unit - keepAliveTime 参数的时间单位。)
TimeUnit.SECONDS, sPoolWorkQueue, sThreadFactory);
/* 如果运行的线程少于 corePoolSize，则 Executor 始终首选添加新的线程，而不进行排队。
如果运行的线程等于或多于 corePoolSize，则 Executor 始终首选将请求加入队列，而不添加新的线程。
如果无法将请求加入队列，则创建新的线程，除非创建此线程超出 maximumPoolSize，在这种情况下，任务将被拒绝。*/
//执行异步任务
//如果当前线程池中的数量大于corePoolSize，缓冲队列workQueue已满，
//并且线程池中的数量等于maximumPoolSize，新提交任务由Handler处理。
//RejectedExecutionException
for (int i = 0; i < 200; i++) {
//相当于new AsyncTask().execute();
THREAD_POOL_EXECUTOR.execute(new MyTask(i));
}
复制代码Log如下
其实这个就是Android中AsyncTask的原理我们不妨分析一下AsyncTask：
初始化
执行
返回
返回UI线程
Progress更新UI
JAVA API 文档：tool.oschina.net/apidocs/api…
Android API文档：tool.oschina.net/apidocs/api…
487
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
