DefaultBeetlMemoryManager (com.ibeetl:beetl 3.9.1.RELEASE API)

java.lang.Object
- org.beetl.core.impl.DefaultBeetlMemoryManager

所有已实现的接口:: IBeetlMemoryManager

public class DefaultBeetlMemoryManager
extends Object
implements IBeetlMemoryManager

通过维护 Collection 的引用，来避免重复创建 Collection 的实例当 Collection 的容量较大时，MemoryManager的优势开始凸显，减少了 Collection 扩容的开销

     // 以下例子演示了如何通过 DefaultBeetlMemoryManager 使代码性能提升了 45% (1058ms → 578ms)
     public void testRecoveryList() {
         String tag = "recoveryList#";
         int id = 1;

         // performance: 当 Collection 的容量较大时，MemoryManager的优势开始凸显，减少了 Collection 扩容的开销
         final int size = 20;
         for (int i = 0; i < size; i++) {
             List list = new ArrayList();
             opList(list); // List 的数据操作
             BeetlRuntime.getMemoryManager().recoveryList(list); // 回收引用
         }

         long time1 = System.nanoTime();
         for (int i = 0; i < size; i++) { // 耗时: 578ms
             List list = BeetlRuntime.getMemoryManager().takeList(); // 获取引用，没有则创建
             opList(list); // List 的数据操作
         }
         long time2 = System.nanoTime();
         for (int i = 0; i < size; i++) { // 耗时: 1058ms
             List list = new ArrayList(); // 常规场景创建 List 的实例
             opList(list); // List 的数据操作
         }
         long time3 = System.nanoTime();

         System.out.println(tag + id++ + " 耗时: " + (time2 - time1) / 1_000_000 + "ms");
         System.out.println(tag + id++ + " 耗时: " + (time3 - time2) / 1_000_000 + "ms");
         System.out.println(BeetlRuntime.getMemoryManager());
     }
     // 一个模拟 list 操作的方法
     private static void opList(List list) {
         for (int i = 0; i < 1000_000; i++) {
             list.add(i);
         }
     }

嵌套类概要
- 从接口继承的嵌套类/接口 org.beetl.core.runtime.IBeetlMemoryManager
  IBeetlMemoryManager.Clearable

字段概要

字段
限定符和类型	字段和说明
`static int`	`sListPoolMaxSize` 缓存 `List` 实例的数量上限
`static int`	`sMapPoolMaxSize` 缓存 `Map` 实例的数量上限
`static int`	`sObjectPoolMaxSize` 在每个LinkedList中缓存 `Clearable` 实例的数量上限
`static int`	`sSetPoolMaxSize` 缓存 `Set` 实例的数量上限

方法概要

所有方法静态方法实例方法具体方法
限定符和类型	方法和说明
`void`	`clearMemory()` 清理 ListPool SetPool MapPool 和 ObjectPool 对于 ObjectPool，会依次调用每个实例的 `IBeetlMemoryManager.Clearable.clear()` 方法
`static IBeetlMemoryManager`	`get()` 获取 DefaultBeetlMemoryManager 实例
`boolean`	`recoveryList(List garbage)` 将一个 `List` 实例放入池中
`boolean`	`recoveryMap(Map garbage)` 将一个 `Map` 实例放入池中
`boolean`	`recoveryObject(Class<IBeetlMemoryManager.Clearable> type, IBeetlMemoryManager.Clearable garbage)` 将一个 `IBeetlMemoryManager.Clearable` 实例放入池中
`boolean`	`recoverySet(Set garbage)` 将一个 `Set` 实例放入池中
`int`	`sizeOfListPool()` 返回 List 池中保存的 List 实例的个数
`int`	`sizeOfMapPool()` 返回 Map 池中保存的 Map 实例的个数
`int`	`sizeOfObjectPool()` 返回 Object 池中实例的个数
`int`	`sizeOfObjectType()` 返回 Object 池中类型的个数
`int`	`sizeOfSetPool()` 返回 Set 池中保存的 Set 实例的个数
`List`	`takeList()` 获取一个 `List` 的实例
`Map`	`takeMap()` 获取一个 `Map` 的实例
`IBeetlMemoryManager.Clearable`	`takeObject(Class<IBeetlMemoryManager.Clearable> type)` 获取一个 `IBeetlMemoryManager.Clearable` 的实例
`Set`	`takeSet()` 获取一个 `Set` 的实例
`String`	`toString()`

从类继承的方法 java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

- 字段详细资料
  - sMapPoolMaxSize
```
public static final int sMapPoolMaxSize
```
    缓存 Map 实例的数量上限
    
    另请参阅:
    
    常量字段值
  - sListPoolMaxSize
```
public static final int sListPoolMaxSize
```
    缓存 List 实例的数量上限
    
    另请参阅:
    
    常量字段值
  - sSetPoolMaxSize
```
public static final int sSetPoolMaxSize
```
    缓存 Set 实例的数量上限
    
    另请参阅:
    
    常量字段值
  - sObjectPoolMaxSize
```
public static final int sObjectPoolMaxSize
```
    在每个LinkedList中缓存 Clearable 实例的数量上限
    
    另请参阅:
    
    常量字段值
- 方法详细资料
  - get
```
public static IBeetlMemoryManager get()
```
    获取 DefaultBeetlMemoryManager 实例
    
    返回:
    
    进程内唯一的实例
  - takeMap
```
public Map takeMap()
```
    从接口复制的说明: IBeetlMemoryManager
    
    获取一个 Map 的实例
    
    指定者:
    
    takeMap 在接口中 IBeetlMemoryManager
    
    返回:
    
    Map 实例，如果池中实例不够，则会创建一个
  - recoveryMap
```
public boolean recoveryMap(Map garbage)
```
    从接口复制的说明: IBeetlMemoryManager
    
    将一个 Map 实例放入池中
    
    指定者:
    
    recoveryMap 在接口中 IBeetlMemoryManager
    
    参数:
    
    garbage - 应该被回收的实例
    
    返回:
    
    true 表示放入成功，false 表示放入失败
  - sizeOfMapPool
```
public int sizeOfMapPool()
```
    从接口复制的说明: IBeetlMemoryManager
    
    返回 Map 池中保存的 Map 实例的个数
    
    指定者:
    
    sizeOfMapPool 在接口中 IBeetlMemoryManager
    
    返回:
    
    Map 池中实例的个数
  - takeSet
```
public Set takeSet()
```
    从接口复制的说明: IBeetlMemoryManager
    
    获取一个 Set 的实例
    
    指定者:
    
    takeSet 在接口中 IBeetlMemoryManager
    
    返回:
    
    Set 实例，如果池中实例不够，则会创建一个
  - recoverySet
```
public boolean recoverySet(Set garbage)
```
    从接口复制的说明: IBeetlMemoryManager
    
    将一个 Set 实例放入池中
    
    指定者:
    
    recoverySet 在接口中 IBeetlMemoryManager
    
    参数:
    
    garbage - 应该被回收的实例
    
    返回:
    
    true 表示放入成功，false 表示放入失败
  - sizeOfSetPool
```
public int sizeOfSetPool()
```
    从接口复制的说明: IBeetlMemoryManager
    
    返回 Set 池中保存的 Set 实例的个数
    
    指定者:
    
    sizeOfSetPool 在接口中 IBeetlMemoryManager
    
    返回:
    
    Set 池中实例的个数
  - takeList
```
public List takeList()
```
    从接口复制的说明: IBeetlMemoryManager
    
    获取一个 List 的实例
    
    指定者:
    
    takeList 在接口中 IBeetlMemoryManager
    
    返回:
    
    List 实例，如果池中实例不够，则会创建一个
  - recoveryList
```
public boolean recoveryList(List garbage)
```
    从接口复制的说明: IBeetlMemoryManager
    
    将一个 List 实例放入池中
    
    指定者:
    
    recoveryList 在接口中 IBeetlMemoryManager
    
    参数:
    
    garbage - 应该被回收的实例
    
    返回:
    
    true 表示放入成功，false 表示放入失败
  - sizeOfListPool
```
public int sizeOfListPool()
```
    从接口复制的说明: IBeetlMemoryManager
    
    返回 List 池中保存的 List 实例的个数
    
    指定者:
    
    sizeOfListPool 在接口中 IBeetlMemoryManager
    
    返回:
    
    List 池中实例的个数
  - recoveryObject
```
public boolean recoveryObject(Class<IBeetlMemoryManager.Clearable> type,
                              IBeetlMemoryManager.Clearable garbage)
```
    从接口复制的说明: IBeetlMemoryManager
    
    将一个 IBeetlMemoryManager.Clearable 实例放入池中
    
    指定者:
    
    recoveryObject 在接口中 IBeetlMemoryManager
    
    参数:
    
    type - 类型
    
    garbage - 应该被回收的实例
    
    返回:
    
    true 表示放入成功，false 表示放入失败
  - takeObject
```
public IBeetlMemoryManager.Clearable takeObject(Class<IBeetlMemoryManager.Clearable> type)
```
    从接口复制的说明: IBeetlMemoryManager
    
    获取一个 IBeetlMemoryManager.Clearable 的实例
    
    指定者:
    
    takeObject 在接口中 IBeetlMemoryManager
    
    返回:
    
    Clearable 实例，如果池中实例不够，则会创建一个
  - sizeOfObjectType
```
public int sizeOfObjectType()
```
    从接口复制的说明: IBeetlMemoryManager
    
    返回 Object 池中类型的个数
    
    指定者:
    
    sizeOfObjectType 在接口中 IBeetlMemoryManager
    
    返回:
    
    返回 type 的个数
  - sizeOfObjectPool
```
public int sizeOfObjectPool()
```
    从接口复制的说明: IBeetlMemoryManager
    
    返回 Object 池中实例的个数
    
    指定者:
    
    sizeOfObjectPool 在接口中 IBeetlMemoryManager
    
    返回:
    
    Obejct 池中所有类型的实例数量总和
  - clearMemory
```
public void clearMemory()
```
    从接口复制的说明: IBeetlMemoryManager
    
    清理 ListPool SetPool MapPool 和 ObjectPool 对于 ObjectPool，会依次调用每个实例的 IBeetlMemoryManager.Clearable.clear() 方法
    
    指定者:
    
    clearMemory 在接口中 IBeetlMemoryManager
  - toString
```
public String toString()
```
    覆盖:
    
    toString 在类中 Object

类 DefaultBeetlMemoryManager

嵌套类概要

从接口继承的嵌套类/接口 org.beetl.core.runtime.IBeetlMemoryManager

字段概要

方法概要

从类继承的方法 java.lang.Object

字段详细资料

sMapPoolMaxSize

sListPoolMaxSize

sSetPoolMaxSize

sObjectPoolMaxSize

方法详细资料

get

takeMap

recoveryMap

sizeOfMapPool

takeSet

recoverySet

sizeOfSetPool

takeList

recoveryList

sizeOfListPool

recoveryObject

takeObject

sizeOfObjectType

sizeOfObjectPool

clearMemory

toString