Android 线程池

最新推荐文章于 2024-04-23 17:25:59 发布

油焖茄子

最新推荐文章于 2024-04-23 17:25:59 发布

阅读量224

点赞数

分类专栏： Android 文章标签： android 线程池

Android 专栏收录该内容

122 篇文章 2 订阅

订阅专栏

在写程序时有些异步程序只执行一遍就不需要了，为了方便经常会写下面的代码

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

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

1.由于是匿名的，无法对它进行管理

2.如果需要多次执行这个操作就new多次，可能创建多个，占用系统资源

3.无法执行更多的操作

使用线程池的好处

1.可以重复利用存在的线程，减少系统的开销

2.利用线程池可以执行定时、并发数的控制

Java的线程池对Android也是适用的

线程池的作用：

线程池作用就是限制系统中执行线程的数量。

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

为什么要用线程池:

1.减少了创建和销毁线程的次数，每个工作线程都可以被重复利用，可执行多个任务。

2.可以根据系统的承受能力，调整线程池中工作线线程的数目，防止因为消耗过多的内存，而把服务器累趴下(每个线程需要大约1MB内存，线程开的越多，消耗的内存也就越大，最后死机)。

Java通过Executors提供四种线程池，分别为：

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

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

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

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

/**
   * 可以缓存线程池
   */
  public static void Function1() {
    ExecutorService executorService = Executors.newCachedThreadPool();
    for (int i = 0; i < 50; i++) {
      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 = 11 index = 30

active count = 11 index = 31

active count = 11 index = 32

active count = 11 index = 33

active count = 11 index = 34

active count = 11 index = 35

active count = 11 index = 36

active count = 11 index = 37

active count = 11 index = 38

active count = 11 index = 39

active count = 11 index = 40

active count = 11 index = 41

active count = 11 index = 42

active count = 11 index = 43

active count = 11 index = 44

active count = 11 index = 45

active count = 11 index = 46

active count = 11 index = 47

active count = 11 index = 48

active count = 10 index = 49

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

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

只创建了一个线程

油焖茄子

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Android 线程池

在写程序时有些异步程序只执行一遍就不需要了，为了方便经常会写下面的代码new Thread(new Runnable() { @Override public void run() { // TODO Auto-generated method stub }}).start();这样new出来的匿名对象会存在一些问题1.由于是匿名的
复制链接

扫一扫