java 线程池 队列封装_java线程池（线程池组---分离任务队列和线程池）
线程池本质上所使用的逻辑模型仍然是我们熟悉的“生产者/消费者”模型。
生产 消费
外部线程(生产者)－－－>任务
消费者和生产者共享一个数据结构(缓存任务)PriorityQueue；生产者将任务添加到队列中，消费者从队列中取出数据；队列和线程池(线程池内部维护一个线程数组)，完全耦合在一起，当任务特别多，队列就不断的膨胀，增多，拥堵；就向车子过洞子 另外一头走不掉，我靠，长龙(世界最长堵车世界纪录在天朝 200多公里)
问题来了，试想这样的一个情景：当大量登录的消息进来，出去的少(进入大于出去)，队列就不断增加，线程忙不过来处理就空起了，那么大量的其他登录消息就进不来了；阻塞起了；
我的想法是这样解决，本身线程池不是万能的，能否将线程池和数据结构分离开来，外部用一个线程池组，每一个线程池开N个线程(注意应用场景来决定)；
譬如之前我一个线程池是6个线程，
现在就是开6个线程池组，一个线程池对应一个线程，即一个线程==线程池；这样看对应的线程池和任务队列就分开了，相当于开6个线程，把任务均衡到6个队列中，相应的线程去消耗；这样就实现了线程池和任务队列的分离；这样效果是否和单独开一个线程池6个线程一样呢？答案你应该无法猜出来，本身这个就要根据实际情况去处理；这里只是提供一个想法而已 ；
以下就基于netty提供的线程池封装的一个线程池组，要用请导入netty，版本是4；
package Server.ExtComponents.utilsKit.ThreadUtils;
import io.netty.util.concurrent.DefaultEventExecutorGroup;
import io.netty.util.concurrent.EventExecutorGroup;
import org.apache.log4j.xml.DOMConfigurator;
import org.springframework.stereotype.Service;
import java.util.concurrent.atomic.AtomicInteger;
/**
* @author : 石头哥哥
* Project : LandlordsServer
* Date: 13-8-5
* Time: 下午7:37
* Connect: [email protected]
* packageName: Server.ExtComponents.utilsKit.ThreadUtils
* 线程池组管理类
* 多个线程池，平均处理的任务，并行处理；
*/
@Service
public class ThreadPoolExecutorGroupManager {
private EventExecutorGroup EventExecutor[];
private final AtomicInteger _index = new AtomicInteger();
private static final int MAX_FLG=100;
public ThreadPoolExecutorGroupManager(){
}
/**
* 初始化线程组
* @param poolArraySize
*/
public void init(int poolArraySize){
int DEFAULT_THREAD_CORE_SIZE = 1;
init(poolArraySize, DEFAULT_THREAD_CORE_SIZE,ThreadPoolExecutorGroupManager.class+"");
}
/**
* 初始化线程组
* @param poolArraySize 线程组数量
* @param threadCoreSize 每个线程池数量
*/
public void init(int poolArraySize,int threadCoreSize,String groupNmae){
EventExecutor=new EventExecutorGroup[poolArraySize];
for (int i=0;i!=poolArraySize;++i){
EventExecutor[i]=new DefaultEventExecutorGroup(
threadCoreSize,
new PriorityThreadFactory(groupNmae+"+#+"+i, Thread.NORM_PRIORITY ));
}
}
/**
* 获取下一个线程池
* @return EventExecutorGroup
*/
public EventExecutorGroup nextThreadPool(){
int index=_index.getAndIncrement();
if (index>=MAX_FLG){_index.set(0);}
return EventExecutor[Math.abs(index)%EventExecutor.length];
}
public static void main(String[]args){
DOMConfigurator.configure("res/log4j.xml");
ThreadPoolExecutorGroupManager executorGroupManager=new ThreadPoolExecutorGroupManager();
executorGroupManager.init(2,3,"excutors");
for (int i=0;i!=102;++i){
System.out.println("-->>>>"+executorGroupManager.nextThreadPool());
}
}
}
package Server.ExtComponents.utilsKit.ThreadUtils;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.atomic.AtomicInteger;
/**
* @author :陈磊
* Project:CreazyGameServer1.3
* Date: 13-3-19
* Time: 下午8:47
* connectMethod:[email protected]
*/
public class PriorityThreadFactory implements ThreadFactory {
private int _prio;
private String _name;
private AtomicInteger _threadNumber = new AtomicInteger(1);
private ThreadGroup _group;
/**
*
* @param name 线程池名
* @param priority 线程池优先级
*/
public PriorityThreadFactory(String name, int priority){
_prio = priority;
_name = name;
_group = new ThreadGroup(_name);
}
@Override
public Thread newThread(Runnable r){
Thread t = new Thread(_group, r);
t.setName(_name + "-"+"#-" + _threadNumber.getAndIncrement());
t.setPriority(_prio);
return t;
}
public ThreadGroup getGroup(){
return _group;
}
} 好吧今天就到这。