java线程池

人生就像一场戏!

已于 2024-01-18 19:35:57 修改

阅读量193

点赞数

分类专栏： java基础文章标签： java

于 2019-08-08 21:43:24 首次发布

本文链接：https://blog.csdn.net/qq_40428665/article/details/98886217

版权

java基础专栏收录该内容

9 篇文章 0 订阅

订阅专栏

1.引言

合理利用线程池能够带来三个好处。第一：降低资源消耗。通过重复利用已创建的线程降低线程创建和销毁造成的消耗。第二：提高响应速度。当任务到达时，任务可以不需要的等到线程创建就能立即执行。第三：提高线程的可管理性。线程是稀缺资源，如果无限制的创建，不仅会消耗系统资源，还会降低系统的稳定性，使用线程池可以进行统一的分配，调优和监控。但是要做到合理的利用线程池，必须对其原理了如指掌。

2.线程池使用

Executors提供的四种线程 1.newCachedThreadPool创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。 2.newFixedThreadPool 创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。 3.newScheduledThreadPool 创建一个定长线程池，支持定时及周期性任务执行。 4.newSingleThreadExecutor 创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。

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

ExecutorService executorService = Executors.newCachedThreadPool();
for(int i=0;i<5;i++){
  final int index = i;
  try {
    Thread.sleep(index * 1000);
  } catch (InterruptedException e) {
    e.printStackTrace();
  }
  executorService.execute(new Runnable() {
    @Override
    public void run() {
      System.out.println(Thread.currentThread().getName() + "," +index);
    }
  });
}

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

ExecutorService fixedThreadPool = Executors.newFixedThreadPool(4);
for(int i=0;i<5;i++) {
  final int index = i;
    fixedThreadPool.execute(new Runnable() {
    @Override
    public void run() {
      try {
        System.out.println(Thread.currentThread().getName() + ", " + index);
        Thread.sleep(2000);
      } catch (InterruptedException e) {
        e.printStackTrace();
      }
    }
  });
}

3.newScheduledThreadPool 创建一个定长线程池，支持周期和定时任务示例如下

ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);
System.out.println("before:" + System.currentTimeMillis()/1000);
scheduledThreadPool.schedule(new Runnable() {
  @Override
  public void run() {
    System.out.println("延迟3秒执行的哦 :" + System.currentTimeMillis()/1000);
  }
}, 3, TimeUnit.SECONDS);
System.out.println("after :" +System.currentTimeMillis()/1000);






System.out.println("before:" + System.currentTimeMillis()/1000);
scheduledThreadPool.scheduleAtFixedRate(new Runnable() {
  @Override
  public void run() {
    System.out.println("延迟1秒之后，3秒执行一次:" +System.currentTimeMillis()/1000);
  }
}, 1, 3, TimeUnit.SECONDS);
System.out.println("after :" +System.currentTimeMillis()/1000);

4.newSingleThreadExecutor创建一个单线程化的线程池，只会用工作线程来执行任务，保证顺序，示例如下

ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();
for (int i=0;i<10;i++) {
  final int index = i;
  singleThreadExecutor.execute(new Runnable() {
    @Override
    public void run() {
      try {
         System.out.println(Thread.currentThread().getName() + "," + index);
        Thread.sleep(2000);
      } catch (InterruptedException e) {
        e.printStackTrace();
      }
    }
  });
}

向线程池提交任务 ThreadPoolExecutor类中execute()和submit()区别 execute()方法实际上是Executor中声明的方法，在ThreadPoolExecutor进行了具体的实现，这个方法是ThreadPoolExecutor的核心方法，通过这个方法可以向线程池提交一个任务，交由线程池去执行。

submit()方法是在ExecutorService中声明的方法，在AbstractExecutorService就已经有了具体的实现，在ThreadPoolExecutor中并没有对其进行重写，这个方法也是用来向线程池提交任务的，但是它和execute()方法不同，它能够返回任务执行的结果，通过源码查看submit()方法的实现，会发现它实际上还是调用的execute()方法，只不过它利用了Future来获取任务执行结果。

/**
 * @throws RejectedExecutionException {@inheritDoc}
 * @throws NullPointerException    {@inheritDoc}
 */
public Future<?> submit(Runnable task) {
  if (task == null) throw new NullPointerException();
  RunnableFuture<Void> ftask = newTaskFor(task, null);
  execute(ftask);
  return ftask;
}

Future使用

必须实现callable封装业务逻辑


/**
 * @author liuminglin
 * JAVA 线程池之Callable返回结果
 */
public class TaskThread implements Callable<String> {

    private Integer number;

    public TaskThread(Integer number) {
        this.number = number;
    }


    @Override
    public String call() throws Exception {

        //这里一般实现业务逻辑
        System.out.println("线程:" + number + " -> 运行...");
        Thread.sleep(5000);
        System.out.println("线程:" + number + " -> 结束.");

        return "返回的字符串" + number;
    }
}

Future调用


import java.util.ArrayList;
import java.util.concurrent.*;

public class ExecutorService {

    public ExecutorService() {

        java.util.concurrent.ExecutorService executor = new ThreadPoolExecutor(4, 6, 1, TimeUnit.MINUTES,
                new ArrayBlockingQueue<>(10), Executors.defaultThreadFactory(), new ThreadPoolExecutor.AbortPolicy());

        ArrayList<Future<String>> resultList = new ArrayList<Future<String>>();

        //开启10个线程
        for (int i = 0; i < 10; i++) {
            //执行业务逻辑
            TaskThread task = new TaskThread(i);
            //异步提交
            Future<String> future = executor.submit(task);
            resultList.add(future);
        }
        System.out.println("获取结果中...");
        for (Future<String> f : resultList) {
            try {
                // if(f.isDone())
                System.out.println(f.get());
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        System.out.println("得到结果.");
        // 关闭线程池。
        executor.shutdown();
    }

    public static void main(String[] args) {
        new ExecutorService();
    }
}

匿名内部类使用线程池

 public void threadPool(final List userInfoList) {
        ExecutorService executor = new ThreadPoolExecutor(4, 6, 1, TimeUnit.MINUTES,
                new LinkedBlockingQueue<>(), Executors.defaultThreadFactory(), new ThreadPoolExecutor.AbortPolicy());

        try {
            for (int i = 0; i < 5; i++) {
                executor.execute(new Runnable() {
                    @Override
                    public void run() {
                        System.out.println("线程名称___________>" + Thread.currentThread().getName());
                        log.info("线程名称 :{}", Thread.currentThread().getName());
                        batchList(userInfoList);
                    }
                });
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

执行代码逻辑

 public void batchList(final List userInfoList) {
        int size = userInfoList.size();
        int limitNum = 10;
        //批次数
        int batchNum = size % limitNum == 0 ? size / limitNum : size / limitNum + 1;
        boolean falg = size % limitNum != 0;
        for (int i = 0; i < batchNum; i++) {
            int starNum = i * limitNum;
            int endNum = (i + 1) * limitNum;
            //size/limitNum取余数(除不尽),计算end的索引值
            if (falg && i == batchNum - 1) {
                endNum = size;
            }

            List batchList = userInfoList.subList(starNum, endNum);
            dbDao.batchExecutor(NameSpaceEnum.USER_MAPPER, "batchInsert", batchList);
        }

    }

@RequestMapping(value = "/insertList", method = {RequestMethod.GET})
    public void batchInsertList() {

        List<UserInfo> userInfoList = new ArrayList<>();
        for (int i = 1; i <= 201; i++) {
            UserInfo userInfo = new UserInfo();
            userInfo.setId(i);
            userInfo.setUserId(String.valueOf(i));
            userInfo.setUserName("张三" + String.valueOf(i));
            userInfo.setPhone(String.valueOf(i));
            userInfo.setHometown(String.valueOf(i));
            userInfo.setEmail(String.valueOf(i));
            userInfo.setAddress(String.valueOf(i));
            userInfo.setCreatTime(new Date());
            userInfo.setModifyDate(new Date());
            userInfoList.add(userInfo);
        }

        threadPool(userInfoList);
        
    }

案例三

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.HttpURLConnection;
import java.net.URL;
import java.util.concurrent.atomic.AtomicInteger;

import javax.net.ssl.HostnameVerifier;
import javax.net.ssl.HttpsURLConnection;
import javax.net.ssl.SSLSession;

import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;

public class ThreadManager {

    /**
     * 线程池
     */
    private final static ThreadPoolTaskExecutor EXECUTOR = new ThreadPoolTaskExecutor();

    /**
     * 计数器
     */
    private final static AtomicInteger COUNTER = new AtomicInteger(0);

    static {
        EXECUTOR.setCorePoolSize(5); // 线程池维护线程的最少数量
        EXECUTOR.setKeepAliveSeconds(200); // 允许的空闲时间
        EXECUTOR.setMaxPoolSize(20); // 线程池维护线程的最大数量
        EXECUTOR.setQueueCapacity(50); // 缓存队列
        EXECUTOR.initialize();
    }

    public void sendPost(final String url, final String param) {
        synchronized (this) {
            while (COUNTER.get() > 50) { // 如果记数器超过40，则等待一段时间
                System.out.println("param:" + param + "等待");
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            COUNTER.incrementAndGet(); // 任务开始前，计数器加1
        }

        EXECUTOR.execute(new Runnable() {
            @Override
            public void run() {
                try {
                    doSendPost(url, param);
                } finally {
                    // 任务完成后，计数器减1
                    int num = COUNTER.decrementAndGet();
                }
            }
        });
    }

    // public static void main(String[] args) {
    // ThreadManager manager = new ThreadManager();
      // 测试执行100次处理
    // for (int i = 0; i < 100; i++) {
    // manager.sendPost("url", "num:" + i);
    // }
    // System.out.println("==============");
    // }

    private static String doSendPost(String url, String param) {
        // 具体执行推送
    }

}

线程池的关闭我们可以通过调用线程池的shutdown或shutdownNow方法来关闭线程池，但是它们的实现原理不同，shutdown的原理是只是将线程池的状态设置成SHUTDOWN状态，然后中断所有没有正在执行任务的线程。shutdownNow的原理是遍历线程池中的工作线程，然后逐个调用线程的interrupt方法来中断线程，所以无法响应中断的任务可能永远无法终止。shutdownNow会首先将线程池的状态设置成STOP，然后尝试停止所有的正在执行或暂停任务的线程，并返回等待执行任务的列表。

只要调用了这两个关闭方法的其中一个，isShutdown方法就会返回true。当所有的任务都已关闭后,才表示线程池关闭成功，这时调用isTerminaed方法会返回true。至于我们应该调用哪一种方法来关闭线程池，应该由提交到线程池的任务特性决定，通常调用shutdown来关闭线程池，如果任务不一定要执行完，则可以调用shutdownNow。

3. 线程池的分析

流程分析：线程池的主要工作流程如下图： Java线程池主要工作流程

从上图我们可以看出，当提交一个新任务到线程池时，线程池的处理流程如下：

首先线程池判断基本线程池是否已满？没满，创建一个工作线程来执行任务。满了，则进入下个流程。
其次线程池判断工作队列是否已满？没满，则将新提交的任务存储在工作队列里。满了，则进入下个流程。
最后线程池判断整个线程池是否已满？没满，则创建一个新的工作线程来执行任务，满了，则交给饱和策略来处理这个任务。

**源码分析。**上面的流程分析让我们很直观的了解的线程池的工作原理，让我们再通过源代码来看看是如何实现的。线程池执行任务的方法如下：

public void execute(Runnable command) {
  if (command == null)
    throw new NullPointerException();
  int c = ctl.get();
  if (workerCountOf(c) < corePoolSize) {
    if (addWorker(command, true))
      return;
    c = ctl.get();
  }
  if (isRunning(c) && workQueue.offer(command)) {
    int recheck = ctl.get();
    if (! isRunning(recheck) && remove(command))
      reject(command);
    else if (workerCountOf(recheck) == 0)
      addWorker(null, false);
  }
  else if (!addWorker(command, false))
    reject(command);
}

工作线程。线程池创建线程时，会将线程封装成工作线程Worker，Worker在执行完任务后，还会无限循环获取工作队列里的任务来执行。

人生就像一场戏!

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
java线程池

<dependency> <groupId>com.alibaba</groupId> <artifactId>fastjson</artifactId> <version>1.2.47</version></dependency>package com.htf....
复制链接

扫一扫

专栏目录