Android线程池机制封装

1、封装好的线程工具类

/**
 * 线程池
 * Created by zhaoliang on 2018/5/16 0016
 */

public class ThreadPoolManagerUtil {
    private int corePoolSize;//核心线程池的数量，同时能够执行的线程数量
    private int maximumPoolSize;//最大线程池数量，表示当缓冲队列满的时候能继续容纳的等待任务的数量
    private long keepAliveTime = 1;//存活时间
    private TimeUnit unit = TimeUnit.HOURS;
    private ThreadPoolExecutor executor;
    /**
     * 单例设计模式（饿汉式）
     * 单例首先私有化构造方法，然后饿汉式一开始就开始创建，并提供get方法
     */
    private static ThreadPoolManagerUtil mInstance = new ThreadPoolManagerUtil();

    public static ThreadPoolManagerUtil getInstance() {
        return mInstance;
    }

    private ThreadPoolManagerUtil() {
        /**
         * 给corePoolSize赋值：当前设备可用处理器核心数*2 + 1,能够让cpu的效率得到最大程度执行（有研究论证的）
         */
        corePoolSize = Runtime.getRuntime().availableProcessors() * 2 + 1;
        maximumPoolSize = corePoolSize; //虽然maximumPoolSize用不到，但是需要赋值，否则报错
        executor = new ThreadPoolExecutor(
                corePoolSize, //当某个核心任务执行完毕，会依次从缓冲队列中取出等待任务
                maximumPoolSize, //5,先corePoolSize,然后new LinkedBlockingQueue(),然后maximumPoolSize,但是它的数量是包含了corePoolSize的
                keepAliveTime, //表示的是maximumPoolSize当中等待任务的存活时间
                unit,
                new LinkedBlockingQueue(), //缓冲队列，用于存放等待任务，Linked的先进先出
                Executors.defaultThreadFactory(), //创建线程的工厂
                new ThreadPoolExecutor.AbortPolicy() //用来对超出maximumPoolSize的任务的处理策略
        );

    }

    /**
     * 执行任务
     */
    public void execute(Runnable runnable) {
        if (runnable == null) return;
        executor.execute(runnable);
    }

    /**
     * 从线程池中移除任务
     */
    public void remove(Runnable runnable) {
        if (runnable == null) return;

        executor.remove(runnable);
    }

    public static Runnable runnable300s = new Runnable() {
        @Override
        public void run() {
            try {
                Thread.sleep(300);
            } catch (InterruptedException e) {

            }
        }
    };
}

2、在主类中使用

public class MainActivity extends AppCompatActivity {
    ActivityMainBinding binding;
    private List list = new ArrayList<>();
    private MyAdapter adapter;
    private Context context;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        context = this;
        binding = DataBindingUtil.setContentView(this, R.layout.activity_main);
        adapter = new MyAdapter(context);

        initView();
    }

    private void initView() {
//        new Thread() {
//            @Override
//            public void run() {
//                super.run();
//                getInfo();
//            }
//        }.start();
        ThreadPoolManagerUtil.getInstance().execute(mRunnable);//开启线程池
        binding.btTv.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                adapter.setData(list);//传递数据
                binding.listview.setAdapter(adapter);//listview展示数据
            }
        });
    }

    Runnable mRunnable = new Runnable() {
        @Override
        public void run() {
            getInfo();//请求网络
        }
    };

    private void getInfo() {
        //使用HttpURLConnection
        try {
            // 1. 得到访问地址的URL
            URL url = new URL(
                    "http://5b8cfba17366ab0014a29b87.mockapi.io/api/get/shuji/books");
            // 2. 得到网络访问对象java.net.HttpURLConnection
            HttpURLConnection connection = (HttpURLConnection) url
                    .openConnection();
                         /* 3. 设置请求参数（过期时间，输入、输出流、访问方式），以流的形式进行连接 */
            // 设置是否向HttpURLConnection输出
            connection.setDoOutput(false);
            // 设置是否从httpUrlConnection读入
            connection.setDoInput(true);
            // 设置请求方式
            connection.setRequestMethod("GET");
            // 设置是否使用缓存
            connection.setUseCaches(true);
            // 设置此 HttpURLConnection 实例是否应该自动执行 HTTP 重定向
            connection.setInstanceFollowRedirects(true);
            // 设置超时时间
            connection.setConnectTimeout(3000);
            // 连接
            connection.connect();
            // 4. 得到响应状态码的返回值 responseCode
            int code = connection.getResponseCode();
            // 5. 如果返回值正常，数据在网络中是以流的形式得到服务端返回的数据
            String msg = "";
            if (code == 200) { // 正常响应
                // 从流中读取响应信息
                BufferedReader reader = new BufferedReader(
                        new InputStreamReader(connection.getInputStream()));
                String line = null;

                while ((line = reader.readLine()) != null) { // 循环从流中读取
                    msg += line + "\n";
                }
                reader.close(); // 关闭流
            }
            // 6. 断开连接，释放资源
            connection.disconnect();
            /**
             * 移除线程池
             */
            ThreadPoolManagerUtil.getInstance().remove(mRunnable);//移除线程池
            // 显示响应结果
            System.out.println(msg);
            //解析
            JsonArray jsonArray = new JsonParser().parse(msg).getAsJsonArray();
            for (JsonElement data : jsonArray) {
                InfoBean bean = new Gson().fromJson(data, InfoBean.class);
                list.add(bean);
            }

        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();

    }
}