package com.prime.impl;
import java.nio.ByteBuffer;
import java.util.Comparator;
import java.util.TreeSet;
/**
* <p>
* 该内存管理对象主要是在当你需要长时间的new一快内存的时候使用,
* <p>
* <b>(主要作用是为了不让GC对这些内存不停的释放分配而消耗性能,而且每次获取的内存大小可以是自己指定的大小)</b>
* <p>
* 本内存管理对象主要通过预先分配一个大的ByteBuffer然后每次从这个ByteBuffer中获取一小块内存出来进行使用,
* <p>
* 具体获取内存的规则是在打的内存中获取一段连续的内存出来使用,如果中间有一小段内存(例如三个字节)未可以使用,
* <p>
* 但如果你获取的内存都币这三内存大的话,则永远获取不到该内存(这里就会产生一小块的内存碎片),
* <p>
* 当然只要该小段内存的前后被释放后将又可以获取使用
* <p>
* 主要是通过ByteBuffer的子序列来做到的,如果当预先分配的内存不足的时候,将重新分配另快大的内存
* <p>
* (该该重新分配的内存也是有初始化的时候用使用者设置,重新分配的内存将由本内存管理对象中的子内存管理对象所拥有,
* <p>
* 主要算法是通过链表的形式来实现,理论上当总内存不可用的时候可以无限分配新的内存) <br/>
*
* @author 皮佳
*
*/
public class MomoryManagerByte implements MemoryObjInface {
private static int defaultSize = 1024;
/**
* Create size
*/
private static int byte_size = 1024 * 1024 * 1;
private static int dilatancy_size = 1024 * 1024 * 1;
/**
* 是否VM托管
*/
private static boolean isDirect = false;
private ByteBuffer byteBuffer = null;
private TreeSet<MomoryBuffer> bufferSet = new TreeSet<MomoryBuffer>(
new MomoryBufferCommpositor());
private MomoryManagerByte momoryManagerByte = null;
public MomoryManagerByte() {
this(byte_size, defaultSize, dilatancy_size, isDirect);
}
public MomoryManagerByte(boolean isDirect) {
this(byte_size, defaultSize, dilatancy_size, isDirect);
}
public MomoryManagerByte(int byteSize) {
this(byteSize, defaultSize, dilatancy_size, isDirect);
}
public MomoryManagerByte(int byteSize, boolean isDirect) {
this(byteSize, defaultSize, dilatancy_size, isDirect);
}
public MomoryManagerByte(int byteSize, int defaultSize, int dilatancySize,
boolean isDirect) {
this.byte_size = byteSize;
this.defaultSize = defaultSize;
this.dilatancy_size = dilatancySize;
this.isDirect = isDirect;
if (this.isDirect) {
byteBuffer = ByteBuffer.allocateDirect(this.byte_size);
} else {
byteBuffer = ByteBuffer.allocate(this.byte_size);
}
}
@Override
public ByteBuffer allocat() {
return this.allocat(this.defaultSize);
}
@Override
public ByteBuffer allocat(int size) {
//先从总内存中获取
ByteBuffer byteBuffer =gain(size);
return null;
}
/**
* 从byteBuffer中获取一块内存出来使用
* @param size
* @return
*/
private ByteBuffer gain(int size) {
boolean bor = false;
//如果还没有获取过内存就直接从第一个位置开始获取
if(bufferSet == null || bufferSet.size()<=0){
this.byteBuffer.position(0);
this.byteBuffer.limit(size);
bor = true;
}
else{
//如果之前获取过
synchronized (this.bufferSet) {
//遍历之前获取的内存对象 拿到它的索引值 根据索引值来接着后面的位置获取
Iterator<MomoryBuffer> iter = bufferSet.iterator();
int position = 0;
while(iter.hasNext()){
MomoryBuffer momoryBuffer = iter.next();
if((momoryBuffer.getPosition() - position) >= size){
this.byteBuffer.position(position);
this.byteBuffer.limit(momoryBuffer.getPosition());
bor = true;
break;
}
position = momoryBuffer.getLimit();
}
if((this.byte_size - position) >= size){
this.byteBuffer.position(position);
this.byteBuffer.limit(position + size);
bor = true;
}
}
}
ByteBuffer slicebuf = null;
if(bor){
slicebuf = this.byteBuffer.slice();
// this.getBufferSet().add(new MomoryBuffer(slicebuf,slicebuf.arrayOffset(),slicebuf.arrayOffset() + slicebuf.limit()));
this.getBufferSet().add(new MomoryBuffer(slicebuf,this.byteBuffer.position(),this.byteBuffer.limit()));
}
this.byteBuffer.clear();
return slicebuf;
}
private ByteBuffer getByteBuffer() {
return byteBuffer;
}
/**
* 返回正在使用的ByteBuffer队列,用来标示有哪些区间已经在使用了
*
* @return
*/
private TreeSet<MomoryBuffer> getBufferSet() {
return bufferSet;
}
@Override
public void free(ByteBuffer buf) throws Exception {
// TODO Auto-generated method stub
}
/**
* 用来封装去出来的内存,主要是为了表示该内存用到了总内存中的哪些区间
*
* @author cloud _
*/
class MomoryBuffer {
private ByteBuffer buf = null;
private int position = 0;
private int limit = 0;
public MomoryBuffer(ByteBuffer _buf, int _position, int _limit) {
this.buf = _buf;
this.position = _position;
this.limit = _limit;
}
public ByteBuffer getBuf() {
return buf;
}
public int getPosition() {
return position;
}
public int getLimit() {
return limit;
}
}
/**
* 一个排序器,用来将MomoryBuffer进行排序
*
* @author cloud
*
*/
class MomoryBufferCommpositor implements Comparator<MomoryBuffer> {
public int compare(MomoryBuffer o1, MomoryBuffer o2) {
int position_1 = o1.getPosition();
int position_2 = o2.getPosition();
if (position_1 > position_2) {
return 1;
}
if (position_1 < position_2) {
return -1;
}
return 0;
}
}
}
分享到:
相关推荐
面向Android系统的动态内存管理策略.pdf
android低内存管理策略
内存管理内幕 dragonimp's blog coder.developer.[designer].ArchitecturE.manager.^_^... posts - 29, comments - 121, trackbacks - 27 My Links Home Contact Login News !!! Article ...
• 设计一个内存管理器,支持至少两种分配策略, 如first-fit,next-fit, best-fit, worst-fit等。 • 对不同分配策略的性能进行评估。 .2 内存管理器 内存管理器的功能是管理物理内存,在我们的实验中,它是用来对...
虚拟内存管理,基于时钟策略的页面置换
操作系统可变分区存储管理方式的内存分配和回收,可变分区调度算法有:最先适应分配算法,最优适应分配算法,最坏适应算法 用户提出内存空间的申请;系统根据申请者的要求,按照一定的分配策略分析内存空间的使用情况,...
01-Linux内存管理之二:在X86上的虚拟内存管理.rar
模拟可变分区内存管理,比较几种不同的分配策略 。。。 释放空间:(1)释放单元前后都被占用,将其插入到当前hole结点后面。(2)仅前一单元为空,直接改变前一单元的size大小和释放单元的尾部,将其并入前一单元。...
内存管理机制是嵌入式系统研究中的一个重点和难点的问题,它必须满足以下几个特性: ①实时性。从实时性的角度出发,要求内存分配过程要尽可能地快。因此,在嵌入式系统中,不可能采用通用操作系统的一些复杂而完善...
Windows内存管理
Windows内存管理机制.doc
页面替换算法,内存管理优化策略,基于LRU,OPT, CLOCK等。
介绍了c++/C#的异常处理机制中,抛掷和捕获对象的构造和析构问题,分析在异常处理中内存资源的管理策略。
内容:“内存管理规则”总结了对象所有权和销毁的规则。“对象的所有权和销毁”描述了基本的对象所有权策略。“实用内存管理”以实用性的角度透视内存管理。“自动释放池”描述了自动释放池—一种延迟回收的机制—在...
深入剖析内存管理机制和策略,解析常见的内存问题调试方法
文将对 Linux™ 程序员可以使用的内存管理技术进行概述,虽然关注的重点是 C 语言,但同样也适用于其他语言。文中将为您提供如何管理内存的细节,然后将进一步展示如何手工管理内存,如何使用引用计数或者内存池来半...
操作系统 内存管理 设计和实现关于内存管理的内存布局初始化及内存申请分配、内存回收等基本功能操作函数,尝试对用256MB的内存空间进行动态分区方式模拟管理。内存分配的基本单位为1KB,同时要求支持至少两种分配...
内存分配对齐策略 学习c/c++内存管理分配机制的同学们,这是一本必看的文档,你懂的
为了提高TTCN3测试组件间通信的性能,在基于TTCN3的基础测试平台上设计并实现了一套支持动态切换内存管理策略的共享内存管理框架,并在该框架下实现了三套不同的共享内存分配和自动回收策略。框架能够根据系统...
内存管理模拟程序 *******************************/ #include #include #include #include #include #include /*定义宏*/ #define TotalMemSize 1024 /*划分的物理块的大小,地址范围0~1023*/ #define MinSize 2 ...