在做很多高并发应用的时候,单线程的瓶颈已经满足不了我们的需求,此时使用多线程来提高处理速度已经是比较常规的方案了。在使用多线程的时候,我们可以使用线程池来管理我们的线程,至于使用线程池的优点就不多说了。

Java线程池说起来也简单,简单说下继承关系: 
ThreadPoolExecutor extends AbstractExecutorService implements ExecutorService extends Executor

还有一个支持延时执行线程和可以重复执行线程的实现类: 
ScheduledThreadPoolExecutor extends ThreadPoolExecutor implements ScheduledExecutorService

大家把这些类中的相关方法弄清楚,使用线程池就不在话下了。其实弄清楚里面各个方法的功能也就够了。 
最重要的还是在实践中总结经验,企业需要的是能实际解决问题的人。

下面是我写的一个例子,包括3个Java文件,分别是: 
ExecutorServiceFactory.java 
ExecutorProcessPool.java 
ExecutorTest.java

1、ExecutorServiceFactory

package test;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.atomic.AtomicInteger; /**
* 线程池构造工厂
*
* @author allan
* @date 2017年3月20日
*/
public class ExecutorServiceFactory {
private static ExecutorServiceFactory executorFactory = new ExecutorServiceFactory();
/**
* 定时任务线程池
*/
private ExecutorService executors; private ExecutorServiceFactory() {
} /**
* 获取ExecutorServiceFactory
*
* @return
*/
public static ExecutorServiceFactory getInstance() {
return executorFactory;
} /**
* 创建一个线程池,它可安排在给定延迟后运行命令或者定期地执行。
*
* @return
*/
public ExecutorService createScheduledThreadPool() {
// CPU个数
int availableProcessors = Runtime.getRuntime().availableProcessors();
// 创建
executors = Executors.newScheduledThreadPool(availableProcessors * 10, getThreadFactory());
return executors;
} /**
* 创建一个使用单个 worker 线程的
* Executor,以无界队列方式来运行该线程。(注意,如果因为在关闭前的执行期间出现失败而终止了此单个线程,
* 那么如果需要,一个新线程将代替它执行后续的任务)。可保证顺序地执行各个任务,并且在任意给定的时间不会有多个线程是活动的。与其他等效的
* newFixedThreadPool(1) 不同,可保证无需重新配置此方法所返回的执行程序即可使用其他的线程。
*
* @return
*/
public ExecutorService createSingleThreadExecutor() {
// 创建
executors = Executors.newSingleThreadExecutor(getThreadFactory());
return executors;
} /**
* 创建一个可根据需要创建新线程的线程池,但是在以前构造的线程可用时将重用它们。对于执行很多短期异步任务的程序而言,这些线程池通常可提高程序性能。调用
* execute 将重用以前构造的线程(如果线程可用)。如果现有线程没有可用的,则创建一个新线程并添加到池中。终止并从缓存中移除那些已有 60
* 秒钟未被使用的线程。因此,长时间保持空闲的线程池不会使用任何资源。注意,可以使用 ThreadPoolExecutor
* 构造方法创建具有类似属性但细节不同(例如超时参数)的线程池。
*
* @return
*/
public ExecutorService createCachedThreadPool() {
// 创建
executors = Executors.newCachedThreadPool(getThreadFactory());
return executors;
} /**
* 创建一个可重用固定线程数的线程池,以共享的无界队列方式来运行这些线程。在任意点,在大多数 nThreads
* 线程会处于处理任务的活动状态。如果在所有线程处于活动状态时提交附加任务
* ,则在有可用线程之前,附加任务将在队列中等待。如果在关闭前的执行期间由于失败而导致任何线程终止
* ,那么一个新线程将代替它执行后续的任务(如果需要)。在某个线程被显式地关闭之前,池中的线程将一直存在。
*
* @return
*/
public ExecutorService createFixedThreadPool(int count) {
// 创建
executors = Executors.newFixedThreadPool(count, getThreadFactory());
return executors;
} /**
* 获取线程池工厂
*
* @return
*/
private ThreadFactory getThreadFactory() {
return new ThreadFactory() {
AtomicInteger sn = new AtomicInteger();
public Thread newThread(Runnable r) {
SecurityManager s = System.getSecurityManager();
ThreadGroup group = (s != null) ? s.getThreadGroup() : Thread.currentThread().getThreadGroup();
Thread t = new Thread(group, r);
t.setName("任务线程 - " + sn.incrementAndGet());
return t;
}
};
}
}

2、ExecutorProcessPool

package test;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Future; /**
* 线程处理类
*
* @author allan
* @date 2017年3月20日
*/
public class ExecutorProcessPool { private ExecutorService executor;
private static ExecutorProcessPool pool = new ExecutorProcessPool();
private final int threadMax = 10; private ExecutorProcessPool() {
System.out.println("threadMax>>>>>>>" + threadMax);
executor = ExecutorServiceFactory.getInstance().createFixedThreadPool(threadMax);
} public static ExecutorProcessPool getInstance() {
return pool;
} /**
* 关闭线程池,这里要说明的是:调用关闭线程池方法后,线程池会执行完队列中的所有任务才退出
*
* @author allan
* @date 2017年3月20日
*/
public void shutdown(){
executor.shutdown();
} /**
* 提交任务到线程池,可以接收线程返回值
*
* @param task
* @return
* @author allan
* @date 2017年3月20日
*/
public Future<?> submit(Runnable task) {
return executor.submit(task);
} /**
* 提交任务到线程池,可以接收线程返回值
*
* @param task
* @return
* @author allan
* @date 2017年3月20日
*/
public Future<?> submit(Callable<?> task) {
return executor.submit(task);
} /**
* 直接提交任务到线程池,无返回值
*
* @param task
* @author allan
* @date 2017年3月20日
*/
public void execute(Runnable task){
executor.execute(task);
} }

3、ExecutorTest

package test;

import java.util.concurrent.Callable;
import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit; /**
* 测试类
*
* @author allan
* @date 2017年3月20日
*/
public class ExecutorTest { public static void main(String[] args) { ExecutorProcessPool pool = ExecutorProcessPool.getInstance(); for (int i = 0; i < 200; i++) {
Future<?> future = pool.submit(new ExcuteTask1(i+""));
// try {
// 如果接收线程返回值,future.get() 会阻塞,如果这样写就是一个线程一个线程执行。所以非特殊情况不建议使用接收返回值的。
// System.out.println(future.get());
// } catch (Exception e) {
// e.printStackTrace();
// }
} for (int i = 0; i < 200; i++) {
pool.execute(new ExcuteTask2(i+""));
} //关闭线程池,如果是需要长期运行的线程池,不用调用该方法。
//监听程序退出的时候最好执行一下。
pool.shutdown();
} /**
* 执行任务1,实现Callable方式
*
* @author allan
* @date 2017年3月20日
*/
static class ExcuteTask1 implements Callable<String> {
private String taskName; public ExcuteTask1(String taskName) {
this.taskName = taskName;
} @Override
public String call() throws Exception {
try {
// Java 6/7最佳的休眠方法为TimeUnit.MILLISECONDS.sleep(100);
// 最好不要用 Thread.sleep(100);
TimeUnit.MILLISECONDS.sleep((int)(Math.random() * 1000));// 1000毫秒以内的随机数,模拟业务逻辑处理
} catch (Exception e) {
e.printStackTrace();
}
System.out.println("-------------这里执行业务逻辑,Callable TaskName = " + taskName + "-------------");
return ">>>>>>>>>>>>>线程返回值,Callable TaskName = " + taskName + "<<<<<<<<<<<<<<";
}
} /**
* 执行任务2,实现Runable方式
*
* @author allan
* @date 2017年3月20日
*/
static class ExcuteTask2 implements Runnable {
private String taskName; public ExcuteTask2(String taskName) {
this.taskName = taskName;
} @Override
public void run() {
try {
TimeUnit.MILLISECONDS.sleep((int)(Math.random() * 1000));// 1000毫秒以内的随机数,模拟业务逻辑处理
} catch (Exception e) {
e.printStackTrace();
}
System.out.println("-------------这里执行业务逻辑,Runnable TaskName = " + taskName + "-------------");
} }
}

原文:http://blog.csdn.net/catoop/article/details/50180949

另外推荐一篇:ExecutorService中submit和execute的区别

JAVA线程池应用的DEMO的更多相关文章

  1. java线程池,信号量使用demo

    直接上代码 package org.jimmy.threadtest20181121; import java.util.concurrent.LinkedBlockingQueue; import ...

  2. 这么说吧,java线程池的实现原理其实很简单

    好处 : 线程是稀缺资源,如果被无限制的创建,不仅会消耗系统资源,还会降低系统的稳定性,合理的使用线程池对线程进行统一分配.调优和监控,有以下好处: 1.降低资源消耗: 2.提高响应速度: 3.提高线 ...

  3. 深入分析java线程池的实现原理(转载)

    前言 线程是稀缺资源,如果被无限制的创建,不仅会消耗系统资源,还会降低系统的稳定性,合理的使用线程池对线程进行统一分配.调优和监控,有以下好处: 1.降低资源消耗: 2.提高响应速度: 3.提高线程的 ...

  4. Java线程池 详解(图解)

    来源:www.jianshu.com/p/098819be088c 拓展: 手动创建 new ThreadPoolExecutor 的使用: https://segmentfault.com/a/11 ...

  5. Java线程池使用和源码分析

    1.为什么使用线程池 在多线程编程中一项很重要的功能就是执行任务,而执行任务的方式有很多种,为什么一定需要使用线程池呢?下面我们使用Socket编程处理请求的功能,分别对每种执行任务的方式进行分析. ...

  6. java 线程池第一篇 之 ThreadPoolExcutor

    一:什么是线程池? java 线程池是将大量的线程集中管理的类,包括对线程的创建,资源的管理,线程生命周期的管理.当系统中存在大量的异步任务的时候就考虑使用java线程池管理所有的线程.减少系统资源的 ...

  7. 面试必备:Java线程池解析

    前言 掌握线程池是后端程序员的基本要求,相信大家求职面试过程中,几乎都会被问到有关于线程池的问题.我在网上搜集了几道经典的线程池面试题,并以此为切入点,谈谈我对线程池的理解.如果有哪里理解不正确,非常 ...

  8. Java线程池实现

    电脑的CPU资源是有限的,任务的处理速度与线程数量之间并不是正相关.当线程数量过多,CPU要频繁的在不同线程切换,反而会引起处理性能的下降.线程池中最大的线程数,是考虑多种因素来事先设定的,比如硬件的 ...

  9. Java线程池 ThreadPoolExecutor类

    什么是线程池? java线程池是将大量的线程集中管理的类, 包括对线程的创建, 资源的管理, 线程生命周期的管理. 当系统中存在大量的异步任务的时候就考虑使用java线程池管理所有的线程, 从而减少系 ...

随机推荐

  1. FLASH结构

    mergedir/code.tmp.bin 压缩未加密文件的FLASH文件 mergedir/sfs/nvm.bin   shareData数据文件,未加密.未压缩 数据克隆:DATA/ALL APP ...

  2. ABP框架详解(五)Navigation

    ABP框架中的Navigation功能用于管理业务系统中所有可用的菜单导航控件,通常在业务系统的首页会有一个全局性的导航菜单,JD商城,天猫,猪八戒网莫不如是.所以为方便起见,Navigation功能 ...

  3. Web Service 的工作原理

    Web Service基本概念 Web Service也叫XML Web Service WebService是一种可以接收从Internet或者Intranet上的其它系统中传递过来的请求,轻量级的 ...

  4. [SoapUI] JDBC 请求连接SQL Sever,MySQL

    MySQLDriver: com.mysql.jdbc.DriverConnection string: jdbc:mysql://localhost:3306/xxx?user=xxx&pa ...

  5. Javascript 异步加载详解(转)

    本文总结一下浏览器在 javascript 的加载方式. 关键词:异步加载(async loading),延迟加载(lazy loading),延迟执行(lazy execution),async 属 ...

  6. Unity3d中C#使用指针(Unsafe)的办法(转)

    近日由于在U3D项目中要使用到数据传递(C++ DLL的数据传递给U3D中的C#),其中涉及到需要使用C#的指针.直接编译会出现以下错误Unsafe code requires the 'unsafe ...

  7. ViewPager的用法实例

    前言:最近在做一个项目,文件管理器,能够在主界面通过滑动选择:手机,内存卡,云端的不同界面,因此就用到了ViewPager. 起步阶段,ViewPager写好了,对应的Adapter也写好了,测试通过 ...

  8. android SlidingTabLayout实现ViewPager页卡滑动效果

    先来张效果图(能够滑动切换页卡) watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQvcGVuZ2t2/font/5a6L5L2T/fontsize/400/fi ...

  9. poj 3111 K Best 最大化平均值 二分思想

    poj 3111 K Best 最大化平均值 二分思想 题目链接: http://poj.org/problem?id=3111 思路: 挑战程序竞赛书上讲的很好,下面的解释也基本来源于此书 设定条件 ...

  10. C#基本方法(瞎写写)

    public static IEnumerable<T> GetAll<T>() where T : new() { using (var conn = new Profile ...