安卓四种线程池

落日映苍穹つ 2022-07-16 04:27 170阅读 0赞

package cn.edu.jlnu.threaddemo;
    
    import android.support.v7.app.AppCompatActivity;
    import android.os.Bundle;
    import android.util.Log;
    import android.view.View;
    import android.widget.Button;
    
    import java.sql.Time;
    import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    import java.util.concurrent.ScheduledExecutorService;
    import java.util.concurrent.TimeUnit;
    
    public class MainActivity extends AppCompatActivity {
        private Button btn;
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_main);
            btn= (Button) findViewById(R.id.btn);
            btn.setOnClickListener(new View.OnClickListener() {
                @Override
                public void onClick(View v) {
                  //  testCache();
                   // testFixed();
                    //testSingle();
                    teestScheduled();
                }
            });
        }
        public void testCache(){//创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程！
            ExecutorService cacheThreadPool= Executors.newCachedThreadPool();
            for(int i=0;i<10;i++){
                final  int index=i;
                cacheThreadPool.execute(new Runnable() {
                    @Override
                    public void run() {
                        Log.e("TAG",Thread.currentThread().getName()+"  "+index);
                    }
                });
                try {
                    Thread.sleep(2000);//让线程休息，可继续执行，防止创建新的线程
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
        public void testFixed(){//创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。
            ExecutorService fixedThreadPool=Executors.newFixedThreadPool(3);
            for(int i=0;i<10;i++){
                final  int index=i;
                fixedThreadPool.execute(new Runnable() {
                    @Override
                    public void run() {
                        Log.e("TAG",Thread.currentThread().getName()+"  "+index);
                        try {
                            Thread.sleep(2000);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                });
            }
        }
        public  void testSingle(){//创建一个单线程化的线程池,它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO,FOFI,优先级)执行
            ExecutorService singleThreadPool =Executors.newSingleThreadExecutor();
            for(int i=0;i<10;i++){
                final  int index=i;
                singleThreadPool.execute(new Runnable() {
                    @Override
                    public void run() {
                        Log.e("TAG",Thread.currentThread().getName()+"  "+index);
                        try {
                            Thread.sleep(2000);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                });
            }
        }
        public void teestScheduled(){//创建一个定长线程池，支持定时及周期性任务执行
            Log.d("TAG","开始执行...");
            ScheduledExecutorService scheduledExecutorService=Executors.newSingleThreadScheduledExecutor();
    //        //定时3秒以后执行
    //        scheduledExecutorService.schedule(new Runnable() {
    //            @Override
    //            public void run() {
    //                Log.d("TAG","延时3秒执行...");
    //            }
    //        },3, TimeUnit.SECONDS);
            //定时2秒之后执行，每个3秒执行一次
            scheduledExecutorService.scheduleAtFixedRate(new Runnable() {
                @Override
                public void run() {
                    Log.d("TAG","延时2秒执行..,每隔3秒执行一次.");
                }
            },2,3,TimeUnit.SECONDS);
            scheduledExecutorService.shutdown();//停止线程
        }
    }