安卓四种线程池

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();//停止线程
    }
}