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;

}

} 好吧今天就到这。

你可能感兴趣的:(java,线程池,队列封装)