前提概要

非同步建立View這種操作一般情況下是用不到的，包括筆者之前自學階段也是聞所未聞。
這定然是突破了我們一般程式設計的思維——UI操作難道不是隻能在UI執行緒中嗎？
是的，UI操作只能在UI執行緒中，但是UI控制元件的操作卻是可以非同步執行的。

考慮一下以下需求：

我們要展示一個ListView，ListView中的資料和佈局都是我們網路獲取的，我們預先並不知道。

以往的我們使用一個Listview一般都是為了展示一類佈局相同的資訊，這種情況下，我們可以通過adapter的getView（）方法中的convertView來實現View的複用，使View不用反覆建立。
比如以下：

但是倘若ListView的每個Item佈局都不相同，並且佈局可能是網路動態獲取的，我們並不能預先得知。這種情況就不能使用convertView了，那要怎麼處理呢。筆者使用的便是非同步建立View的方式。

非同步建立View

主要流程：

1、既然是非同步建立，那麼建立執行緒池當然是必要的，倘若使用new Thread（）的方式，每次建立執行緒的消耗都超過建立View的消耗了。
2、如需求所說，我們預先並不知道我們會載入什麼佈局，什麼控制元件，所以我們也不知道非同步建立什麼。所以在第一次建立View的時候，是在主執行緒建立的，然後放入到回收池中，回收池接受到了這個View，通過getClass（）的方式就知道自己需要非同步建立什麼View了。
3、存在多執行緒對同一個變數進行存取操作，就必然涉及到鎖的問題。比如：第一次獲取到View，回收池接受到之後開始在池中建立它的副本，但是副本還未建立完成（建立操作是非同步的），adapter就進行了取的操作，這必然是會有問題的。這裡筆者使用樂觀鎖的方式，給獲取操作加上try-catch，儘量去相信這種問題不會發生，如果發生了就直接返回null，在主執行緒建立。

各個類的主要邏輯

CreateThreadPoolExecutor：
執行緒池，每當有執行緒需要建立View的時候，就將任務交給他執行。
HalControlListAdapter：
繼承自BaseAdapter。在getView（）中獲取View的時候首先去HalControlListviewPool中獲取，如果沒有獲取到，就主執行緒自己建立。一般情況下，如果是主執行緒建立的，說明是第一次建立，所以要放入回收池回收，以便讓回收池建立副本。
HalControlListviewPool：
使用HashMap和LinkedList的資料格式來回收，存取View。
如果有View傳進來，就為這個View建立arraySize個副本，以供後面的View獲取。（在demo中 arraySize=1）

示例（原始碼在文章結尾）

每個Item隨機建立TextView或者EditView，如果在主執行緒建立的，就設定Text“主執行緒xxx”，如果是非同步建立的，就不設定text，如下：

筆者為了演示，設定在回收池中每個View的副本只建立一個（arraySize=1），如果設定較多，基本不會再主執行緒建立View。
當然，即使是隻有一個副本，可以看到，大部分的View還是非同步建立的。
這樣就能節省很多主執行緒的資源。

程式碼

CreateThreadPoolExecutor

package com.example.xujiajia_sx.asynccreateui;

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingDeque;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;

public class CreateThreadPoolExecutor extends ThreadPoolExecutor {
    private static CreateThreadPoolExecutor createThreadPoolExecutor;

    private static final int CPU_COUNT = Runtime.getRuntime().availableProcessors();
    //核心執行緒數
    private static final int CORE_POOL_SIZE = CPU_COUNT * 4 + 1;
    //允許建立的最大執行緒數
    private static final int MAXIMUM_POOL_SIZE = CPU_COUNT * 5 + 1;
    //當前執行緒池執行緒綜述大於核心執行緒數時，種植多餘的空閒執行緒的時間
    private static final long KEEP_ALIVE = 10L;

    //用於給執行緒池建立執行緒的執行緒工廠類
    private static final ThreadFactory sThreadFactory = new ThreadFactory() {
        private final AtomicInteger mCount = new AtomicInteger(1);

        @Override
        public Thread newThread(Runnable r) {
            return new Thread(r, "listview#" + mCount.getAndIncrement());
        }
    };

    private CreateThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime,
                                     TimeUnit unit, BlockingQueue<Runnable> workQueue, ThreadFactory threadFactory) {
        super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue, threadFactory);
    }

    public static synchronized CreateThreadPoolExecutor getInstance() {
        if (createThreadPoolExecutor == null) {
            createThreadPoolExecutor = new CreateThreadPoolExecutor(CORE_POOL_SIZE, MAXIMUM_POOL_SIZE,
                    KEEP_ALIVE, TimeUnit.SECONDS, new LinkedBlockingDeque<Runnable>(), sThreadFactory);
        }
        return createThreadPoolExecutor;
    }
}

HalControlListAdapter

package com.example.xujiajia_sx.asynccreateui;

import android.content.Context;
import android.util.Log;
import android.view.View;
import android.view.ViewGroup;
import android.widget.BaseAdapter;
import android.widget.Button;
import android.widget.EditText;
import android.widget.TextView;

import java.util.Random;


/**
 * Created by breakerror on 2017/6/12.
 */

public class HalControlListAdapter extends BaseAdapter {
    private Context mContext = null;
    private HalControlListviewPool mPool;

    public HalControlListAdapter(Context context) {
        mContext = context;
        mPool = new HalControlListviewPool(mContext);
    }

    @Override
    public int getCount() {
        return 100;
    }

    @Override
    public Object getItem(int position) {
        return null;
    }

    @Override
    public long getItemId(int position) {
        return 0;
    }

    int count = 0;

    @Override
    public View getView(int position, View convertView, ViewGroup parent) {
        int key = new Random().nextInt(2);

        View view = mPool.get((long) key);
        if (view == null) {
            view = createView(key, position);
            mPool.recycle(key, view);
        }

        return view;
    }

    public View createView(int key, int position) {
        View view;
        switch (key) {
            case 0:
                view = new TextView(mContext);
                ((TextView) view).setText("TextView主執行緒" + position);
                break;
            case 1:
            default:
                view = new EditText(mContext);
                ((EditText) view).setText("EditText主執行緒" + position);
                break;

        }
        return view;
    }


}

HalControlListviewPool

package com.example.xujiajia_sx.asynccreateui;

import android.content.Context;
import android.view.View;

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.concurrent.ThreadPoolExecutor;

/**
 * Created by breakerror on 2017/6/19.
 */

public class HalControlListviewPool {
    private Context mContext = null;
    private HashMap<Long, LinkedList<View>> mViewPool = null;
    //每個物件非同步建立的個數
    private final int arraySize = 1;
    //建立一個靜態的執行緒池物件
    private static ThreadPoolExecutor THREAD_POOL_EXECUTOR = null;

    public HalControlListviewPool(Context context) {
        mViewPool = new HashMap<>();
        mContext = context;
        THREAD_POOL_EXECUTOR = CreateThreadPoolExecutor.getInstance();
    }

    public boolean recycle(long t, View view) {
        LinkedList<View> subView = mViewPool.get(t);
        if (null == subView) {
            mViewPool.put(t, new LinkedList<View>());
            THREAD_POOL_EXECUTOR.execute(new createTask(view.getClass(), t));
            return true;
        } else {
            return false;
        }
    }

    public View get(long t) {
        LinkedList<View> subView = mViewPool.get(t);
        View view = null;
        if (null != subView && subView.size() > 0) {
            //如果子執行緒只寫了一半就讀取會出錯，如果子執行緒沒寫完就返回null
            try {
                view = subView.getFirst();
                subView.removeFirst();
                THREAD_POOL_EXECUTOR.execute(new createTask(view.getClass(), t));
            } catch (Exception e) {
            }
        }
        return view;
    }


    public class createTask implements Runnable {

        private Class mClass;
        private long mT;

        public createTask(Class c, long t) {
            mClass = c;
            mT = t;
        }

        @Override
        public void run() {
            try {
                Constructor c = mClass.getConstructor(Context.class);
                LinkedList<View> subView = mViewPool.get(mT);
                while (subView.size() < arraySize) {
                    subView.add((View) c.newInstance(mContext));
                }
            } catch (InstantiationException e) {
                e.printStackTrace();
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            } catch (NoSuchMethodException e) {
                e.printStackTrace();
            } catch (InvocationTargetException e) {
                e.printStackTrace();
            }
        }
    }

}

MainActivity

package com.example.xujiajia_sx.asynccreateui;

import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.support.v7.widget.LinearLayoutCompat;
import android.widget.LinearLayout;
import android.widget.ListView;

public class MainActivity extends AppCompatActivity {

    private ListView lvMain;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        initView();
    }

    private void initView() {
        lvMain=(ListView)findViewById(R.id.lv_main);

    }

    @Override
    protected void onStart() {
        super.onStart();
        lvMain.setAdapter(new HalControlListAdapter(this));
    }
}

原始碼下載地址

http://download.csdn.net/detail/double2hao/9899147