励精图治---Concurrency---GUI设计

为什么只是点击一个button, 可以看到按键变化很快? 添加了按键事件listener,并在里头dosomething的时候有时会有无响应的感觉?

因为特么GUI工具包都被实现为单线程.---------->因为单线程能保证时间有序进行.多线程不稳定的多,开发难度大.现在都是单线程了.

此文不必较真，有个别类是基于swing写的。就看那么个意思。有些许GUI了解就达到目的了

EDT: 事件分发线程  Event Dispatch Thread

EDT负责GUI drawing, 事件分发处理. 因此,当onClickListener中有一个长时间运行的任务,那么会导致界面无响应.

那么对长时间运行的任务,必须要将这个任务委托给分线程,让分线程去处理这个任务, 这可以迅速释放控制器给EDT。从而保证GUI的迅速响应。

用单线程实现线程中的任务调度

范例

public class SingleThread {
    private static final ExecutorService exec = Executors.newSingleThreadExecutor(new SingleThreadFactory());
    
    private static volatile Thread theSingleThread;
    private static class SingleThreadFactory implements ThreadFactory {
        public Thread newThread(Runnable r) {
            theSingleThread = new Thread(r);
            return theSingleThread;
        }
    }
    public static boolean isEventDispatchThread () {
        return Thread.currentThread() == theSingleThread;
    }
    
    public static void invokeLater(Runnable task) {
        exec.execute(task);
    }
    
    public static void invokeAndWait(Runnable task) throws InterruptedException,  InvocationTargetException {
        Future f = exec.submit(task);
        try {
            f.get();
        } catch (ExecutionException e) {
            throw new InvocationTargetException(e);
        }
    }
}

用newSingleThreadExecutor来实现任务的提交。还是比较靠谱的。起码是单线程。安全。

适用：任务时间短，不需要被并发执行，

GUI事件流程

在鼠标点击后，事件的处理流程是这样的。。。这里只要这里doSomething访问的是线程安全的或者GUI对象，而且，时间短的话，那么这里跟线程相关的问题都可以忽略。

面对长时间任务

使用线程接力的方法是比较可取的。

直接看范例。

mSearchView.setOnClickListener(
    new OnClickListener() {
        @Override
        public void onClick(View v) {
            mSearchView.setText("start");//#--------------->第一部分在GUIExecutor中
            backgroundExec.execute(new Runnable() {
                public void run() {
                    try {
                        doSomethingBig();//#--------------->第二部分在backgroundExec中
                    } finally {
                        GuiExecutor.instance().execute(new Runnable() {
                            public void run() {
                                mSearchView.setText("end");//#--------------->第三部分在GUIExecutor中
                            }
                        });
                    }
                }
            });
        }
    });
    
这种做法就叫线程接力。如果这里还需要用Future，那么，用get就可以在得到结果后继续操作。

利用Future取消线程
1. 设置mayInterruptIfRuning为true
2. 调用cancel


Future<?> runningTask;
mSubMitBT.setOnClickListener(
    new OnClickListener() {
        @Override
        public void onClick(View v) {
            if(runningTask == null){
                runningTask = backgroundExec.submit(new Runnable() {
                    public void run() {
                        while(hasWork()){
                            if(Thread.currentThread().isInterrupted()){
                                cleanup();
                                break;
                            }
                            doSomething();
                        }
                    }
                });
            }
        }
    });
mCancelBT.setOnClickListener(
    new OnClickListener() {
        @Override
        public void onClick(View v) {
            if(runningTask != null) runningTask.cancel();
        }
    });
    
利用Future更新完成状态和进度
先看一段FutureTask的源码
public class FutureTask<V> implements RunnableFuture<V> {
    ......
    public FutureTask(Callable<V> callable) {
        if (callable == null)
            throw new NullPointerException();
        this.callable = callable;//#这里可以传入callable
        this.state = NEW;       // ensure visibility of callable
    }


    public FutureTask(Runnable runnable, V result) {
        this.callable = Executors.callable(runnable, result);
        this.state = NEW;       // ensure visibility of callable
    }


    public boolean isCancelled() {//#通过isCanceled检查是否中止
        return state >= CANCELLED;
    }


    public boolean isDone() {//#通过isCanceled检查是否结束
        return state != NEW;
    }


    ......
    
    protected void done() { }


    ......


}
FutureTask实现了RunnableFuture，RunnableFuture继承了Future
public abstract class BackgroundTask<V> implements Runnable, Future<V> {
    private final FutureTask<V> computation = new Computation();
    
    private class Computation extends FutureTask<V> {
        public Computation() {
            super(new Callable<V>() {
                public V call() throws Exception {
                    return BackgroundTask.this.compute();//#这里的Callable会传入给callable，在run的时候会被调用。
                }
            });
        }
        protected final void done() {
            GuiExecutor.instance().execute(new Runnable() {
                public void run() {
                    V value = null;
                    Throwable thrown = null;
                    boolean cancelled = false;
                    try {
                        value = get();//#阻塞式获取结果
                    } catch (ExceptionException e) {
                        thrown = e.getCause();
                    } catch (CancellationException e) {
                        cancelled = true;
                    } finally {
                        onCompletion(value, thrown, cancelled);
                    }
                }
            });//#   GuiExecutor这个类是自定义的。是针对swing写。写这个代码的意义在于意会下那么个意思。不要较真
        }
        protected void setProgress(final int cur, final int max) {
            GuiExecutor.instance().execute(new Runnable() {
                public void run() {
                    onProgress(cur, max);
                }
            });
        }
        protected abstract V computer() throws Exceptions;//#这里是要被实现的，在实现的过程中可以调用setProgress来更新进度
        protected void onCompletion(V result, Throwable exe, boolean cancelled) {}
        protected void onProgress(final int cur, final int max) {}
    }
}




总结
1. GUI设计大部分都是单线程的。也可以自己写。要够严谨才行。
2. 长时间运行的任务，一定要放在分线程里头
3. 线程接力就是把一个人任务拆开执行。UI的归一个线程，逻辑的归一个线程。这是为了避免计算造成阻塞。影响响应
4. EDT中的处理的任务要迅速
5. 创建一个自己的类去处理。Future和newSingleThreadExecutor搭配使用有奇效哦。
6. 库的访问，System.loadLibrary什么的，都要放在同一个线程中执行。android里头一般就是static。方便快捷