Android线程池的使用方法

来源：互联网发布：swift完整项目源码编辑：程序博客网时间：2024/05/20 01:35

Android的线程池，起到的作用就是更好的管控线程

今天先讲一下基本用法

一、CashedThreadPool：缓存线程池，能够自动创建，删除线程对象，并且对已生成的线程对象反复利用，减少创建和回收的次数，降低系统开销

先看看构造方法

        ExecutorService cachedThreadPool = Executors.newCachedThreadPool();

然后是启动线程方法

            cachedThreadPool.execute(new Runnable() {                @Override                public void run() {                    Log.d("MainActivity", "Thread Name:" + Thread.currentThread().getName() + " Thread ID:" + Thread.currentThread().getId());                }            });

线程池会接受一个Runna对象，然后在线程里运行run方法

二、FixedThreadPool：定量线程池，在构造时会设定线程数量上限，用法和缓存线程池差不多

构造方法

        ExecutorService fixedThreadPool = Executors.newFixedThreadPool(2);

这里的参数“2”就是线程池做能创建线程的上线

用法也是调用execute方法

            fixedThreadPool.execute(new Runnable() {                @Override                public void run() {                    Log.d("MainActivity", "Thread Name:" + Thread.currentThread().getName() + " Thread ID:" + Thread.currentThread().getId());                    Log.d("MainActivity", "i:" + tmp);                    try {                        Thread.sleep(2000);                    } catch (InterruptedException e) {                        e.printStackTrace();                    }                }            });

三、SingleThreadPool：单一线程池，线程池只能有一个线程

构造方法

 ExecutorService singleThreadPool = Executors.newSingleThreadExecutor();

执行线程方法一样我就省略点写，之后会有源码附上

            singleThreadPool.execute(new Runnable() )

四、ScheduleThreadPool：最后一种是一个计划性的线程池，他可以设置延迟多少时间启动线程，也可以设置周期性启动线程

看构造方法

ScheduledExecutorService scheduledThreadPool = Executors.newSingleThreadScheduledExecutor();

注意：这是添加了单个线程限制条件的周期性线程池的构造方法，这次我们用这个举例

我这里有两个使用方法，第一个是延迟，第二个是延迟+周期性，我都写了注释

        //Test1:延迟执行        /**         * 第一个参数是Runnable，第二个参数是时间，第三个参数是时间的单位         *///        scheduledThreadPool.schedule(new Runnable() {//            @Override//            public void run() {//                Log.d("MainActivity", "TestScheduledThreadPool.run");//            }//        }, 3, TimeUnit.SECONDS);        //Test2:延迟执行，并且周期性执行        /**         * 第一个参数是Runnable，第二个参数是延迟时间，第三个参数是巡行间隔，第四个参数是时间的单位         */        scheduledThreadPool.scheduleAtFixedRate(new Runnable() {            @Override            public void run() {                Log.d("MainActivity", "TestScheduledThreadPool.run");            }        },2,3,TimeUnit.SECONDS);

好了其实很简单，我把完整的代码贴一下，布局文件是4个按钮我就不贴上来了，大家想象一下

package com.ty.threadpool_demo1;import android.os.Bundle;import android.support.v7.app.AppCompatActivity;import android.util.Log;import android.view.View;import android.widget.Button;import java.util.concurrent.ExecutorService;import java.util.concurrent.Executors;import java.util.concurrent.ScheduledExecutorService;import java.util.concurrent.TimeUnit;import butterknife.BindView;import butterknife.ButterKnife;import butterknife.OnClick;public class MainActivity extends AppCompatActivity {    @BindView(R.id.BTN_Cached)    Button BTNCached;    @BindView(R.id.BTN_Fixed)    Button BTNFixed;    @BindView(R.id.BTN_Single)    Button BTNSingle;    @BindView(R.id.BTN_Scheduled)    Button BTNScheduled;    @Override    protected void onCreate(Bundle savedInstanceState) {        super.onCreate(savedInstanceState);        setContentView(R.layout.activity_main);        ButterKnife.bind(this);    }    @OnClick({R.id.BTN_Cached, R.id.BTN_Fixed, R.id.BTN_Single, R.id.BTN_Scheduled})    public void onClick(View view) {        switch (view.getId()) {            case R.id.BTN_Cached:                //缓存线程池，会自动控制线程数量，自动创建和销毁,并且循环利用已创建的线程                TestCashedThreadPool();                break;            case R.id.BTN_Fixed:                //在创建线程池的时候会设定最大线程数。                TestFixedThreadPool();                break;            case R.id.BTN_Single:                //单一线程的线程池                TestSingleThreadPool();                break;            case R.id.BTN_Scheduled:                //计划性线程池                TestScheduledThreadPool();                break;        }    }    private void TestScheduledThreadPool() {        ScheduledExecutorService scheduledThreadPool = Executors.newSingleThreadScheduledExecutor();        Log.d("MainActivity", "TestScheduledThreadPool");        //Test1:延迟执行        /**         * 第一个参数是Runnable，第二个参数是时间，第三个参数是时间的单位         *///        scheduledThreadPool.schedule(new Runnable() {//            @Override//            public void run() {//                Log.d("MainActivity", "TestScheduledThreadPool.run");//            }//        }, 3, TimeUnit.SECONDS);        //Test2:延迟执行，并且周期性执行        /**         * 第一个参数是Runnable，第二个参数是延迟时间，第三个参数是巡行间隔，第四个参数是时间的单位         */        scheduledThreadPool.scheduleAtFixedRate(new Runnable() {            @Override            public void run() {                Log.d("MainActivity", "TestScheduledThreadPool.run");            }        },2,3,TimeUnit.SECONDS);    }    private void TestSingleThreadPool() {        ExecutorService singleThreadPool = Executors.newSingleThreadExecutor();        for (int i = 0; i < 10; i++) {            final int tmp = i;            singleThreadPool.execute(new Runnable() {                @Override                public void run() {                    Log.d("MainActivity", "Thread Name:" + Thread.currentThread().getName() + " Thread ID:" + Thread.currentThread().getId());                    Log.d("MainActivity", "i:" + tmp);                    try {                        Thread.sleep(2000);                    } catch (InterruptedException e) {                        e.printStackTrace();                    }                }            });        }    }    private void TestFixedThreadPool() {        ExecutorService fixedThreadPool = Executors.newFixedThreadPool(2);        for (int i = 0; i < 10; i++) {            final int tmp = i;            fixedThreadPool.execute(new Runnable() {                @Override                public void run() {                    Log.d("MainActivity", "Thread Name:" + Thread.currentThread().getName() + " Thread ID:" + Thread.currentThread().getId());                    Log.d("MainActivity", "i:" + tmp);                    try {                        Thread.sleep(2000);                    } catch (InterruptedException e) {                        e.printStackTrace();                    }                }            });        }    }    private void TestCashedThreadPool() {        ExecutorService cachedThreadPool = Executors.newCachedThreadPool();        for (int i = 0; i < 10; i++) {            final int tmp = i;            cachedThreadPool.execute(new Runnable() {                @Override                public void run() {                    Log.d("MainActivity", "Thread Name:" + Thread.currentThread().getName() + " Thread ID:" + Thread.currentThread().getId());                    Log.d("MainActivity", "i:" + tmp);                }            });        }    }}

0 0