官方bilibiliWindows破解入门Android逆向入门
【网络诊断修复工具】切换到窄版

吾爱破解 - 52pojie.cn

 找回密码
 注册[Register]

QQ登录

只需一步，快速开始

吾爱破解 - 52pojie.cn»网站 › 【 软件安全 】 › 『编程语言区』 › 内存清理加速球（类似360的加速球） C#界面 c++dll
返回列表 发新帖
查看: 819|回复: 8
收起左侧

[其他原创] 内存清理加速球（类似360的加速球） C#界面 c++dll

[复制链接]
hszt
hszt 发表于 2026-4-30 16:08
本帖最后由 hszt 于 2026-4-30 16:29 编辑

这个是因为自己想用360的那个内存加速球，但又不想安装360，于是自己（用AI）写了一个类似的，
分享给大家用  C#和c++写的。也可以当做一个简单的任务管理器来用，
模仿了任务管理器部分常用的功能，显示前台和后台程序，可以结束进程或打开文件位置，比任务管理器增加一个功能，显示进程路径，方便看是哪个软件的进程
源代码https://github.com/wojiukankan8/MemoryBooster
编译后的下载地址：https://wwaoc.lanzoub.com/iCSSA3obl4xc
1、软件依赖net运行库，如果打不开，需要安装net 4.5以上版本，推荐net4.8，如果没有可以在微软官网下载

2、简单使用：
软件启动后靠右边隐藏，显示了部分，鼠标放上去后会显示，刚启动的20秒不隐藏
    双击，单击加速清理内存
    右键点击加速球显示主面板
   
   在进程列表可以右键结束单个进程，也可以勾选多个，点击按钮，结束进程
3、在设置里面可以设置开机启动，最小化到托盘图标
平时就只靠右边显示这个加速球，鼠标靠过去就可以显示，点右键出现功能界面 图片.png
图片.png 图片.png 图片.png

[C++] 纯文本查看 复制代码
#define MEMORYCORE_EXPORTS
#define WIN32_LEAN_AND_MEAN
#define _WINSOCK_DEPRECATED_NO_WARNINGS

#include "MemoryCore.h"

// Winsock headers must precede windows.h to avoid the legacy winsock.h pull-in.
#include <winsock2.h>
#include <ws2tcpip.h>
#include <ws2ipdef.h>
#include <in6addr.h>

#include <windows.h>
#include <psapi.h>
#include <tlhelp32.h>
#include <iphlpapi.h>
#include <tcpmib.h>
#include <udpmib.h>
#include <tcpestats.h>
#include <string.h>

#include <map>
#include <unordered_map>
#include <vector>
#include <mutex>

#pragma comment(lib, "psapi.lib")
#pragma comment(lib, "iphlpapi.lib")
#pragma comment(lib, "ws2_32.lib")

/* ====================================================================== */
/* Memory Cleaning                                                        */
/* ====================================================================== */

MEMCORE_API int CleanAllWorkingSets()
{
    int cleaned = 0;
    HANDLE hSnap = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
    if (hSnap == INVALID_HANDLE_VALUE) return 0;

    PROCESSENTRY32W pe;
    memset(&pe, 0, sizeof(pe));
    pe.dwSize = sizeof(pe);

    if (Process32FirstW(hSnap, &pe)) {
        do {
            if (pe.th32ProcessID == 0) continue;
            HANDLE hProc = OpenProcess(
                PROCESS_QUERY_INFORMATION | PROCESS_SET_QUOTA,
                FALSE, pe.th32ProcessID);
            if (hProc) {
                if (EmptyWorkingSet(hProc))
                    cleaned++;
                CloseHandle(hProc);
            }
        } while (Process32NextW(hSnap, &pe));
    }
    CloseHandle(hSnap);
    return cleaned;
}

MEMCORE_API int CleanProcessWorkingSet(uint32_t pid)
{
    HANDLE hProc = OpenProcess(
        PROCESS_QUERY_INFORMATION | PROCESS_SET_QUOTA,
        FALSE, pid);
    if (!hProc) return 0;
    int ok = EmptyWorkingSet(hProc) ? 1 : 0;
    CloseHandle(hProc);
    return ok;
}

/* ====================================================================== */
/* CPU sampling (per-process kernel+user ticks, delta vs wall clock)      */
/*                                                                        */
/* Each PID keeps its own lastSampleTime so newly-appeared processes      */
/* don’t get a distorted first reading and long gaps between GetProcessList */
/* calls don’t over-amplify the value. Matches Task Manager behaviour.     */
/* ====================================================================== */

struct CpuEntry { uint64_t ticks; ULONGLONG sampleMs; };
static std::unordered_map<uint32_t, CpuEntry> g_cpuMap;
static int g_cpuCoreCount = 0;
static std::mutex g_cpuMutex;

static double SampleCpuPercent(HANDLE hProc, uint32_t pid, ULONGLONG nowMs)
{
    if (g_cpuCoreCount == 0) {
        SYSTEM_INFO si;
        GetSystemInfo(&si);
        g_cpuCoreCount = (int)si.dwNumberOfProcessors;
        if (g_cpuCoreCount <= 0) g_cpuCoreCount = 1;
    }

    FILETIME ftCre, ftExit, ftKer, ftUser;
    if (!GetProcessTimes(hProc, &ftCre, &ftExit, &ftKer, &ftUser)) return 0.0;

    ULARGE_INTEGER k, u;
    k.LowPart = ftKer.dwLowDateTime;  k.HighPart = ftKer.dwHighDateTime;
    u.LowPart = ftUser.dwLowDateTime; u.HighPart = ftUser.dwHighDateTime;
    uint64_t ticks = k.QuadPart + u.QuadPart;

    double cpu = 0.0;
    auto it = g_cpuMap.find(pid);
    if (it != g_cpuMap.end() && ticks >= it->second.ticks && it->second.sampleMs > 0) {
        double elapsedSec = (nowMs - it->second.sampleMs) / 1000.0;
        if (elapsedSec >= 0.05) {
            double cpuSec = (ticks - it->second.ticks) / 10'000'000.0;
            cpu = cpuSec / (elapsedSec * g_cpuCoreCount) * 100.0;
            if (cpu < 0) cpu = 0;
            if (cpu > 100) cpu = 100;
        }
    }
    g_cpuMap[pid] = { ticks, nowMs };
    return cpu;
}

/* ====================================================================== */
/* Process List                                                           */
/* ====================================================================== */

MEMCORE_API int GetProcessList(ProcessInfoNative* buffer, int bufferCount)
{
    if (!buffer || bufferCount <= 0) return 0;

    HANDLE hSnap = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
    if (hSnap == INVALID_HANDLE_VALUE) return 0;

    std::lock_guard<std::mutex> lock(g_cpuMutex);
    ULONGLONG now = GetTickCount64();

    PROCESSENTRY32W pe;
    memset(&pe, 0, sizeof(pe));
    pe.dwSize = sizeof(pe);
    int count = 0;

    std::unordered_map<uint32_t, CpuEntry> seen;
    seen.reserve(256);

    if (Process32FirstW(hSnap, &pe)) {
        do {
            if (count >= bufferCount) break;
            if (pe.th32ProcessID == 0) continue;

            ProcessInfoNative* p = &buffer[count];
            memset(p, 0, sizeof(ProcessInfoNative));
            p->pid = pe.th32ProcessID;
            wcsncpy_s(p->name, 260, pe.szExeFile, _TRUNCATE);

            HANDLE hProc = OpenProcess(
                PROCESS_QUERY_INFORMATION | PROCESS_VM_READ,
                FALSE, pe.th32ProcessID);
            if (!hProc) {
                // Retry with a lighter access mask (protected processes)
                hProc = OpenProcess(
                    PROCESS_QUERY_LIMITED_INFORMATION, FALSE, pe.th32ProcessID);
            }
            if (hProc) {
                PROCESS_MEMORY_COUNTERS_EX pmc;
                memset(&pmc, 0, sizeof(pmc));
                pmc.cb = sizeof(pmc);
                if (GetProcessMemoryInfo(hProc,
                    (PROCESS_MEMORY_COUNTERS*)&pmc, sizeof(pmc)))
                {
                    p->workingSetSize = pmc.WorkingSetSize;
                    p->privateBytes = pmc.PrivateUsage;
                }

                WCHAR path[520];
                memset(path, 0, sizeof(path));
                DWORD pathLen = 520;
                if (QueryFullProcessImageNameW(hProc, 0, path, &pathLen)) {
                    wcsncpy_s(p->filePath, 520, path, _TRUNCATE);
                }

                p->cpuPercent = SampleCpuPercent(hProc, pe.th32ProcessID, now);
                seen[pe.th32ProcessID] = g_cpuMap[pe.th32ProcessID];

                CloseHandle(hProc);
            }

            count++;
        } while (Process32NextW(hSnap, &pe));
    }
    CloseHandle(hSnap);

    // Drop exited processes from the CPU map so it doesn't grow unbounded.
    g_cpuMap.swap(seen);
    return count;
}

/* ====================================================================== */
/* Kill Process                                                           */
/* ====================================================================== */

MEMCORE_API int KillProcess(uint32_t pid)
{
    HANDLE hProc = OpenProcess(PROCESS_TERMINATE, FALSE, pid);
    if (!hProc) return 0;
    int ok = TerminateProcess(hProc, 1) ? 1 : 0;
    CloseHandle(hProc);
    return ok;
}

/* ====================================================================== */
/* System Memory Info                                                     */
/* ====================================================================== */

MEMCORE_API int GetSystemMemoryInfo(SystemMemoryInfo* info)
{
    if (!info) return 0;
    MEMORYSTATUSEX ms;
    memset(&ms, 0, sizeof(ms));
    ms.dwLength = sizeof(ms);
    if (!GlobalMemoryStatusEx(&ms)) return 0;

    info->totalPhysical = ms.ullTotalPhys;
    info->availablePhysical = ms.ullAvailPhys;
    info->memoryLoadPercent = ms.dwMemoryLoad;
    return 1;
}

/* ====================================================================== */
/* Legacy network snapshot (kept for ABI compatibility)                   */
/* ====================================================================== */

MEMCORE_API int GetNetworkSnapshot(NetworkSnapshot* snapshot)
{
    if (!snapshot) return 0;

    PMIB_IF_TABLE2 table = nullptr;
    if (GetIfTable2(&table) != NO_ERROR || !table) return 0;

    uint64_t sent = 0, recv = 0;
    for (ULONG i = 0; i < table->NumEntries; i++) {
        const MIB_IF_ROW2& r = table->Table[i];
        if (r.OperStatus != IfOperStatusUp) continue;
        if (r.Type == IF_TYPE_SOFTWARE_LOOPBACK) continue;
        // Skip tunnel / virtual adapters (WSL, Hyper-V vEthernet, VMware, VPN).
        if (r.Type != IF_TYPE_ETHERNET_CSMACD &&
            r.Type != IF_TYPE_IEEE80211 &&
            r.Type != IF_TYPE_IEEE80216_WMAN &&
            r.Type != IF_TYPE_WWANPP &&
            r.Type != IF_TYPE_WWANPP2) continue;

        sent += r.OutOctets;
        recv += r.InOctets;
    }
    FreeMibTable(table);

    snapshot->bytesSent = sent;
    snapshot->bytesRecv = recv;
    return 1;
}

/* ====================================================================== */
/* Total NIC throughput using 64-bit counters                             */
/* ====================================================================== */

static ULONGLONG g_totalLastSampleMs = 0;
static uint64_t g_totalLastIn = 0, g_totalLastOut = 0;
static std::mutex g_totalMutex;

MEMCORE_API int GetNetTotalStats(NetTotalInfo* info)
{
    if (!info) return 0;
    memset(info, 0, sizeof(*info));

    PMIB_IF_TABLE2 table = nullptr;
    if (GetIfTable2(&table) != NO_ERROR || !table) return 0;

    uint64_t sent = 0, recv = 0;
    for (ULONG i = 0; i < table->NumEntries; i++) {
        const MIB_IF_ROW2& r = table->Table[i];
        if (r.OperStatus != IfOperStatusUp) continue;
        if (r.Type == IF_TYPE_SOFTWARE_LOOPBACK) continue;
        if (r.Type != IF_TYPE_ETHERNET_CSMACD &&
            r.Type != IF_TYPE_IEEE80211 &&
            r.Type != IF_TYPE_IEEE80216_WMAN &&
            r.Type != IF_TYPE_WWANPP &&
            r.Type != IF_TYPE_WWANPP2) continue;
        sent += r.OutOctets;
        recv += r.InOctets;
    }
    FreeMibTable(table);

    std::lock_guard<std::mutex> lock(g_totalMutex);
    ULONGLONG now = GetTickCount64();
    double elapsed = (g_totalLastSampleMs == 0) ? 1.0
                                                 : (now - g_totalLastSampleMs) / 1000.0;
    if (elapsed < 0.05) elapsed = 0.05;

    info->totalBytesIn = recv;
    info->totalBytesOut = sent;
    if (g_totalLastSampleMs != 0) {
        info->bytesInPerSec = (recv >= g_totalLastIn)
            ? (double)(recv - g_totalLastIn) / elapsed : 0.0;
        info->bytesOutPerSec = (sent >= g_totalLastOut)
            ? (double)(sent - g_totalLastOut) / elapsed : 0.0;
    }
    g_totalLastIn = recv;
    g_totalLastOut = sent;
    g_totalLastSampleMs = now;
    return 1;
}

/* ====================================================================== */
/* Per-process TCP bandwidth via ESTATS                                   */
/* ====================================================================== */

struct V4Key {
    DWORD la, ra;  // local/remote IPv4 addresses (network byte order, as MIB provides)
    DWORD lp, rp;  // local/remote ports (MIB layout: low 16 bits, high 16 bits zero)
    bool operator<(const V4Key& o) const {
        if (la != o.la) return la < o.la;
        if (ra != o.ra) return ra < o.ra;
        if (lp != o.lp) return lp < o.lp;
        return rp < o.rp;
    }
};

struct V6Key {
    IN6_ADDR la, ra;
    DWORD lsid, rsid;
    DWORD lp, rp;
    bool operator<(const V6Key& o) const {
        int c = memcmp(&la, &o.la, sizeof(IN6_ADDR));
        if (c) return c < 0;
        c = memcmp(&ra, &o.ra, sizeof(IN6_ADDR));
        if (c) return c < 0;
        if (lsid != o.lsid) return lsid < o.lsid;
        if (rsid != o.rsid) return rsid < o.rsid;
        if (lp != o.lp) return lp < o.lp;
        return rp < o.rp;
    }
};

struct ConnState {
    DWORD pid;
    uint64_t prevIn, prevOut;
    ULONGLONG lastSeenMs;
    bool enabled;   // true once ESTATS collection has been turned on
};

static std::map<V4Key, ConnState> g_v4Conns;
static std::map<V6Key, ConnState> g_v6Conns;
static ULONGLONG g_netLastSampleMs = 0;
static std::mutex g_netMutex;

MEMCORE_API void ResetNetStats(void)
{
    std::lock_guard<std::mutex> lock(g_netMutex);
    g_v4Conns.clear();
    g_v6Conns.clear();
    g_netLastSampleMs = 0;
}

static bool EnableEStatsV4(MIB_TCPROW* row)
{
    TCP_ESTATS_DATA_RW_v0 rw;
    rw.EnableCollection = TRUE;
    DWORD rc = SetPerTcpConnectionEStats(row, TcpConnectionEstatsData,
        (PUCHAR)&rw, 0, sizeof(rw), 0);
    return rc == NO_ERROR;
}

static bool ReadEStatsV4(MIB_TCPROW* row, TCP_ESTATS_DATA_ROD_v0* rod)
{
    memset(rod, 0, sizeof(*rod));
    DWORD rc = GetPerTcpConnectionEStats(row, TcpConnectionEstatsData,
        nullptr, 0, 0, nullptr, 0, 0,
        (PUCHAR)rod, 0, sizeof(*rod));
    return rc == NO_ERROR;
}

static bool EnableEStatsV6(MIB_TCP6ROW* row)
{
    TCP_ESTATS_DATA_RW_v0 rw;
    rw.EnableCollection = TRUE;
    DWORD rc = SetPerTcp6ConnectionEStats(row, TcpConnectionEstatsData,
        (PUCHAR)&rw, 0, sizeof(rw), 0);
    return rc == NO_ERROR;
}

static bool ReadEStatsV6(MIB_TCP6ROW* row, TCP_ESTATS_DATA_ROD_v0* rod)
{
    memset(rod, 0, sizeof(*rod));
    DWORD rc = GetPerTcp6ConnectionEStats(row, TcpConnectionEstatsData,
        nullptr, 0, 0, nullptr, 0, 0,
        (PUCHAR)rod, 0, sizeof(*rod));
    return rc == NO_ERROR;
}

static void AccumulateV4(std::unordered_map<DWORD, ProcNetInfoNative>& agg, ULONGLONG now)
{
    DWORD size = 0;
    GetExtendedTcpTable(nullptr, &size, FALSE, AF_INET, TCP_TABLE_OWNER_PID_ALL, 0);
    if (size == 0) return;

    std::vector<BYTE> buf(size);
    if (GetExtendedTcpTable(buf.data(), &size, FALSE, AF_INET,
            TCP_TABLE_OWNER_PID_ALL, 0) != NO_ERROR) return;

    auto* table = (MIB_TCPTABLE_OWNER_PID*)buf.data();
    for (DWORD i = 0; i < table->dwNumEntries; i++) {
        const auto& r = table->table[i];
        DWORD pid = r.dwOwningPid;
        if (pid == 0) continue;

        MIB_TCPROW row;
        row.dwState = r.dwState;
        row.dwLocalAddr = r.dwLocalAddr;
        row.dwLocalPort = r.dwLocalPort;
        row.dwRemoteAddr = r.dwRemoteAddr;
        row.dwRemotePort = r.dwRemotePort;

        V4Key key{ r.dwLocalAddr, r.dwRemoteAddr, r.dwLocalPort, r.dwRemotePort };

        auto it = g_v4Conns.find(key);
        bool isNew = (it == g_v4Conns.end()) || (it->second.pid != pid);

        if (isNew) {
            if (!EnableEStatsV4(&row)) {
                // Without admin rights this fails; still count the connection.
                auto& pi = agg[pid];
                pi.pid = pid; pi.tcpConnections++;
                continue;
            }
            TCP_ESTATS_DATA_ROD_v0 rod;
            if (!ReadEStatsV4(&row, &rod)) continue;
            ConnState st{ pid, rod.DataBytesIn, rod.DataBytesOut, now, true };
            g_v4Conns[key] = st;
            auto& pi = agg[pid];
            pi.pid = pid; pi.tcpConnections++;
        } else {
            TCP_ESTATS_DATA_ROD_v0 rod;
            if (!ReadEStatsV4(&row, &rod)) continue;
            auto& st = it->second;
            auto& pi = agg[pid];
            pi.pid = pid; pi.tcpConnections++;
            if (rod.DataBytesIn  >= st.prevIn)  pi.bytesIn  += rod.DataBytesIn  - st.prevIn;
            if (rod.DataBytesOut >= st.prevOut) pi.bytesOut += rod.DataBytesOut - st.prevOut;
            st.prevIn = rod.DataBytesIn;
            st.prevOut = rod.DataBytesOut;
            st.lastSeenMs = now;
        }
    }
}

static void AccumulateV6(std::unordered_map<DWORD, ProcNetInfoNative>& agg, ULONGLONG now)
{
    DWORD size = 0;
    GetExtendedTcpTable(nullptr, &size, FALSE, AF_INET6, TCP_TABLE_OWNER_PID_ALL, 0);
    if (size == 0) return;

    std::vector<BYTE> buf(size);
    if (GetExtendedTcpTable(buf.data(), &size, FALSE, AF_INET6,
            TCP_TABLE_OWNER_PID_ALL, 0) != NO_ERROR) return;

    auto* table = (MIB_TCP6TABLE_OWNER_PID*)buf.data();
    for (DWORD i = 0; i < table->dwNumEntries; i++) {
        const auto& r = table->table[i];
        DWORD pid = r.dwOwningPid;
        if (pid == 0) continue;

        MIB_TCP6ROW row;
        memset(&row, 0, sizeof(row));
        memcpy(&row.LocalAddr, &r.ucLocalAddr, sizeof(IN6_ADDR));
        memcpy(&row.RemoteAddr, &r.ucRemoteAddr, sizeof(IN6_ADDR));
        row.dwLocalScopeId = r.dwLocalScopeId;
        row.dwRemoteScopeId = r.dwRemoteScopeId;
        row.dwLocalPort = r.dwLocalPort;
        row.dwRemotePort = r.dwRemotePort;
        row.State = (MIB_TCP_STATE)r.dwState;

        V6Key key;
        memcpy(&key.la, &r.ucLocalAddr, sizeof(IN6_ADDR));
        memcpy(&key.ra, &r.ucRemoteAddr, sizeof(IN6_ADDR));
        key.lsid = r.dwLocalScopeId;
        key.rsid = r.dwRemoteScopeId;
        key.lp = r.dwLocalPort;
        key.rp = r.dwRemotePort;

        auto it = g_v6Conns.find(key);
        bool isNew = (it == g_v6Conns.end()) || (it->second.pid != pid);

        if (isNew) {
            if (!EnableEStatsV6(&row)) {
                auto& pi = agg[pid];
                pi.pid = pid; pi.tcpConnections++;
                continue;
            }
            TCP_ESTATS_DATA_ROD_v0 rod;
            if (!ReadEStatsV6(&row, &rod)) continue;
            ConnState st{ pid, rod.DataBytesIn, rod.DataBytesOut, now, true };
            g_v6Conns[key] = st;
            auto& pi = agg[pid];
            pi.pid = pid; pi.tcpConnections++;
        } else {
            TCP_ESTATS_DATA_ROD_v0 rod;
            if (!ReadEStatsV6(&row, &rod)) continue;
            auto& st = it->second;
            auto& pi = agg[pid];
            pi.pid = pid; pi.tcpConnections++;
            if (rod.DataBytesIn  >= st.prevIn)  pi.bytesIn  += rod.DataBytesIn  - st.prevIn;
            if (rod.DataBytesOut >= st.prevOut) pi.bytesOut += rod.DataBytesOut - st.prevOut;
            st.prevIn = rod.DataBytesIn;
            st.prevOut = rod.DataBytesOut;
            st.lastSeenMs = now;
        }
    }
}

static void AccumulateUdp(std::unordered_map<DWORD, ProcNetInfoNative>& agg, int family)
{
    DWORD size = 0;
    GetExtendedUdpTable(nullptr, &size, FALSE, family, UDP_TABLE_OWNER_PID, 0);
    if (size == 0) return;
    std::vector<BYTE> buf(size);
    if (GetExtendedUdpTable(buf.data(), &size, FALSE, family,
            UDP_TABLE_OWNER_PID, 0) != NO_ERROR) return;

    if (family == AF_INET) {
        auto* table = (MIB_UDPTABLE_OWNER_PID*)buf.data();
        for (DWORD i = 0; i < table->dwNumEntries; i++) {
            DWORD pid = table->table[i].dwOwningPid;
            if (pid == 0) continue;
            auto& pi = agg[pid];
            pi.pid = pid; pi.udpConnections++;
        }
    } else {
        auto* table = (MIB_UDP6TABLE_OWNER_PID*)buf.data();
        for (DWORD i = 0; i < table->dwNumEntries; i++) {
            DWORD pid = table->table[i].dwOwningPid;
            if (pid == 0) continue;
            auto& pi = agg[pid];
            pi.pid = pid; pi.udpConnections++;
        }
    }
}

MEMCORE_API int GetPerProcessNetStats(ProcNetInfoNative* buffer, int bufferCount)
{
    if (!buffer || bufferCount <= 0) return 0;

    std::lock_guard<std::mutex> lock(g_netMutex);

    ULONGLONG now = GetTickCount64();
    double elapsed = (g_netLastSampleMs == 0) ? 1.0
                                               : (now - g_netLastSampleMs) / 1000.0;
    if (elapsed < 0.05) elapsed = 0.05;

    std::unordered_map<DWORD, ProcNetInfoNative> agg;
    agg.reserve(128);

    AccumulateV4(agg, now);
    AccumulateV6(agg, now);
    AccumulateUdp(agg, AF_INET);
    AccumulateUdp(agg, AF_INET6);

    // Expire closed connections (not seen for >10s).
    auto expire = [now](auto& m) {
        for (auto it = m.begin(); it != m.end(); ) {
            if (now - it->second.lastSeenMs > 10000ULL) it = m.erase(it);
            else ++it;
        }
    };
    expire(g_v4Conns);
    expire(g_v6Conns);

    int count = 0;
    for (auto& kv : agg) {
        if (count >= bufferCount) break;
        ProcNetInfoNative& out = buffer[count];
        out = kv.second;
        out.pid = kv.first;
        out.bytesInPerSec  = (double)out.bytesIn  / elapsed;
        out.bytesOutPerSec = (double)out.bytesOut / elapsed;
        count++;
    }
    g_netLastSampleMs = now;
    return count;
}

免费评分

参与人数 4吾爱币 +6 热心值 +4 收起 理由
苏紫方璇 + 3 + 1 欢迎分析讨论交流，吾爱破解论坛有你更精彩！
Ebichu + 1 + 1 我很赞同！
chenjh001 + 1 + 1 我很赞同！
h07799486 + 1 + 1 谢谢@Thanks！

查看全部评分

发帖前要善用【论坛搜索】功能，那里可能会有你要找的答案或者已经有人发布过相同内容了，请勿重复发帖。
回复

举报

苏紫方璇
苏紫方璇 发表于 2026-4-30 16:26
请在帖子中插入部分关键代码
本版块仅限分享编程技术和源码相关内容，发布帖子必须带上关键代码和具体功能介绍
【吾爱破解论坛总版规】 - [让你充分了解吾爱破解论坛行为规则]
回复

举报

moxin9597
moxin9597 发表于 2026-4-30 20:06
吾爱破解论坛没有任何官方QQ群，禁止留联系方式，禁止任何商业交易。
不需要会员的吧？
如何升级？如何获得积分？积分对应解释说明！
回复

举报

smallmouse228
smallmouse228 发表于 2026-4-30 21:27
《站点帮助文档》有什么问题来这里看看吧，这里有你想知道的内容！
这个也能做出来，可以呀，我是一点也看不懂！！
呼吁大家发布原创作品添加吾爱破解论坛标识！
回复

举报

renzhen1997
renzhen1997 发表于 2026-4-30 21:58
有没有用，会不会把有些进程一下就强退了用过的来评下
如何快速判断一个文件是否为病毒！
回复

举报

zbzb80
zbzb80 发表于 2026-5-1 01:16
不错不错，这种单一功能的小程序非常实用，360太臃肿了。
回复

举报

JQYR
JQYR 发表于 2026-5-1 08:47
看着不错，感谢分享
回复

举报

zlqhysy
zlqhysy 发表于 2026-5-1 09:52
支持原创，谢谢
回复

举报

chenjh001
chenjh001 发表于 2026-5-1 11:29
支持原创，谢谢
回复

举报

返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 注册[Register]

本版积分规则


免责声明：
吾爱破解所发布的一切破解补丁、注册机和注册信息及软件的解密分析文章仅限用于学习和研究目的；不得将上述内容用于商业或者非法用途，否则，一切后果请用户自负。本站信息来自网络，版权争议与本站无关。您必须在下载后的24个小时之内，从您的电脑中彻底删除上述内容。如果您喜欢该程序，请支持正版软件，购买注册，得到更好的正版服务。如有侵权请邮件与我们联系处理。

Mail To:Service@52pojie.cn

返回列表

RSS订阅|小黑屋|处罚记录|联系我们|吾爱破解 - 52pojie.cn ( 京ICP备16042023号 | 京公网安备 11010502030087号 )

GMT+8, 2026-5-13 06:12

Powered by Discuz!

Copyright © 2001-2020, Tencent Cloud.

快速回复 返回顶部 返回列表