经典内存池c++源代码分享及性能对比研究

最新推荐文章于 2023-01-11 10:11:19 发布
最新推荐文章于 2023-01-11 10:11:19 发布
阅读量450 收藏 3
点赞数
分类专栏： 编程 文章标签： c++ 内存池
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/carlclouder/article/details/101264830
版权

最近在写一个IOCP扩展类，遇到内存池问题，网上的完整代码不多，可惜没钱下载，只能自己研究了，自己写了份代码，实现了基本功能，自动增加内存块，可实现较大吞吐量。代码分享出来，请大家交流，帮助优化。目前还只能实现单个对象的管理，大神请指点。

先来看性能对比结果，见下图（代码在后面，可能微博识别的原因导致贴上来后代码有些错误，自己调整）：
Release模式下，反复循环处理总计5200万个对象，传统new/delete操作花4.29秒，内存池操作花2.1秒，大约是传统new/delete一半时间（若测试方案不同，测试规模增大，速度优势越明显）。
本例中，内部维护了64个块（每个块5mb），总计320Mb，可用单元524万个单元，已用了161万个单元，内存池的内存使用情况和结构由dumpInfo输出，
在这里插入图片描述

在这里插入图片描述

头文件：

#pragma once

#ifndef __CL_OBJMEMPOOL_H__
#define __CL_OBJMEMPOOL_H__

//内部锁类，基类
class CLCSLock
{
public:
    CLCSLock(void);
    ~CLCSLock(void);
    //主锁，请用于线程队列的增加删除操作
    void lock();
    void unLock();

protected:
private:
    CRITICAL_SECTION *m_cs = 0;
};

template <</span>typename classTag>
class CLObjMenBlock;

template <</span>typename classTag>
class CLObjMenPool;

//内存池对象单元模板类
template <</span>typename classTag>
class CLObjMenUnitInfo
{
    friend class CLObjMenPool;
    friend class CLObjMenBlock;
    friend class CLObjMenUnitInfo;
public:
    classTag data;
protected:
    CLObjMenUnitInfo *pPre;
    CLObjMenUnitInfo *pNext;
    CLObjMenBlock *pThisBlock;
    //在构造时候显示调用
    CLObjMenUnitInfo *init(
        CLObjMenBlock *_pThisBlock = 0,
        CLObjMenUnitInfo *_pPre = 0,
        CLObjMenUnitInfo *_pNext = 0)
    {
        pThisBlock = _pThisBlock;
        pPre = _pPre;
        pNext = _pNext;
        return this;
    }
};

//内存池内存块对象模板类
template <</span>typename classTag>
class CLObjMenBlock
{
    friend class CLObjMenPool;
    friend class CLObjMenBlock;
    friend class CLObjMenUnitInfo;
protected:
    CLObjMenBlock(DWORD_PTR PerBlockMemCapacity_MB)
    {
        init();
        alloc(PerBlockMemCapacity_MB * 1024 * 1024 / sizeof(CLObjMenUnitInfo));
    }
    ~CLObjMenBlock()
    {
        release();
        init();
    }
    //判断该内存块是否存在可用单元
    inline BOOL isUsable()
    {
        return pUsableLst ? TRUE : FALSE;
    }
    //将对象指针回收进入内存块单元
    CLObjMenUnitInfo *freeOneData(CLObjMenUnitInfo *pUnit)
    {
        assert(pUnit != NULL);
        //执行对象析构
        (&(pUnit->data))->classTag::~classTag();
        return putToUsable(pUnit);
    }
    //取出一个待命可用的对象单元，返回其构造后的对象指针
    classTag *getOneData()
    {
        assert(pUsableLst != NULL);
        //执行对象默认构造
        pUsableLst->CLObjMenUnitInfo::CLObjMenUnitInfo();
        return putToUnusable(pUsableLst);
    }

    inline void init()
    {
        pUsableLst = 0;
        nMaxUsable = 0;
        pUnusableLst = 0;
        nMaxUnusable = 0;
        pPreBlock = 0;
        pNextBlock = 0;
        pMainDataLst = 0;
        nMaxDataCounts = 0;
    }
    //分配内存
    void alloc(DWORD_PTR unitCounts = 1)
    {
        assert(pMainDataLst == 0 && pUsableLst == 0 && pUnusableLst == 0);
        if (pMainDataLst == 0)
        {
            //第一次申请内存空间
            pMainDataLst = (CLObjMenUnitInfo *)malloc(sizeof(CLObjMenUnitInfo) * (nMaxDataCounts = nMaxUsable = (unitCounts == 0 ? 1 : unitCounts)));
            //第一次执行可用队列的初始化连接工作
            pUsableLst = &pMainDataLst[0];
            pMainDataLst[0].init(this, 0, nMaxDataCounts <= 1 ? 0 : &pMainDataLst[1]);
            for (DWORD_PTR i = 1; i < nMaxDataCounts - 1; i++)
            {
                pMainDataLst[i].init(this, &pMainDataLst[i - 1], &pMainDataLst[i + 1]);
            }
            pMainDataLst[nMaxDataCounts - 1].init(this, nMaxDataCounts <= 1 ? 0 : &pMainDataLst[nMaxDataCounts - 2], 0);
        }
    };
    //释放内存
    void release()
    {
        if (pMainDataLst)
        {
            //析构所有已使用的对象
            for (CLObjMenUnitInfo *pc = pUnusableLst; pc != NULL; )
            {
                pUnusableLst = freeOneData(pc);
                pc->init();
                pc = pUnusableLst;
            }
            //释放动态内存
            free(pMainDataLst);
            pMainDataLst = 0;
        }
    }
    //对象放入可用队列头，返回不可用队列头指针
    CLObjMenUnitInfo  *putToUsable(CLObjMenUnitInfo *pUnit)
    {
        assert(this == pUnit->pThisBlock);
        //处理不可用列表头
        if (pUnusableLst && pUnusableLst == pUnit)
            pUnusableLst = pUnit->pNext;

        //处理前后连接,隔离对象
        extruct(pUnit);

        //接入可用列表
        if (pUsableLst)
        {
            pUsableLst->pPre = pUnit;
        }
        pUnit->pNext = pUsableLst;
        pUnit->pPre = 0;
        pUsableLst = pUnit;
        nMaxUnusable -= 1;
        nMaxUsable += 1;
        return pUnusableLst;

    }
    //返回可用对象指针
    classTag  *putToUnusable(CLObjMenUnitInfo *pUnit)
    {
        assert(this == pUnit->pThisBlock);
        //处理可用列表头
        if (pUsableLst && pUsableLst == pUnit)
            pUsableLst = pUnit->pNext;

        //处理前后连接,隔离对象
        extruct(pUnit);

        //接入不可用列表
        if (pUnusableLst)
        {
            pUnusableLst->pPre = pUnit;
        }
        pUnit->pNext = pUnusableLst;
        pUnit->pPre = 0;
        pUnusableLst = pUnit;
        nMaxUnusable += 1;
        nMaxUsable -= 1;
        return &pUnit->data;
    }
    //处理前后连接,隔离对象
    inline void extruct(CLObjMenUnitInfo *pUnit)
    {
        if (pUnit->pPre)
        {
            pUnit->pPre->pNext = pUnit->pNext;
        }
        if (pUnit->pNext)
            pUnit->pNext->pPre = pUnit->pPre;
    }


    CLObjMenUnitInfo *pMainDataLst;
    DWORD_PTR nMaxDataCounts;
    CLObjMenUnitInfo *pUsableLst;
    DWORD_PTR nMaxUsable;
    CLObjMenUnitInfo *pUnusableLst;
    DWORD_PTR nMaxUnusable;
    CLObjMenBlock *pPreBlock;
    CLObjMenBlock *pNextBlock;
};

//内存池对象模板类
template <</span>typename classTag>
class CLObjMenPool
{
    friend class CLObjMenPool;
    friend class CLObjMenBlock;
    friend class CLObjMenUnitInfo;
public:
    CLObjMenPool(DWORD_PTR PerBlockMemCapacity_MB = 5)
    {
        setPerBlockMemCapacity(PerBlockMemCapacity_MB);
        pEntry = 0;
        pCurrentUsingBlock = 0;
    }
    ~CLObjMenPool()
    {
        for (CLObjMenBlock *pi = pEntry; pi != NULL; )
        {
            pCurrentUsingBlock = pi->pNextBlock;
            delete pi; // 释放块
            pi = pCurrentUsingBlock;
        }
        m_PerBlockMemCapacity = 0;
        pEntry = 0;
        pCurrentUsingBlock = 0;
    }
    //向内存池动态申请一个对象，构造并返回其指针
    classTag *newOne()
    {
        if (pEntry == NULL)
        {
            pCurrentUsingBlock = pEntry = new CLObjMenBlock(m_PerBlockMemCapacity);
        }
        CLObjMenBlock *pStartBlock = pCurrentUsingBlock;
        //检索可用的块
        for (; pCurrentUsingBlock->isUsable() == FALSE;)
        {
            if (pCurrentUsingBlock->pNextBlock == NULL)
            {
                if (pCurrentUsingBlock != pEntry)
                {
                    pCurrentUsingBlock = pEntry;
                }
                else
                {
                    pStartBlock = new CLObjMenBlock(m_PerBlockMemCapacity);
                    if (pEntry->pNextBlock)
                        pEntry->pNextBlock->pPreBlock = pStartBlock;
                    pStartBlock->pNextBlock = pEntry->pNextBlock;
                    pEntry->pNextBlock = pStartBlock;
                    pCurrentUsingBlock = pStartBlock;
                }
            }
            else if (pCurrentUsingBlock->pNextBlock == pStartBlock)  //插入新块，在队列中
            {
                pStartBlock = new CLObjMenBlock(m_PerBlockMemCapacity);
                if (pCurrentUsingBlock->pNextBlock)
                    pCurrentUsingBlock->pNextBlock->pPreBlock = pStartBlock;
                pStartBlock->pNextBlock = pCurrentUsingBlock->pNextBlock;
                pCurrentUsingBlock->pNextBlock = pStartBlock;
                pCurrentUsingBlock = pStartBlock;
            }
            else pCurrentUsingBlock = pCurrentUsingBlock->pNextBlock;
        }
        return pCurrentUsingBlock->getOneData();
    }
    //向内存池释放一个动态申请的对象，进行相关析构操作
    void deleteOne(CLObjMenUnitInfo *pDelete)
    {
        assert(pDelete->pThisBlock != NULL);
        pDelete->pThisBlock->freeOneData(pDelete);
    }
    //设置单个内存块的大小，单位MB，默认5MB
    void setPerBlockMemCapacity(DWORD_PTR PerBlockMemCapacity_MB = 5)
    {
        m_PerBlockMemCapacity = PerBlockMemCapacity_MB == 0 ? 1 : PerBlockMemCapacity_MB;
    }
    //统计内存使用量，并控制向控台输出当前内存池的内存使用情况。
    //bLog = TRUE表示输出信息到控制台否则只统计内存使用量，bDeTail = FALSE表示采用简化输出
    DWORD_PTR dumpInfo(BOOL bLog = TRUE, BOOL bDeTail = FALSE)
    {
        if (bLog)
        {
            if (bDeTail)
                _tprintf_s(_T("\n>>The Memmery pool dumper detail--------------------------------- \n\n>>MemBlock Info:\n"));
            else
                _tprintf_s(_T("\n>>The Memmery pool dumper simple--------------------------------- "));
        }
        size_t si = 0;
        size_t siu = 0;
        size_t sit = 0;
        for (const CLObjMenBlock *pc = pEntry; pc; )
        {
            si++;
            siu += pc->nMaxUnusable;
            sit += pc->nMaxDataCounts;
            size_t n = pc->nMaxDataCounts == 0 ? 0 : ((double)pc->nMaxUnusable) / pc->nMaxDataCounts * 50.0;
            if (bLog && bDeTail)
            {
                _tprintf_s(_T(">>MemBlock(%zd): ["), si);
                for (size_t i = 0; i < 50; i++)
                {
                    if (i < n)_tprintf_s(_T("*"));
                    else _tprintf_s(_T("-"));
                }
                _tprintf_s(_T("] \n"), n * 2);
            }
            pc = pc->pNextBlock;
        }
        DWORD_PTR perObj = sizeof(CLObjMenUnitInfo);
        DWORD_PTR mem = perObj * sit + si * sizeof(CLObjMenBlock);
        if (bLog)
        {
            DWORD_PTR Tb = 0, Gb = 0, Mb = 0, Kb = 0, Byte = 0;
            Kb = mem / 1024;
            Byte = mem % 1024;
            Mb = Kb / 1024;
            Kb = Kb % 1024;
            Gb = Mb / 1024;
            Mb = Mb % 1024;
            Tb = Gb / 1024;
            Gb = Gb % 1024;
            if (Tb > 0)
                _tprintf_s(_T("\n>>Summary: mem=%zdT %zdG %zdM %zdK %zdB, blocks=%zd, total=%zd, used=%zd.\n"), Tb, Gb, Mb, Kb, Byte,  si, sit, siu);
            else if (Gb > 0)
                _tprintf_s(_T("\n>>Summary: mem=%zdG %zdM %zdK %zdB, blocks=%zd, total=%zd, used=%zd.\n"), Gb, Mb, Kb, Byte,  si, sit, siu);
            else if (Mb > 0)
                _tprintf_s(_T("\n>>Summary: mem=%zdM %zdK %zdB, blocks=%zd, total=%zd, used=%zd.\n"), Mb, Kb, Byte,  si, sit, siu);
            else if (Kb > 0)
                _tprintf_s(_T("\n>>Summary: mem=%zdK %zdB, blocks=%zd ,total=%zd, used=%zd.\n"), Kb, Byte,  si, sit, siu);
            else
                _tprintf_s(_T("\n>>Summary: mem=%zdB, blocks=%zd, total=%zd, used=%zd.\n"), Byte,  si, sit, siu);
        }
        return mem;
    }
protected:
    CLObjMenBlock *pEntry;
    CLObjMenBlock *pCurrentUsingBlock;
    DWORD_PTR m_PerBlockMemCapacity;
};

//全局的安全锁
extern CLCSLock _g_memPoolGLock;
//全局的安全锁
inline CLCSLock &getGlobleMemPoolLocker()
{
    return _g_memPoolGLock;
}
//取得类型对应的内存池对象
template <</span>typename classTag>
CLObjMenPool *getMenPool()
{
    static CLObjMenPool _MenPool;
    return &_MenPool;
}
//向内存池动态申请一个对象，返回对象指针。对应的，该指针必须用deleteOne释放
template <</span>typename classTag>
classTag *newOne()
{
    getGlobleMemPoolLocker().lock();
    classTag *rt = getMenPool()->newOne();
    getGlobleMemPoolLocker().unLock();
    assert(rt != NULL);
    return rt;

}
//将由newOne获得的对象指针释放回内存池，会做相关析构操作
template <</span>typename classTag>
void deleteOne(classTag *pDelete = 0)
{
    assert(pDelete != NULL);
    getGlobleMemPoolLocker().lock();
    getMenPool()->deleteOne((CLObjMenUnitInfo *)pDelete);
    getGlobleMemPoolLocker().unLock();
}
//设置内存池中内存块当个最大内存占用大小，单位MB
template <</span>typename classTag>
void setMemPoolBlockCapacity(DWORD_PTR mb = 5 )
{
    assert(mb != 0);
    getGlobleMemPoolLocker().lock();
    getMenPool()->setPerBlockMemCapacity(mb);
    getGlobleMemPoolLocker().unLock();
}

#endif

cpp文件：

#include"CLObjectMemPool.h"

//全局唯一的线程池锁对象
CLCSLock _g_memPoolGLock;

CLCSLock::CLCSLock(void)
{
    if (m_cs == 0)
    {
        m_cs = new CRITICAL_SECTION;
        if (m_cs) InitializeCriticalSection(m_cs);
        else throw std::logic_error("CriticalSection didn't alloc!");
    }
}

CLCSLock::~CLCSLock(void)
{
    if (m_cs)
    {
        DeleteCriticalSection(m_cs);
        delete m_cs;
        m_cs = 0;
    }
}

void CLCSLock::lock()
{
    if(m_cs)EnterCriticalSection(m_cs);
    else throw std::logic_error("CriticalSection didn't alloc!");
}

void CLCSLock::unLock()
{
    if (m_cs)LeaveCriticalSection(m_cs);
    else throw std::logic_error("CriticalSection didn't alloc!");
}

测试代码，其中CLString是我自定义的一个类：

int main()  
{
    _tprintf_s(_T("\n Mem Pool Test: "));

    size_t mb = 200;//单次连续申请内存200 MB
    size_t cycleTimes = 10;//循环次数
    size_t si = (double)mb * 1024 * 1024 / sizeof(CLString);

    PCLString *plst = new PCLString[si];
    ZeroMemory(plst, si * sizeof(PCLString));

    ULONGLONG st = GetTickCount64();
    for (size_t j = 0; j < cycleTimes; j++)
    {
        for (size_t i = 0; i < si; i++)
        {
            if (plst[i] == 0) plst[i] = new CLString;
        }
        for (size_t i = 0; i < si; i++)
        {
            if (plst[i] != 0)delete plst[i];
            plst[i] = 0;;
        }
    }
    ULONGLONG et = GetTickCount64();

    ZeroMemory(plst, si * sizeof(PCLString));

    //设置单个块最大10Mb
    //setMemPoolBlockCapacity(10);
    ULONGLONG st2 = GetTickCount64();
    for (size_t j = 0; j < cycleTimes; j++)
    {
        for (size_t i = 0; i < si; i++)
        {
            if (plst[i] == 0)plst[i] = newOne();
        }
        for (size_t i = 0; i < si; i++)
        {
            if (plst[i] != 0)deleteOne(plst[i]);
            plst[i] = 0;
        }
    }
    ULONGLONG et2 = GetTickCount64();

    _tprintf_s(_T("\n\n对比结果: 处理对象数 = %zd, new/delete操作 = %zdms, MemPool操作 = %zdms. \n\n"), si * cycleTimes, et - st, et2 - st2);

    for (size_t i = 0; i < si / 3.25; i++)
    {
        if (plst[i] == 0)plst[i] = newOne();
    }
    getMenPool()->dumpInfo(1, 1); //采用详细输出
    for (size_t i = 0; i < si / 3.25; i++)
    {
        if (plst[i] != 0)deleteOne(plst[i]);
        plst[i] = 0;
    }
    delete[] plst;
    return 0;
}
夜雨清狂
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【内存】内存分配和内存池 性能优化
bandaoyu的note
08-13 1115
C++几种内存分配方法的效率测试与比较 这几天做的一个项目要频繁new许多对象，对于频繁调用new对效率的影响只停留在理论上，没有一个直观的认识，故做了一个小测试。本次测试只对比了三种内存分配方式： 1. 频繁调用new 2. 一次性new足够的内存，再用placement new产生对象到已分配的内存 3. 用vector 测试代码如下 （注意事项：vs下x86和x64、debug、release配置下运行效果不一样，gcc编译时，一些二外的debug编译参数也会影响速度） #includ
【C++内存管理源码解读】
小呆鸟blog
07-10 378
SGI STL的空间配置器与众不同，且与STL标准规范不同。SGI STL的每一个容器都已经指定缺省的空间配置器是alloc。对于new来说，编译器会先调用::operator new分配内存；然后调用Obj::Obj()构造对象内容。对于delete来说，编译器会先调用Obj::~Obj()析构对象；然后调用::operator delete释放空间。标准STL allocator决定将这两个阶段操作区分开来。对象构造由::construct()负责；对象释放由::destroy()负责。
RT-Thread系列--内存池MEMPOOL源码分析
coderma的博客
01-11 674
RT-Thread之MEMPOOL源码解析
SGI STL内存池源码剖析
林主席的博客
11-13 367
SGI STL内存池源码理解，附代码
一文看懂Ngnix内存池源码 附带详细讲解，清晰结构图
哇咔咔的博客
06-28 853
可以先看一下大概过程： 首先Ngnix内存池分为主内存池和其他内存池，主内存用来管理其他内存池，和自身初始具有的能够分配的内存。 **但主内存池和其他内存池在结构定义上是一样的，**都是下面代码块中的 ，**且具有别名 ，**只不过其他内存池再被创建的时候，会被分割，将除去成员 以外的部分作为可分配内存。如下图所示，图中主内存池和其他内存池在大小上可能具有迷惑性，但实际上主内存池和其他内存池所占的大小是一样的，只不过可分配内存不一样。 这里是各结构体中的关系： 是一个分流函数，按一个标准分割大块内存分配
C++ 吃豆子游戏 教程及源代码
06-02
而"pacman"可能是指源代码文件，包含了游戏的实现细节。 在C++中实现吃豆子游戏，我们需要以下几个关键知识点： 1. **图形库**：为了创建GUI，我们可以使用SDL（Simple DirectMedia Layer）或SFML（Simple and ...
C++内存监控源代码
11-12
本资源提供的"C++内存监控源代码"是一个用于辅助开发者的实用工具，它具有内存修改功能，能帮助我们深入理解并优化C++程序的内存使用。 首先，C++内存监控通常包括以下几个核心功能： 1. **内存分配记录**：记录每...
【STL源代码】C++标准库STL源代码下载
09-05
阅读STL源代码可以帮助我们理解C++容器和算法的底层实现，从而优化自己的代码，提高程序性能。同时，也能让我们更好地掌握C++模板机制，以及如何利用泛型编程来编写高效且可复用的代码。通过分析源码，我们可以学习...
C++ STL库源代码(SGI版本)
最新发布
06-04
通过深入研究这些源代码，开发者可以理解STL的内部工作机制，提升编写高效C++代码的能力。这不仅有助于优化程序性能，也能帮助开发者遵循C++的设计原则，比如使用泛型编程和资源管理。此外，对于那些想要实现自己...
c++学习练习源代码
04-12
13. **C++11及更高版本的新特性**: 如auto关键字、lambda表达式、右值引用、move语义等，如果作者在学习过程中接触到了这些新特性，源代码中也可能有所体现。 通过分析和运行这些源代码，学习者不仅可以理解C++的...
几种内存池的实现(c/c++ 源码)
07-25
几种 内存池 的实现 (c/c++ 源码)
MemPool内存池源码
02-08
是一个windows内存池的源码。基于模板实现，支持多线程操作。
C++内存池完整代码memory_pool.rar
01-03
C++ 内存池完整 memory_pool
C++内存池完整代码memory_pool.zip
04-03
C++内存池完整代码memory_pool Makefile
c++ 内存池技术实现
06-02
c++ 内存池技术实现 源码 应用程序可以通过系统的内存分配调用预先一次性申请适当大小的内存作为一个内存池，之后应用程序自己对内存的分配和释放则可以通过这个内存池来完成。只有当内存池大小需要动态扩展时，才需要再调用系统的内存分配函数，其他时间对内存的一切操作都在应用程序的掌控之中。
C++内存池(附源码)
wang13342322203的博客
08-09 424
C++内存池(附源码) 前段时间阅读了Nginx的源码，其对内存高效的管理给我留下了深刻的印象，而内存管理的核心便是内存池。于是想自己实现一个C++版本的内存池，这方面当然还是STL的内存池最为经典，所以免不了参悟借鉴。内存池的概念早已经是老生常谈，然而把内存池实现的高效安全仍是个比较艰巨的问题。内存池的原理简单来讲就是一次性的向系统申请大量的内存，之后再有内存请求的时候，如果内存池的内存大小能够...
C++语法学习笔记六十五：内存池概念、代码实现和详细分析
哲学天空的博客
08-30 185
实例代码： #include <iostream> #include <vector> #include <ctime> using namespace std; namespace _nmsp1 //命名空间 { //一：内存池的概念和实现原理概述 //malloc：内存浪费，频繁分配小块内存，则浪费更加显得明显 //“内存池”，要解决什么问题？ //(1)减少malloc的次数，减少malloc()调用次数就意味着减少对内存的浪费 //(2)减少mall
c++内存池实现
热门推荐
neustar1的专栏
04-19 1万+
利用C/C++开发大型应用程序中，内存的管理与分配是一个需要认真考虑的部分。 本文描述了内存池设计原理并给出内存池的实现代码，代码支持Windows和Linux，多线程安全。 内存池设计过程中需要考虑好内存的分配与释放问题，其实也就是空间和时间的矛盾。 有的内存池设计得很巧妙，内存分配与需求相当，但是会浪费过多的时间去查找分配与释放，这就得不偿失； 实际使用中，我们更多的是关心内存分配的速
C++：中级语言特性与内存操作详解
C++程序的编译和解释是两种常见的执行方式：编译是在所有源代码完成后进行，通过编译器将高级代码转换为机器指令，这个过程可能涉及到代码优化；而解释则是逐行执行源代码，虽然实时性较好但不利于整体优化和性能...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值