编程问题一:实现子线程和主线程的切换

最近，我在想我这短暂的程序员生涯有什么让自己眼前一亮的技术呢？有点类似，big question（Who am I？）。
在这里我写一写那些让我有提高和进步的的问题吧。这些问题，原先是先解决后总结出来的。所以大家不要认为我的问题提得“华而不实，原来如此简单”。

问题一：写一个类实现提供子线程方法和主线程方法？

问题背景：这个问题是我最近想到的。因为我见过一些框架，可以通过注释什么“@Main”就可以让方法走在主线程，“@SubMain”就可以再子线程。具体哪个框架我就忘了。但是这个确实是一个好问题。而且有点意思，自己想想看咯。

实现

在这里，其实我是想到了以前工作项目有一个同事写了一个Service（非Android的Service），这个类就提供了一个跑在子线程的方法。而且敏捷的小伙子也知道我们的 AsyncTask 其实就实现。所以，我参考了AsyncTask拷贝实现了一个。代码如下：

/**
 * Created by Ola on 2017/7/19.
 */
public abstract class SuperThread<Result> {

    private static final int MESSAGE_POST_RESULT = 0x1;

    private Thread mThread;

    private static InternalHandler sHandler;
    private Result mResult;

    private static Handler getHandler() {
        synchronized (AsyncTask.class) {
            if (sHandler == null) {
                sHandler = new InternalHandler();
            }
            return sHandler;
        }
    }

    /**
     * running in sub threads
     */
    protected abstract Result doInBackground();

    protected void onResult(Result result) {

    }

    public void execute() {
        mThread = new Thread(new Runnable() {
            @Override
            public void run() {
                mResult = doInBackground();
                postResult(mResult);
            }
        });
        mThread.start();
    }

    private Result postResult(Result result) {
        Message message = getHandler().obtainMessage(
                MESSAGE_POST_RESULT,
                new SuperThreadResult<Result>(this, result));
        message.sendToTarget();
        return result;
    }

    private static class InternalHandler extends Handler {

        public InternalHandler() {
            super(Looper.getMainLooper());
        }

        @Override
        public void handleMessage(Message msg) {
            SuperThreadResult<?> result = (SuperThreadResult<?>) msg.obj;
            switch (msg.what) {
                case MESSAGE_POST_RESULT:
                    result.mSuperThread.onResult(result.mData);
                    break;
            }
        }
    }

    private static class SuperThreadResult<Data> {
        final SuperThread mSuperThread;
        final Data mData;

        public SuperThreadResult(SuperThread superThread, Data data) {
            mSuperThread = superThread;
            mData = data;
        }

    }
}

测试：

       SuperThread<String> superThread = new SuperThread<String>() {

            @Override
            protected String doInBackground() {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

                Date date = new Date();
                SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss SSS");
                String result = format.format(date);

                String name = Thread.currentThread().getName();
                Log.i("doInBackground", name);

                return result;
            }

            @Override
            protected void onResult(String s) {
                info.setText(s);
                String name = Thread.currentThread().getName();
                Log.i("onResult", name);
            }
        };

        superThread.execute();

关键点在于使用handler进行切换主子线程。

输出：