Android 线程池ThreadPool的基本使用

蔚落 2021-09-12 02:04 455阅读 1赞

# 前言 #

> 在写异步时，为了方便经常会写下面的代码：

new Thread(new Runnable() {
     
        @Override
        public void run() {
            // TODO Auto-generated method stub
        }
    }).start();

这样new出来的匿名对象会存在一些问题：

1.  由于是匿名的，无法对它进行管理
2.  如果需要多次执行这个操作就new多次，可能创建多个，占用系统资源
3.  无法执行更多的操作

所以，使用线程池的好处：

1.  可以重复利用存在的线程，减少系统的开销
2.  利用线程池可以执行定时、并发数的控制

原理：根据系统的环境情况，可以自动或手动设置线程数量，达到运行的最佳效果；少了浪费了系统资源，多了造成系统拥挤效率不高。用线程池控制线程数量，其他线程排队等候。一个任务执行完毕，再从队列的中取最前面的任务开始执行。若队列中没有等待进程，线程池的这一资源处于等待。当一个新任务需要运行时，如果线程池中有等待的工作线程，就可以开始运行了；否则进入等待队列。

## 四种线程池 ##

（1）newCachedThreadPool：

创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。

（2）newFixedThreadPool：

创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。

（3）newScheduledThreadPool：

创建一个定长线程池，支持定时及周期性任务执行。

（4）newSingleThreadExecutor：

创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。

### 1.newCachedThreadPool ###

/*
    	 * 可以缓存线程池
    	 */
    	public static void Function1() {
    		ExecutorService executorService = Executors.newCachedThreadPool();
    		for (int i = 0; i < 30; i++) {//30次
    			final int index = i;
    			try {
    				Thread.sleep(100); // 休眠时间越短创建的线程数越多
    			} catch (InterruptedException e) {
    				// TODO Auto-generated catch block
    				e.printStackTrace();
    			}
    			executorService.execute(new Runnable() {
    
    				@Override
    				public void run() {
    					// TODO Auto-generated method stub
    					System.out.println("active count = " + Thread.activeCount()
    							+ " index = " + index);
    					try {
    						Thread.sleep(1000);
    					} catch (InterruptedException e) {
    						// TODO Auto-generated catch block
    						e.printStackTrace();
    					}
    				}
    			});
    		}
    	}

打印结果

active count = 2 index = 0
    
    active count = 3 index = 1
    
    active count = 4 index = 2
    
    active count = 5 index = 3
    
    active count = 6 index = 4
    
    active count = 7 index = 5
    
    active count = 8 index = 6
    
    active count = 9 index = 7
    
    active count = 10 index = 8
    
    active count = 11 index = 9
    
    active count = 11 index = 10
    
    active count = 11 index = 11
    
    active count = 11 index = 12
    
    active count = 11 index = 13
    
    active count = 11 index = 14
    
    active count = 11 index = 15
    
    active count = 11 index = 16
    
    active count = 11 index = 17
    
    active count = 11 index = 18
    
    active count = 11 index = 19
    
    active count = 11 index = 20
    
    active count = 11 index = 21
    
    active count = 11 index = 22
    
    active count = 11 index = 23
    
    active count = 11 index = 24
    
    active count = 11 index = 25
    
    active count = 11 index = 26
    
    active count = 11 index = 27
    
    active count = 11 index = 28
    
    active count = 11 index = 29
    
    active count = 10 index = 30

从打印消息来看开始线程数在增加，后来稳定，可以修改休眠时间，休眠时间越短创建的线程数就越多，因为前面的还没执行完，线程池中没有可以执行的就需要创建；如果把休眠时间加大，创建的线程数就会少

### 2.newFixedThreadPool   ###

根据传入的参数创建线程数目

/**
             * 定长线程池
             */
            public static void Function2 () {
                ExecutorService executorService = Executors.newFixedThreadPool(3);
                for (int i = 0; i < 30; i++) {
                    final int index = i;
                    executorService.execute(new Runnable() {
                        @Override
                        public void run() {
                            try {
                                System.out.println("index = " + index
                                        + "  thread count = " + Thread.activeCount());
                                Thread.sleep(2000);
                            } catch (InterruptedException e) {
                                // TODO Auto-generated catch block
                                e.printStackTrace();
                            }
                        }
                    });
                }
            }

### 3.newScheduledThreadPool ###

/**
             * 定长线程池，可做延时
             */
            public static void Function3 () {
                ScheduledExecutorService executorService = Executors
                        .newScheduledThreadPool(5);
                executorService.schedule(new Runnable() {
    
                    @Override
                    public void run() {
                        System.out.println("delay 3 seconds" + "  thread count = "
                                + Thread.activeCount());
                    }
                }, 3, TimeUnit.SECONDS);
            }
    
            /**
             * 定期执行，可以用来做定时器
             */
            public static void Function4 () {
                ScheduledExecutorService executorService = Executors
                        .newScheduledThreadPool(3);
                executorService.scheduleAtFixedRate(new Runnable() {
                    @Override
                    public void run() {
                        System.out
                                .println("delay 1 seconds, and excute every 3 seconds"
                                        + "  thread count = " + Thread.activeCount());
                    }
                }, 1, 3, TimeUnit.SECONDS);
            }

打印结果:

delay 1 seconds, and excute every 3 seconds  thread count = 2
    delay 1 seconds, and excute every 3 seconds  thread count = 3
    delay 1 seconds, and excute every 3 seconds  thread count = 4
    delay 1 seconds, and excute every 3 seconds  thread count = 4
    delay 1 seconds, and excute every 3 seconds  thread count = 4
    delay 1 seconds, and excute every 3 seconds  thread count = 4
    delay 1 seconds, and excute every 3 seconds  thread count = 4
    delay 1 seconds, and excute every 3 seconds  thread count = 4
    delay 1 seconds, and excute every 3 seconds  thread count = 4

### 4.newSingleThreadExecutor这个最简单 ###

/**
         * 单例线程
         */
        public static void Function5() {
            ExecutorService singleThreadExecutor = Executors
                    .newSingleThreadExecutor();
            for (int i = 0; i < 5; i++) {
                final int index = i;
                singleThreadExecutor.execute(new Runnable() {
    
                    @Override
                    public void run() {
                        try {
                            System.out.println("index = " + index
                                    + "  thread count = " + Thread.activeCount());
                            Thread.sleep(1000);
                        } catch (InterruptedException e) {
                            // TODO Auto-generated catch block
                            e.printStackTrace();
                        }
                    }
                });
            }
        }

打印结果：

index = 0  thread count = 2
    index = 1  thread count = 2
    index = 2  thread count = 2
    index = 3  thread count = 2
    index = 4  thread count = 2

只创建了一个线程。

——————————————————结束——————————————————