这个是官方解释
 
Pool 是对象池类，用于对象的存贮、重复使用。
 
对象池优化是游戏开发中非常重要的优化方式，也是影响游戏性能的重要因素之一。
 
在游戏中有许多对象在不停的创建与移除，比如角色攻击子弹、特效的创建与移除，NPC的被消灭与刷新等，在创建过程中非常消耗性能，特别是数量多的情况下。
 
对象池技术能很好解决以上问题，在对象移除消失的时候回收到对象池，需要新对象的时候直接从对象池中取出使用。
 
优点是减少了实例化对象时的开销，且能让对象反复使用，减少了新内存分配与垃圾回收器运行的机会。
 
注意：对象移除时并不是立即从内存中抹去，只有认为内存不足时，才会使用垃圾回收机制清空，清空时很耗内存，很可能就会造成卡顿现象。用了对象池后将减少程序的垃圾对象，有效的提高程序的运行速度和稳定性。
 
合理使用对象池，可以有效减少对象创建的开销，避免频繁的垃圾回收，从而优化游戏流畅度。
 
对于游戏中使用频繁的对象，例如BOSS对象，玩家模型等，在实例化的过程中，会增加开销，这时候可以采用对象池来减少内存分配与垃圾回收频率，因为回收进对象池的对象不是立即被销毁，而是储存一段时间之后，达到回收内存上限时，才会被回收。
 
使用对象池回收对象时需要注意的是，在将对象回收进对象池之前先从父节点remove掉（可以调用removeSelf()），另外，不能将已经被销毁(destoryed)的sprite放回对象池
 
对象池的优点是减少了实例化对象时的开销，且能让对象反复使用，减少了新内存分配与垃圾回收器运行的机会。

Netty的对象池又是如何实现的
 
Netty 内存池的知识，它主要采用 jemalloc 内存分配器来实现
 
问题
 
关于 Netty 对象池，我想问你几个问题：
 1 Netty 对象池与内存池的区别与联系？
 2 Netty 内存池中是否使用到了对象池？
 3 Netty 对象池中是否使用到了内存池？
 4 Netty 对象池实现的基本逻辑？

透明代理的使用 在对后端的连接中使用对象池（backend是一个池子 里面是一个域名的连接）
 
使用需要用到的组件
 
GenericObjectPool.Config
DefaultChannelGroup
PoolableObjectFactory BasePoolableObjectFactory
GenericObjectPool
 
调用的流程
 
需要重写的函数 makeObject、 validateObject、 destroyObject
1、makeObject 创建对象的具体实现
2、borrowObject 获取对象池中的对象简单而言就是去LinkedList中获取一个对象，如果不存在的话，要调用构造方法中第一个参数Factory工厂类的makeObject()方法去创建一个对象再获取，获取到对象后要调用validateObject方法判断该对象是否是可用的，如果是可用的才拿去使用。LinkedList容器减一
3、returnObject 先调用validateObject方法判断该对象是否是可用的，如果可用则归还到池中，LinkedList容器加一，如果是不可以的则则调用destroyObject方法进行销毁。
 
避免泄漏
 
产生原因
 
在一些极端的情况下出现 borrowObject／invalidateObject 没有被调用导致的泄漏问题。
对象泄漏会导致对象池中的对象数量一直上升，达到设置的上限
再调用 borrowObject 就会永远等待或者抛出java.util.NoSuchElementException: Timeout waiting for idle object 异常。

 
解决策略
 
1. 设置抛弃时间
GenericObjectPool判断一个对象是否泄漏是根据对象最后一次使用或者最后一次borrow的时间进行判断的，
如果超出了预设的值就会被认为是一个泄漏的对象被清理掉（PooledObjectFactory.destroyObject在这一过程中会被调用）。
抛弃时间可以通过 AbandonedConfig.setRemoveAbandonedTimeout 进行设置，时间单位是秒

2. 设置了抛弃时间以后还需要打开泄漏清理才会生效。泄漏判断的开启可以通过两种方式

> 从对象池中获取对象的时候进行清理如果当前对象池中少于2个idle状态的对象或者 active数量>最大对象数-3 的时候，
在borrow对象的时候启动泄漏清理。通过 AbandonedConfig.setRemoveAbandonedOnBorrow 为 true 进行开启。

> 启动定时任务进行清理AbandonedConfig.setRemoveAbandonedOnMaintenance 设置为 true 以后，
在维护任务运行的时候会进行泄漏对象的清理，可以通过 GenericObjectPool.setTimeBetweenEvictionRunsMillis 设置维护任务执行的时间间隔。

- 使用例子
GenericObjectPool<PoolObj> pool = new GenericObjectPool<PoolObj>(new MyPooledObjectFactory(),config);

AbandonedConfig abandonedConfig = new AbandonedConfig();

abandonedConfig.setRemoveAbandonedOnMaintenance(true); //在Maintenance的时候检查是否有泄漏

abandonedConfig.setRemoveAbandonedOnBorrow(true); //borrow 的时候检查泄漏

abandonedConfig.setRemoveAbandonedTimeout(10); //如果一个对象borrow之后10秒还没有返还给pool，认为是泄漏的对象

pool.setAbandonedConfig(abandonedConfig);

pool.setTimeBetweenEvictionRunsMillis(5000); //5秒运行一次维护任务

 
透明代理使用demo
 
初始化定义
 
GenericObjectPool.Config poolConfig = new GenericObjectPool.Config();
poolConfig.maxActive = config.getIntAttribute("maxActive", DEFAULT_POOLCONFIG_MAXACTIVE);
poolConfig.maxIdle = config.getIntAttribute("maxIdle", DEFAULT_POOLCONFIG_MAXIDLE);
poolConfig.minIdle = config.getIntAttribute("minIdle", DEFAULT_POOLCONFIG_MINIDLE);
poolConfig.maxWait = config.getIntAttribute("maxWait", DEFAULT_POOLCONFIG_MAXWAIT);
poolConfig.testOnBorrow = true;
poolConfig.testOnReturn = true;
poolConfig.whenExhaustedAction = GenericObjectPool.WHEN_EXHAUSTED_GROW;

port = config.getIntAttribute("port", 80);
int idleTimeout = config.getIntAttribute("idleTimeout", DEFAULT_IDLE_TIMEOUT);
int connectionTimeout = config.getIntAttribute("connectionTimeout", DEFAULT_CONNECTION_TIMEOUT);
int maxResponseLength = config.getIntAttribute("maxResponseLength", DEFAULT_MAX_RESPONSE_LENGTH);
channelGroup = new DefaultChannelGroup();
channelPool =new BackendChannelPool(host, port, idleTimeout, connectionTimeout, maxResponseLength, 
    clientSocketChannelFactory, timer, poolConfig,
    new HostBackendHandlerListener() {
        @Override
        public void onExceptionCaught(BackendRequest request,
                        ChannelHandlerContext ctx, ExceptionEvent e) {
            try {
                if (request == null) {
                    return;
                }
                // 如果是 ClosedChannelException 则无需使pool中的连接失效，因为
                // 创建连接的时候已经添加了连接关闭监听器来处理 参看 BackendConnection
                if (!(e.getCause() instanceof ClosedChannelException)
                                && !(e.getCause() instanceof ConnectException)) {
                    BackendConnection connection = request.getConnection();
                    channelPool.invalidateObject(connection);
                }
            } catch (Exception ex) {
                LogUtils.error(" invalidate object error ", ex);
            }
        }

        @Override
        public void onMessageReceived(BackendRequest request,
                        ChannelHandlerContext ctx, MessageEvent e) {
        }

        @Override
        public void onChannelOpen(ChannelHandlerContext ctx, ChannelStateEvent e) {
            channelGroup.add(ctx.getChannel());
        }

        @Override
        public void onMessageProcessed(BackendRequest request,
                        ProxyHttpResponse response, boolean closeConnection,
                        ChannelHandlerContext ctx, MessageEvent e) {
            BackendConnection connection = request.getConnection();
            try {
                if (closeConnection) {
                    if (connection.isOpen()) {
                        channelPool.invalidateObject(connection);
                    }
                } else {
                    channelPool.returnObject(connection);
                }
            } catch (Exception ex) {
                LogUtils.error(" return object error ", ex);
            }
        }
    },backendExecutor);
    String detectPath = config.getAttribute("detectPath");
    int detectPeriod = config.getIntAttribute("detectPeriod", DEFAULT_DETECT_PERIOD_TIME);
    this.detectTimes = config.getIntAttribute("detectTimes", DEFAULT_DETECT_TIMES);
    if (!StringUtils.isBlank(detectPath)) {
        client = new NettyHttpClient(timer);
        LogUtils.info(this.getName() + " start schedule backend detect " + host + ":" + port + detectPath);
        detectExecutor = Executors.newSingleThreadScheduledExecutor();
        detectExecutor.scheduleAtFixedRate(new BackendDetectThread(host, port, detectPath, client),
                detectPeriod, detectPeriod, TimeUnit.SECONDS);
    }
}

 
创建对象
 
public Object makeObject() throws Exception {

	if(LogUtils.isTraceEnabled()){
    	LogUtils.trace("BackendChannelPool makeObject");
	}

	// await*() in I/O thread causes a dead lock or sudden performance drop.
	//  pool.borrowObject() 必须在新的线程中执行

	// Configure the client.
	final ClientBootstrap cb = new ClientBootstrap(
			clientSocketChannelFactory);
	final BlockingQueue<BackendRequest> requestQueue = new LinkedBlockingQueue<BackendRequest>();

	final ChannelPipelineFactory cpf = new ChannelPipelineFactory() {

		@Override
		public ChannelPipeline getPipeline() throws Exception {
			// Create a default pipeline implementation.
			final ChannelPipeline pipeline = Channels.pipeline();

			pipeline.addLast("timeout", new ProxyIdleStateHandler(timer, 0, 0, idleTimeout, TimeUnit.MILLISECONDS));
			pipeline.addLast("decoder", new ProxyHttpResponseDecoder());
			pipeline.addLast("aggregator", new ProxyHttpChunkAggregator(maxResponseLength));

			final BackendRelayingHandler handler = new BackendRelayingHandler(
					handlerListener,requestQueue,backendExecutor);

			final BackendRequestEncoder encoder = new BackendRequestEncoder(requestQueue);
			pipeline.addLast("encoder", encoder);
			pipeline.addLast("handler", handler);
			return pipeline;
		}
	};

	// Set up the event pipeline factory.
	cb.setPipelineFactory(cpf);
	//TODO more option config.
	cb.setOption("connectTimeoutMillis", connectionTimeout * 1000);

	ChannelFuture future = cb.connect(new InetSocketAddress(host,
			port));
	if(LogUtils.isDebugEnabled()){
		LogUtils.debug("ClientChannelObjectFactory.makeObject ChannelFuture: "+host+":"+port);
	}
	future = future.await();
	if(future.isCancelled()){
		throw new ConnectTimeoutException("request cancelled.");
	}else if(!future.isSuccess()){
		throw new ConnectTimeoutException(future.getCause());
	}else{
		return new BackendConnection(future.getChannel());
	}
}

 
重要优化点
 
 
connectionPool.setMaxActive(maxActive); connectionPool.setMaxIdle(maxActive); 成对配置
 
 
设置maxWait connectionPool.setMaxWait(maxWait);
 
  
 
   
不设置会导致当被依赖的服务由于某些故障（如机器资源被某进程大量占用）而响应极慢时，会有大量线程blocked在borrowObject的逻辑，最终导致resin线程耗尽，服务卡死，用户请求被拒绝
 
  
 
  
 
   
因此需要对maxWait进行设置，且设置的时间不宜过大(高吞吐时仍有可能导致web卡死)，也不宜过小（可能导致较多的请求失败）
 
  
 
  
 
   
基本原则： qt<N, 其中q为服务最大吞吐(请求/s), t为设置的maxWait时间(s), N为resin的最大线程数 resin的线程数当前为512, 预估最大吞吐为100, 因此有t<N/q=512/100=5.12 我们将其配置为3s(即3000ms), 从而当该对象池中的对象出现异常时，仍可扛住512/3约为170qps的压力
 
  
 

                          Unity3D框架学习_对象池和对象池管理
 

目录
 
1、博客介绍
 
2、内容
 
（1）ObjectPoolContainer 对象容器
 
（2）ObjectPool 单一对象池
 
（3）PoolManager 对象池管理
 
3、推送
 
4、结语
 

1、博客介绍
 
        本篇博客介绍Unity对象池的管理，改自github某工程，结尾会推送，对象池没什么特别好说的了就是实例对象，释放对象，博主这篇写的很简单，读者直接看博主的工程就一目了然了，博客内不再书写代码，工程注释和结构都很清晰，配的还有流程图，工程推送在结尾博主的github。
 

2、内容
 
（1）ObjectPoolContainer 对象容器
 
该脚本包含了实例对象和该对象的使用状态
 
 
（2）ObjectPool 单一对象池
 
         对象池内包含了，储存对象容器的链表，正在使用的对象的字典，池子名字，获取对象实例的方法Get（），释放对象的方法Release（）。
 
 
（3）PoolManager 对象池管理
 
       对象池管理脚本，对象池会自动挂载在PoolManager空节点下，没有自动创建，生成物释放后也放置在PoolManager下,字典储存了不同的对象池， 可以设置刷新时间RefreshTime来定时刷新池子，会删除不活跃的池子。
 
 

3、推送
 
博主github：https://github.com/KingSun5/UnityPool
 
学习借鉴:https://github.com/thefuntastic/unity-object-pool
 

4、结语
 
学习使人进步，最近好困呀，春困呀，博主能力有限，若文中有出现什么错误的地方，欢迎各位评论指摘。
 
       QQ交流群：806091680（Chinar）
 
       该群为CSDN博主Chinar所创，推荐一下！我也在群里！
 
       本文属于原创文章，转载请著名作者出处并置顶！！！！！