这个是官方解释

Pool 是对象池类，用于对象的存贮、重复使用。

对象池优化是游戏开发中非常重要的优化方式，也是影响游戏性能的重要因素之一。

在游戏中有许多对象在不停的创建与移除，比如角色攻击子弹、特效的创建与移除，NPC的被消灭与刷新等，在创建过程中非常消耗性能，特别是数量多的情况下。

对象池技术能很好解决以上问题，在对象移除消失的时候回收到对象池，需要新对象的时候直接从对象池中取出使用。

优点是减少了实例化对象时的开销，且能让对象反复使用，减少了新内存分配与垃圾回收器运行的机会。

注意：对象移除时并不是立即从内存中抹去，只有认为内存不足时，才会使用垃圾回收机制清空，清空时很耗内存，很可能就会造成卡顿现象。用了对象池后将减少程序的垃圾对象，有效的提高程序的运行速度和稳定性。

合理使用对象池，可以有效减少对象创建的开销，避免频繁的垃圾回收，从而优化游戏流畅度。

对于游戏中使用频繁的对象，例如BOSS对象，玩家模型等，在实例化的过程中，会增加开销，这时候可以采用对象池来减少内存分配与垃圾回收频率，因为回收进对象池的对象不是立即被销毁，而是储存一段时间之后，达到回收内存上限时，才会被回收。

使用对象池回收对象时需要注意的是，在将对象回收进对象池之前先从父节点remove掉（可以调用removeSelf()），另外，不能将已经被销毁(destoryed)的sprite放回对象池

对象池的优点是减少了实例化对象时的开销，且能让对象反复使用，减少了新内存分配与垃圾回收器运行的机会。

// TODO

透明代理的使用   在对后端的连接中使用对象池（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的压力

众所周知，游戏开发中内存和性能一直是影响用户游戏体验的至关重要的两个因素，这次说一说对象池的概念。
对象池意义是将游戏中反复创建销毁的对象进行多次利用，从而避免大量对象的销毁与创建而造成CPU的负担。缺点是占用了更多的内存，但凡事都没有最好的解决办法，在移动平台上针对游戏的优化基本偏向于牺牲空间换取时间，所以以下两种对象池从本质上是为了回收对象服务的，废话不多说，直接上代码。
using UnityEngine;
using System.Collections;
using System;
using System.Collections.Generic;
/// <summary>
/// 泛型非单例池，代码简洁，通用性广泛
/// </summary>
public class MyPool <T> where T : class {
	private Action <T> mReset;							//重置对象的委托
	private Func <T> mNew;								//创建新对象的委托
	private Stack <T> stack;								//存放对象的池子，用List等动态数组也可以，推荐泛型数组
	public MyPool (Func <T> mNew, Action <T> mReset = null) {
		this.mNew = mNew;
		this.mReset = mReset;
		stack = new Stack<T> ();
	}
	//从池子中获取对象的方法，思路是若池子的数量为0，则调用创建新对象委托创建一个对象返回
	//否则从池子中拿出一个对象并返回
	public T New () {
		if (stack.Count == 0) {
			T t = mNew ();
			return t;									
		} else {
			T t = stack.Pop ();
			if (mReset != null)
				mReset (t);
			return t;
		}
	}
	//此方法用于将销毁的对象存入池子
	public void Store (T t) {
		stack.Push (t);
	}
	//清空池子
	public void Clear () {
		stack.Clear ();
	}
}

此处推荐一个链接，这个对象池的写法很大程度参照这篇文章的，是一位代码节俭主义牛人写的非常好的文章。
点击打开链接
而他的使用方式如下：
using UnityEngine;
using System.Collections;
/// <summary>
/// 使用池子的测试类
/// </summary>
public class Test : MonoBehaviour {
	public GameObject ballet;										//子弹的预设体，在unity引擎中引用
	private MyPool <GameObject> pool;
	void Start () {
		pool = new MyPool<GameObject> (NewBallet, Reset);
	}

	//实例化新子弹的方法
	private GameObject NewBallet () {
		GameObject g = Instantiate (ballet) as GameObject;		//实例化新子弹，实例化过程中需要设置子弹的位置等初始化操作写在这
		return g;
	}
	//重置对象的方法，
	private void Reset (GameObject g) {
		g.transform.position = Vector3.zero;
		g.transform.rotation = Quaternion.identity;
		g.SetActive (true);					//从池子中取后将物体设为可见，也可用其他方法代替
		//......
	}
	//销毁对象的方法
	private void Destroy (GameObject g) {
		g.SetActive (false);							//放入池子前将物体设为不可见
		pool.Store (g);
	}
}

对于使用池子的类我只是写了最基本的应用，推荐将池子放在一个对象类型的控制类中。至于方法里的扩展根据各位看官的项目内容而定。
using UnityEngine;
using System.Collections;
using System.Collections.Generic;
using System;
/// <summary>
/// 单例对象池，思路是为每种GameObject建立一个新的池子，并给他
/// 一个字符串存在字典中。
/// </summary>
public class SinglePool {
	#region 单例，此处使类继承MonoBehavior并写成继承MonoBehavior的单例也可以
	private static SinglePool instance = null;
	private SinglePool () {

	}
	public static SinglePool GetInstance () {
		if (instance == null) {
			instance = new SinglePool ();
		}
		return instance;
	}
	#endregion

	#region 变量
	private Dictionary <string, List <GameObject>> poolDic;		//存放池子的字典，池子用泛型List
	private Action <GameObject> mReset;											//重置对象的委托
	private Func <GameObject> mNew;												//创建新对象的委托
	#endregion

	#region 方法
	//可以让字典存放Object而不是GameObject，适用性更广
	//从对应字符串池子中取出对象的方法
	public GameObject New (string str, Func <GameObject> mNew, Action <GameObject> mReset = null) {
		if (poolDic.ContainsKey (str)) {		//如果字典存在该字符串，取出该池子										
			if (poolDic [str].Count > 0) {		//如果池子里有对象则取出一个对象并返回
				GameObject g = poolDic [str] [0];
				poolDic [str].Remove (g);
				if (mReset != null)
					mReset (g);
				return g;
			} else {								//如果池子没有对象则返回一个创建的新对象
				return mNew ();
			}
		} else {							//如果字典不存在该字符串则新创建一个池子，并返回一个创建的新对象
			poolDic.Add (str, new List<GameObject> ());
			return mNew ();
		}
	}
	//销毁的对象存入池子的方法
	public void Store (string str, GameObject g) {
		if (poolDic.ContainsKey (str)) {
			poolDic [str].Add (g);
		}
	}
	//销毁对象池的方法
	public void DestroyPool (string str) {
		if (poolDic.ContainsKey (str)) {
			poolDic.Remove (str);
		}
	}
	#endregion
}

单例池子的使用方式我就不写了，和上面大同小异，只需多传一个池子对应的string值存在字典即可。晚上继续第二天的一天一算法~