使用String存储和分配可用资源

最新推荐文章于 2024-08-15 14:47:41 发布
最新推荐文章于 2024-08-15 14:47:41 发布
阅读量243 收藏
点赞数
分类专栏： # 想法与实现 文章标签： java 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/shaozhugui91/article/details/114199570
版权

问题

遇到一些资源存储和分配的问题，例如，某种资源的取值范围为1-65535，需要动态分配和回收。在Java中最小的数据类型为byte，如果使用byte[65535]在内存和库中存储，至少需要65KB空间，当网络中此类资源池过多时，会造成内存资源大量消耗。

解决思路

利用String来存储和描述id：1-65535的占用情况。如"2-5,20,30,40-45,105-120,300,400-500,600-700,1000-1050,2000-65535"表示可用id有：2、3、4、5、20、30、40、41、42、43、44、45、105…
在存储和Java内部处理时均以字符串形式处理，不将其转变为byte数组。以节省内存空间。

  1. 字符串格式中以COMMA="," 作为分割符；以CONN="-"作为连接符；
  2. 保持有序排列，这样可以用二分法进行快速查找（这里使用了一种二分法的变形，一直没有做理论推导，但确实好用）；

Java实现

类中的方法与属性
其中public方法有四个：
releaseId(int) 释放指定的Id资源；
getId(int) 占用指定的Id资源；
getId() 自由占用Id资源，默认策略是最小值优先。
getIdPool 查看当前的Id资源池

测试效果如下：

idpool is 2-5,20,30,40-45,105-120,300,400-500,600-700,1000-1050,2000-65535
get Id for targetId:2
idpool is 3-5,20,30,40-45,105-120,300,400-500,600-700,1000-1050,2000-65535
get Id for targetId:4
idpool is 3,5,20,30,40-45,105-120,300,400-500,600-700,1000-1050,2000-65535
get Id for targetId:20
idpool is 3,5,30,40-45,105-120,300,400-500,600-700,1000-1050,2000-65535
get Id for targetId:41
idpool is 3,5,30,40,42-45,105-120,300,400-500,600-700,1000-1050,2000-65535
get Id for targetId:43
idpool is 3,5,30,40,42,44-45,105-120,300,400-500,600-700,1000-1050,2000-65535
get Id for targetId:105
idpool is 3,5,30,40,42,44-45,106-120,300,400-500,600-700,1000-1050,2000-65535
get Id for targetId:120
idpool is 3,5,30,40,42,44-45,106-119,300,400-500,600-700,1000-1050,2000-65535
get Id for targetId:650
idpool is 3,5,30,40,42,44-45,106-119,300,400-500,600-649,651-700,1000-1050,2000-65535
id is not in pool
idpool is 3,5,30,40,42,44-45,106-119,300,400-500,600-649,651-700,1000-1050,2000-65535
get Id for default: 3
idpool is 5,30,40,42,44-45,106-119,300,400-500,600-649,651-700,1000-1050,2000-65535
get Id for default: 5
idpool is 30,40,42,44-45,106-119,300,400-500,600-649,651-700,1000-1050,2000-65535
get Id for default: 30
idpool is 40,42,44-45,106-119,300,400-500,600-649,651-700,1000-1050,2000-65535
get Id for default: 40
idpool is 42,44-45,106-119,300,400-500,600-649,651-700,1000-1050,2000-65535
get Id for default: 42
idpool is 44-45,106-119,300,400-500,600-649,651-700,1000-1050,2000-65535
get Id for default: 44
idpool is 45,106-119,300,400-500,600-649,651-700,1000-1050,2000-65535
get Id for default: 45
idpool is 106-119,300,400-500,600-649,651-700,1000-1050,2000-65535
get Id for default: 106
idpool is 107-119,300,400-500,600-649,651-700,1000-1050,2000-65535
get Id for default: 107
idpool is 108-119,300,400-500,600-649,651-700,1000-1050,2000-65535
get Id for default: 108
idpool is 109-119,300,400-500,600-649,651-700,1000-1050,2000-65535
get Id for default: 109
idpool is 110-119,300,400-500,600-649,651-700,1000-1050,2000-65535
get Id for default: 110
idpool is 111-119,300,400-500,600-649,651-700,1000-1050,2000-65535
get Id for default: 111
idpool is 112-119,300,400-500,600-649,651-700,1000-1050,2000-65535
get Id for default: 112
release id: 100
idpool is 100,113-119,300,400-500,600-649,651-700,1000-1050,2000-65535
release id: 99
idpool is 99-100,113-119,300,400-500,600-649,651-700,1000-1050,2000-65535
release id: 98
idpool is 98-100,113-119,300,400-500,600-649,651-700,1000-1050,2000-65535
release id: 101
idpool is 98-101,113-119,300,400-500,600-649,651-700,1000-1050,2000-65535
release id: 101
101 has been in pool
idpool is 98-101,113-119,300,400-500,600-649,651-700,1000-1050,2000-65535
release id: 501
idpool is 98-101,113-119,300,400-501,600-649,651-700,1000-1050,2000-65535
release id: 399
idpool is 98-101,113-119,300,399-501,600-649,651-700,1000-1050,2000-65535
release id: 800
idpool is 98-101,113-119,300,399-501,600-649,651-700,800,1000-1050,2000-65535
release id: 8000
8000 has been in pool
idpool is 98-101,113-119,300,399-501,600-649,651-700,800,1000-1050,2000-65535
release id: 1
idpool is 1,98-101,113-119,300,399-501,600-649,651-700,800,1000-1050,2000-65535

Process finished with exit code 0

测试代码：

package idpool;

/**
 * @author shaozhugui
 * @date 2021/2/27
 */
public class IdTest {
    public static void main(String[] args) {
        IdPooImpl idPoo = new IdPooImpl("2-5,20,30,40-45,105-120,300,400-500,600-700,1000-1050,2000-65535");

        int[] getIds = {2,4,20,41,43,105,120,650,350};
        for (int id : getIds) {
            try {
                System.out.println("idpool is " + idPoo.getIdPool());
                System.out.println("get Id for targetId:" + idPoo.getId(id));
            } catch (IllegalAccessException e) {
                break;
            }
        }

        for (int i = 1; i < 15; i++) {
            try {
                System.out.println("idpool is " + idPoo.getIdPool());
                System.out.println("get Id for default: " + idPoo.getId());
            } catch (IllegalAccessException e) {
                break;
            }
        }

        int[] releaseIds = {100,99,98,101,101,501,399,800,8000,1};
        for (int releaseId : releaseIds) {
            System.out.println("release id: " + releaseId);
            idPoo.releaseId(releaseId);
            System.out.println("idpool is " + idPoo.getIdPool());
        }
    }
}


package idpool;

/**
 * @author shaozhugui
 * @date 2021/2/27
 */
public class IdPooImpl {
    private String idPool = "1-65535";//"2-10,20,30,40-100,105-200,300-65535", ""

    private static final String COMMA = ",";
    private static final String CONN = "-";

    public IdPooImpl(String idPool) {
        this.idPool = idPool;
    }

    //释放id
    public boolean releaseId(int targetId) {
        if (targetId <= 0) {
            return false;
        }
        if("".equals(idPool)) {
            idPool = String.valueOf(targetId);
            return true;
        }
        String[] idList = idPool.split(COMMA);
        //二分法查找目标id所在的区间(变异二分法)
        int index = getIndexByDichotomySearch(idList, targetId);
        int start = getStart(idList[index]);
        int end = getEnd(idList[index]);
        //System.out.println("index is " + index + "; start = " + start + "; end = " + end);
        if (targetId >= start && targetId <= end) {
            System.out.println(targetId + " has been in pool");
            return true;
        }
        index = targetId > end ? index : index - 1;
        // 之后，targetId必然位于index与index+1之间
        String temp = "";
        if (index >=0 && index + 1 <= idList.length - 1) {
            String pre = idList[index];
            String next = idList[index + 1];
            temp = getTempStr(pre, next, targetId);
        } else if (index == -1) {
            String next = idList[index + 1];
            temp = getTempStr(next, targetId);
        } else if (index == idList.length - 1){
            String pre = idList[index];
            temp = getTempStr2(pre, targetId);
        }
        StringBuilder builder = new StringBuilder();
        for(int i = 0; i < index; i++) {
            builder.append(idList[i]).append(COMMA);
        }
        builder.append(temp);

        if (index < idList.length - 2) {
            builder.append(COMMA);
            for(int i = index + 2; i < idList.length - 1; i++) {
                builder.append(idList[i]).append(COMMA);
            }
            builder.append(idList[idList.length - 1]);
        }

        idPool = builder.toString();
        return true;
    }

    private String getTempStr2(String pre, int targetId) {
        int preStart = getStart(pre);
        int preEnd = getEnd(pre);
        String temp;
        if (targetId - preEnd != 1) {
            temp = pre + COMMA + targetId;
        } else {
            temp = preStart + CONN + targetId;
        }
        return temp;
    }

    private String getTempStr(String next, int targetId) {
        int nextStart = getStart(next);
        int nextEnd = getEnd(next);
        String temp;
        if (nextStart - targetId != 1) {
            temp = targetId + COMMA + next;
        } else {
            temp = targetId + CONN + nextEnd;
        }
        return temp;
    }

    private String getTempStr(String pre, String next, int targetId) {
        int preStart = getStart(pre);
        int preEnd = getEnd(pre);
        int nextStart = getStart(next);
        int nextEnd = getEnd(next);
        String temp;
        if (targetId - preEnd != 1 && nextStart - targetId != 1) {
            temp = pre + COMMA + targetId + COMMA + next;
        } else if (targetId - preEnd == 1 && nextStart - targetId != 1) {
            temp = preStart + CONN + targetId + COMMA + next;
        } else if (targetId - preEnd != 1 && nextStart - targetId == 1) {
            temp = pre + COMMA + targetId + CONN + nextEnd;
        } else {
            temp = preStart + CONN + nextEnd;
        }
        return temp;
    }


    //指定Id分配
    public int getId(int targetId) throws IllegalAccessException {
        if("".equals(idPool)) {
            System.out.println("id pool is empty.");
            throw new IllegalAccessException();
        }

        String[] idList = idPool.split(COMMA);
        //二分法查找目标id所在的区间(变异二分法)
        int index = getIndexByDichotomySearch(idList, targetId);

        // 到对应的区间获取资源
        AllocateResult result = allocateId(targetId, idList[index]);
        if (!result.isResult()) {
            System.out.println("id is not in pool");
            throw new IllegalAccessException();
        }
        StringBuilder builder = new StringBuilder();
        for(int i = 0; i < index; i++) {
            builder.append(idList[i]).append(COMMA);
        }
        if (!"".equals(result.getStr())) {
            builder.append(result.getStr()).append(COMMA);
        }
        for(int i = index + 1; i < idList.length - 1; i++) {
            builder.append(idList[i]).append(COMMA);
        }
        builder.append(idList[idList.length - 1]);
        idPool = builder.toString();
        return targetId;
    }

    private AllocateResult allocateId(int targetId, String s) {
        AllocateResult result = new AllocateResult();
        if (!s.contains(CONN)) {
            if (targetId == Integer.parseInt(s)) {
                result.setResult(true);
                result.setStr("");
            }
            return result;
        }
        int start = getStart(s);
        int end = getEnd(s);
        if (start > targetId || end < targetId) {
            return result;
        }

        result.setResult(true);
        if (start == targetId) {
            start++;
            if (start == end) {
                result.setStr(String.valueOf(end));
            } else {
                result.setStr(start + CONN + end);
            }
            return result;
        }
        if (end == targetId) {
            end--;
            if (start == end) {
                result.setStr(String.valueOf(end));
            } else {
                result.setStr(start + CONN + end);
            }
            return result;
        }
        int tempStart = targetId + 1;
        int tempEnd = targetId - 1;
        StringBuilder builder = new StringBuilder();
        builder.append(start);
        if (start != tempEnd) {
            builder.append(CONN).append(tempEnd);
        }
        builder.append(COMMA);
        if (tempStart != end) {
            builder.append(tempStart).append(CONN);
        }
        builder.append(end);
        result.setStr(builder.toString());
        return result;
    }

    private int getIndexByDichotomySearch(String[] idList, int targetId) {
        int start = 0;
        int end = idList.length - 1;
        int middleByEnd = 0;
        while (start <= end) {
            middleByEnd = (start + end) / 2;
            int temp = getEnd(idList[middleByEnd]);
            if (temp == targetId) {
                return middleByEnd;
            } else if (temp < targetId) {
                start = middleByEnd + 1;
            } else {
                end = middleByEnd - 1;
            }
        }

        int start1 = 0;
        int end1 = idList.length - 1;
        int middleByStart = 0;
        while (start1 <= end1) {
            middleByStart = (start1 + end1) / 2;
            int temp = getStart(idList[middleByStart]);
            if (temp == targetId) {
                return middleByStart;
            } else if(temp < targetId) {
                start1 = middleByStart + 1;
            } else {
                end1 = middleByStart - 1;
            }
        }
        // targetId必然比middleByStart位置的开头小，必然比middleByEnd的结尾大；
        // System.out.println("startIndex is " + middleByStart + "; endIndex is " + middleByEnd);
        return (middleByEnd + middleByStart) / 2 ;
    }

    private int getEnd(String s) {
        if (!s.contains(CONN)) {
            return Integer.parseInt(s);
        }
        String[] strs = s.split(CONN);
        return Integer.parseInt(strs[1]);
    }

    private int getStart(String s) {
        String[] strs = s.split(CONN);
        return Integer.parseInt(strs[0]);
    }


    //自由分配Id，选取最小值
    public int getId() throws IllegalAccessException {
        if("".equals(idPool)) {
            System.out.println("id pool is empty.");
            throw new IllegalAccessException();
        }

        String[] idList = idPool.split(COMMA);
        String allocateStr = idList[0];
        String[] allocateStrs = allocateStr.split(CONN);
        int result = Integer.parseInt(allocateStrs[0]);
        String tempStr = "";
        if (allocateStrs.length != 1) {
            tempStr = allocateStrs[1];
            int end = Integer.parseInt(tempStr);
            if (end != result + 1) {
                tempStr = (result + 1) + CONN + tempStr;
            }
        }

        if (idList.length == 1) {
            idPool = tempStr;
            return result;
        }
        StringBuilder builder;
        if ("".equals(tempStr)) {
            builder = new StringBuilder(idList[1]);
        } else {
            builder = new StringBuilder(tempStr).append(COMMA).append(idList[1]);
        }

        for(int j = 2; j < idList.length; j++) {
            builder.append(COMMA).append(idList[j]);
        }

        idPool = builder.toString();
        return result;
    }

    public String getIdPool(){
        return idPool;
    }
}


class AllocateResult {
    private boolean result;
    private String str;

    public boolean isResult() {
        return result;
    }

    public void setResult(boolean result) {
        this.result = result;
    }

    public String getStr() {
        return str;
    }

    public void setStr(String str) {
        this.str = str;
    }
}
ShaoZG_金刚钻
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
无服务架构的概念、特点和优缺点 & 资源分配的两种方式：静态分配和动态分配
禅与计算机程序设计艺术
09-14 2180
无服务架构（Serverless）通常指的是一种应用部署模型，即将应用的代码、运行环境及依赖包打包到云函数提供商处的容器中执行，由平台自动按需弹性伸缩计算资源，并按月或按量计费。Serverless架构可以降低运营成本，提升开发效率，优化资源利用率。不过在实际使用过程中也存在很多复杂的问题，比如功能上线时间过长，占用资源过多等，这些都需要我们考虑如何处理好，尤其是在对关键业务进行优化时更为重要。
android 获取手机内存及 内存可用空间的方法
08-31
总结来说，通过`StatFs`类提供的方法，我们可以轻松地获取Android设备的内部存储和SD卡的可用空间。这个信息对于监控应用的存储需求，优化资源管理，以及向用户提供有关设备状态的反馈非常有用。确保正确处理权限...
String的存储方式
一只路过的小码农
10-08 6030
String的存储方式，StringBuffer与StringBuilder的区别
String字符串的存储原理
weixin_43486332的博客
07-22 1217
1.String表示字符串类型，属于引用数据类型，不属于基本数据类型 2.在java中用双引号括起来的都是String对象：例如:"abc","def","hello world","你好" 3.java中规定，双引号括起来的字符串，是不可变的，也就是说"abc"到最终死亡，不可变，不能变成"abcd",也不能变成"ab" 4.在JDk当中双引号括起来的字符串，例如"abcd"都直接存储在方法区的"字符串常量池"当中的。 5.凡是双引号括起来的都在字符串常量池中有一份。 6.为什么SUN公司把字符串存储在.
[朝花夕拾]C++ string 内存增长策略
心若微尘的博客
01-19 1588
    朝花夕拾系列缘起 时光荏苒，转眼已经毕业三年多了，而在这三年中，自己得过且过，在技术上45并无长足的长进，并且还把以往学过的知识忘记的差不多了，因此有了这个朝花夕拾的系列。寄希望于在写这些文档的同时，加深自己对C++技术的认识，并且建立梳理下自己的知识体系。 今天算是这个系列中的第一期，先剖析下C++ STL 的string类的内存增长策略，这个问题经常在面试的时候被提及，我一般都...
java获取String ID
狼魂之力
06-19 772
package com.system.utils; import java.util.UUID; public class UuidUtil { public static String get32UUID() { String uuid = UUID.randomUUID().toString().trim().replaceAll("-", ""); return uuid; } public static void main(String[] args) { System
java中 id是怎么写_[转]Java里的字符串, String类简单介绍
weixin_34392923的博客
02-24 733
一, Java里的字符串.首先声明:1.1 字符串跟String类是不同的概念本文涉及两个重点, 1个是字符串, 1个是String类. 它们虽然有联系, 但是却是完全不同的两个概念!我们可以参考jdk api中文里对String类的解释:public final classStringextendsObjectimplementsSerializable, Comparable, Cha...
Slurm如何管理和使用节点资源
h_m_l的博客
10-31 9935
Slurm管理和使用集群节点资源主要分为四个环节：分别是初始化节点资源、更新节点资源、测试节点资源可用、实际分配节点资源。 1.初始化节点资源 slurmctld初始化时解析节点配置文件，借助几个全局数据结构（select插件中也有几个数据结构）： node_record_table_ptr 节点数组，保存所有节点描述符 node_hash...
redis教程介绍以及要点和难点.zip
05-28
1. 数据类型：Redis提供了五种基本数据类型，包括字符串(String)、哈希(Hash)、列表(List)、集合(Set)和有序集合(Sorted Set)，这些数据类型为开发人员提供了多种存储和操作数据的方式。 2. 键空间(Key Space)：...
2_Windows_Azure_计算和存储
03-20
- **大小** (`sizeInMB`)：指定分配给本地存储资源的空间大小。 - **清理设置** (`cleanOnRoleRecycle`)：确定在角色回收时是否清除本地存储数据。 - **访问本地存储**：使用 `RoleEnvironment.GetLocalResource` ...
Android内存使用情况的应用实例
01-20
总结起来，通过上述应用实例，我们可以学习到如何在Android应用中查询和显示内存信息，这有助于我们在开发过程中更好地理解和管理内存资源。同时，了解并实践内存管理是提高应用性能、避免内存泄漏和提升用户满意度...
redis详细笔记，包含面试常见问题
05-12
1. 数据类型：Redis提供了五种基本数据类型，包括字符串(String)、哈希(Hash)、列表(List)、集合(Set)和有序集合(Sorted Set)。这些数据类型覆盖了多种常见的数据操作需求。 2. 持久化：Redis提供了RDB（快照）和...
android中java代码中通过资源id加载String方法
执迷不悔
12-19 1258
使用progress时提示不能使用资源id，找了个方法通过id拿到String string hint=this.getString(R.string.loading_hint);
JAVA进阶补充
最新发布
2301_80150315的博客
08-15 541
概念：把已经有的方法拿过来用，当作函数式接口中抽象方法的方法体条件：引用处必须是函数式接口被引用的方法需要已经存在被引用方法的形参和返回值需要跟抽象方法的形参和返回值保持一致被引用方法的功能需要满足当前需求：方法引用符意义：就是为让控制台的报错信息更加的见名知意自定义异常的步骤：定义异常类写继承关系空参构造带参构造​file对象就表示一个路径，可以是文件的路径、也可以是文件夹的路径；这个路径可以是存在的，也允许是不存在的构造方法描述根据文件路径创建对象。
进程间通信 ---共享内存
BUG制造机的博客
08-14 864
在这篇文章中向大家介绍了共享内存的原理以及常用的指令函数，希望大家有所收获！😁。
SpringBoot快速入门（手动创建）
m0_74124657的博客
08-11 535
代码如下//引导类项目的入口//注解添加导入进来你可以浏览器中查看自己编写的代码，看是否正确localhost：你命名的端口号（默认是8080。后面你也可以在配置文件修改）
Java Spring|day3.SpringBoot
weixin_60364343的博客
08-15 241
告诉Spring boot需要什么功能,它就能引入需要的依赖库起步依赖就是特殊的Maven依赖，利用了传递依赖解析，把常用库聚合在一起，组成几个为特定功能而定制的依赖。
集合（1）
supercool7的博客
08-12 819
表示不同的类型集合，Collection、Map、List、Set、Queue、Deque等，以及辅助性质的接口Iterator、LinkIterator、Comparator、Comparable这些接口是为迭代和比较元素而准备。对接口的具体实现，主要常用的有：ArrayList、LinkedList、HashMap、HashSet、TreeMap等等。理解Java集合体系可以从三个层次：最上层的接口、中间的抽象类、最后的实现类。是所有集合框架的根接口，包含了对集合进行基本操作的方法。
【Markdown】Markdown 中的语言简称
EleganceJiaBao的博客
08-12 927
以下是常见编程语言、脚本语言、标记语言等在 Markdown 中的语言简称以及相应的示例：
C++ string详解与常用操作
C++流（如iostream和fstream）与String紧密集成，允许在输入/输出操作中直接使用字符串。这对于文件读写、用户输入等场景非常有用。 1.8 格式化字符串： C++提供多种方式格式化字符串，如C语言风格的printf函数、...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值