线程池使用实例

线程池:

package com.mainserver;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.config.ServerConfig;

/**
* 业务线程池
* */
public class ThreadBusiness {

private static final Logger LOGGER = LoggerFactory.getLogger(ThreadBusiness.class);

private final ExecutorService executorService;

private static ThreadBusiness INSTANCE = new ThreadBusiness(ServerConfig.getInstance().getHandleThreadNumber());

public static ThreadBusiness getInstance() {
return INSTANCE;
}

private ThreadBusiness(int threadNumber) {
executorService = Executors.newFixedThreadPool(threadNumber);
}

/**
* 执行线程
* */
public void execute(Runnable runnable) {
if (null == runnable) {
return ;
}

executorService.execute(runnable);
}

/**
* 关闭线程池
*/
public void shutdown() {
try {
executorService.shutdown();
while (executorService.awaitTermination(1, TimeUnit.SECONDS)) {
LOGGER.info("server executor stop");
break;
}
} catch (InterruptedException e) {
LOGGER.error("server awaitTermination exception: {}", e);
}
}

}

执行线程:

public class ServerNetHandler extends SimpleChannelInboundHandler<ReqPacket> {

@Override
public void channelActive(ChannelHandlerContext ctx) throws Exception {
System.out.println("get new connect..");

writeData(ctx.channel());
}

@Override
protected void channelRead0(ChannelHandlerContext ctx, ReqPacket reqPacket) throws Exception {
if (!(reqPacket instanceof ReqPacket)) {
if (ServerConfig.getInstance().ismScreepPrint()) {
System.out.println("it isnt my type");
}
return;
}

RequestHandler handler = new RequestHandler(reqPacket);
ThreadBusiness.getInstance().execute(handler);
}
}

线程业务:

public class RequestHandler implements Runnable {

private static final Logger log = LoggerFactory.getLogger(RequestHandler.class);

private ReqPacket req;

public RequestHandler(ReqPacket reqPacket) {
this.req = reqPacket;
}

@Override
public void run() {
switch (req.header.cmd) {
case eCommand.LOGIN_SERVER_LIST_VALUE:
// 获取登录服列表
writeLoginList(req);
break;
case eCommand.SYS_ADDANDUPDATE_SERVERLIST_VALUE:
// 增加和更新登录服务器列表
sysAddAndUpdateServerList(req);
break;

default:
break;
}
}

时间: 2024-11-04 21:42:56

线程池使用实例的相关文章

线程与线程池,实例比较。

线程池: int count = 200000; long startTime = System.currentTimeMillis(); final List<Integer> l = new LinkedList<Integer>(); ThreadPoolExecutor tp = new ThreadPoolExecutor(1, 1, 60, TimeUnit.SECONDS, new LinkedBlockingDeque<Runnable>(count))

boost::threadpool线程池使用实例

前言: 什么是多线程?比如在做一些下载的程序时,同时开启5个下载任务,对应的其实就是多线程.在一些多线程的程序中,响应请求的个数(即线程)的个数过多的话就会造成系统资源损耗过多而宕机,一般最多线程是有上限的,而且每次创建线程和销毁线程都会大量损耗资源和时间.所以解决办法之一就是使用线程池控制线程个数,复用创建过的线程. 线程池可以减少创建和切换线程的额外开销,利用已经存在的线程多次循环执行多个任务从而提高系统的处理能力. 示例: #include <iostream> #include <

11 java 线程池 使用实例

在前面的文章中,我们使用线程的时候就去创建一个线程,这样实现起来非常简便,但是就会有一个问题: 如果并发的线程数量很多,并且每个线程都是执行一个时间很短的任务就结束了,这样频繁创建线程就会大大降低系统的效率,因为频繁创建线程和销毁线程需要时间. 那么有没有一种办法使得线程可以复用,就是执行完一个任务,并不被销毁,而是可以继续执行其他的任务? 在Java中可以通过线程池来达到这样的效果. 1 线程池做什么 网络请求通常有两种形式: 第一种,请求不是很频繁,而且每次连接后会保持相当一段时间来读数据或

java 线程池 使用实例

在前面的文章中,我们使用线程的时候就去创建一个线程,这样实现起来非常简便,但是就会有一个问题: 如果并发的线程数量很多,并且每个线程都是执行一个时间很短的任务就结束了,这样频繁创建线程就会大大降低系统的效率,因为频繁创建线程和销毁线程需要时间. 那么有没有一种办法使得线程可以复用,就是执行完一个任务,并不被销毁,而是可以继续执行其他的任务? 在Java中可以通过线程池来达到这样的效果. 1 线程池做什么 网络请求通常有两种形式: 第一种,请求不是很频繁,而且每次连接后会保持相当一段时间来读数据或

Java 线程池学习

Reference: <创建Java线程池>[1],<Java线程:新特征-线程池>[2], <Java线程池学习>[3],<线程池ThreadPoolExecutor使用简介>[4],<Java5中的线程池实例讲解>[5],<ThreadPoolExecutor使用和思考>[6] [1]中博主自己通过ThreadGroup实现一个线程池(挺方便理解的),使用的是jdk1.4版本,Jdk1.5版本以上提供了现成的线程池. [2]中介绍

Executor实现线程池

最近工作上需要做一个大数据量的读写操作,为了实现高效率,想到了用多线程实现.在网上查一些资料,发现在JDK 1.5之后有了一个非常方便的东东---Executor来实现多线程. 从JDK 1.5开始,增加了java.util.concurrent包,它的引入大大简化了多线程程序的开发. java.util.concurrent包分成了三个部分,分别是java.util.concurrent.             java.util.concurrent.atomic和java.util.co

Java 线程池分析

在项目中经常会用到java线程池,但是别人问起线程池的原理,线程池的策略怎么实现的? 答得不太好,所以按照源码分析一番,首先看下最常用的线程池代码: public class ThreadPoolTest { private static Executor executor= Executors.newFixedThreadPool(10); //一般通过fixThreadPool起线程池 public static void main(String[] args){ for(int i=0;i

线程池的原理和实现

一. 线程池的简介 通常我们使用多线程的方式是,需要时创建一个新的线程,在这个线程里执行特定的任务,然后在任务完成后退出.这在一般的应用里已经能够满足我们应用的需求,毕竟我们并不是什么时候都需要创建大量的线程,并在它们执行一个简单的任务后销毁. 但是在一些web.email.database等应用里,比如彩铃,我们的应用在任何时候都要准备应对数目巨大的连接请求,同时,这些请求所要完成的任务却又可能非常的简单,即只占用很少的处理时间.这时,我们的应用有可能处于不停的创建线程并销毁线程的状态.虽说比

Linux系统编程——线程池

线程池基本原理 在传统服务器结构中,常是有一个总的监听线程监听有没有新的用户连接服务器,每当有一个新的用户进入,服务器就开启一个新的线程用户处理这 个用户的数据包.这个线程只服务于这个用户,当用户与服务器端关闭连接以后,服务器端销毁这个线程.(关于并发服务器更多详情,请看<并发服务器>). 然而频繁地开辟与销毁线程极大地占用了系统的资源,而且在大量用户的情况下,系统为了开辟和销毁线程将浪费大量的时间和资源.线程池提供了一个解决外部大量用户与服务器有限资源的矛盾. 线程池和传统的一个用户对应一个