Android 中 app freezer 原理详解(一)：S 版本

news2024/11/17 23:27:08

基于版本：Android S

 

 

0. 前言

在之前的两篇博文《Android 中app内存回收优化(一)》和 《Android 中app内存回收优化(二)》中详细剖析了 Android 中 app 内存优化的流程。这个机制的管理通过 CachedAppOptimizer 类管理，为什么叫这个名字，而不叫 AppCompact 等？在之前的两篇博文中也提到了，因为该类中还管理了一个重要功能：freezer，一个针对应用进程长期处于 Cached 状态的优化。

在之前博文《app freezer 原理 R 版本》中简单的剖析了app freeze / unfreeze 的流程，但从代码逻辑上来看，笔者觉得 R 版本上有些逻辑是存在问题的，好在S 版本中都修复了。

本文将以 R 版本的原理为基础，对 S 版本进行对比分析。

1. freezer 触发

同 R 版本中，S 版本的触发也是在 applyOomAdjLSP() 函数中调用 updateAppFreezeStateLSP() 来确认是否冻结进程：

frameworks/base/services/core/java/com/android/server/am/OomAdjuster.java

   private void updateAppFreezeStateLSP(ProcessRecord app) {

        // 确认该功能是否使能，如果没有使能则返回
        if (!mCachedAppOptimizer.useFreezer()) {
            return;
        }

        // S 版本新加的，确认应用是否可以豁免
        if (app.mOptRecord.isFreezeExempt()) {
            return;
        }

        // S 版本中cached进程优化相关的属性，都放到了mOptRecord中管理
        final ProcessCachedOptimizerRecord opt = app.mOptRecord;

        // 如果进程处于frozen状态，但shouldNotFreeze变成true，需要解冻
        if (opt.isFrozen() && opt.shouldNotFreeze()) {
            mCachedAppOptimizer.unfreezeAppLSP(app);
            return;
        }

        // 确定adj，是进入freeze 还是 unfreeze 流程
        final ProcessStateRecord state = app.mState;
        if (state.getCurAdj() >= ProcessList.CACHED_APP_MIN_ADJ && !opt.isFrozen()
                && !opt.shouldNotFreeze()) {
            mCachedAppOptimizer.freezeAppAsyncLSP(app);
        } else if (state.getSetAdj() < ProcessList.CACHED_APP_MIN_ADJ) {
            mCachedAppOptimizer.unfreezeAppLSP(app);
        }
    }

该函数与 R 版本基本逻辑差不多，稍微有些差异：

  • 进程有了是否freeze 豁免的功能，当应用设置了 INSTALL_PACKAGES 的权限之后，该应用处于豁免状态，详细看 ProcessList.startProcessLocked() 函数；
  • S 版本中cached进程的一些状态，统一由ProcessRecord 中的 mOptRecord 维护；
  • 最后再unfreeze 调用时，不再判断app 是否处于 frozen，因为这部分逻辑判断会在 unfreeze 函数中判定，这让代码更简介，R 版本中有些多余；

 

2. CachedAppOptimizer.init()

对于CachedAppOptimizer 的构造调用，以及 init() 函数的触发流程，可以参考《Android 中app内存回收优化(二)》 一文第 1 节 和 第 2 节。

frameworks/base/services/core/java/com/android/server/am/CachedAppOptimizer.java
 
    public void init() {
        ...
        DeviceConfig.addOnPropertiesChangedListener(
                DeviceConfig.NAMESPACE_ACTIVITY_MANAGER_NATIVE_BOOT,
                ActivityThread.currentApplication().getMainExecutor(),
                mOnNativeBootFlagsChangedListener);
        mAm.mContext.getContentResolver().registerContentObserver(
                CACHED_APP_FREEZER_ENABLED_URI, false, mSettingsObserver);
        synchronized (mPhenotypeFlagLock) {
            ...
            updateUseFreezer();
            ...
        }
    }

相比较与 R 版本，这里多了两个功能：

  • 新加一个 freeze_debounce_timeout 属性发生变化的 listener，当该属性变化时，会调用 updateFreezerDebounceTimeout() 进行更新；
  • 新加了 cached_apps_freezer 属性值发生变化的 observer；

在 R 版本中，freeze timeout 是10min，使用的是常量。而在 S 版本中，将该值设计为可变的，用户可以通过 DeviceConfig 进行修改。当发生变化时，会调用 updateFreezerDebounceTimeout()进行更新。

另外，在 S 版本中，对 cached_apps_freezer 的值做了一个observer，及时控制 freezer 的使能。

2.1 updateUseFreezer()

    private void updateUseFreezer() {
        // 获取 settings中属性 cached_apps_freezer的值，同R 版本
        final String configOverride = Settings.Global.getString(mAm.mContext.getContentResolver(),
                Settings.Global.CACHED_APPS_FREEZER_ENABLED);

        if ("disabled".equals(configOverride)) {
            mUseFreezer = false;
        } else if ("enabled".equals(configOverride)
                || DeviceConfig.getBoolean(DeviceConfig.NAMESPACE_ACTIVITY_MANAGER_NATIVE_BOOT,
                    KEY_USE_FREEZER, DEFAULT_USE_FREEZER)) {
            mUseFreezer = isFreezerSupported();
            updateFreezerDebounceTimeout();
        } else {
            mUseFreezer = false;
        }

        final boolean useFreezer = mUseFreezer;
        // enableFreezer() would need the global ActivityManagerService lock, post it.
        mAm.mHandler.post(() -> {
            if (useFreezer) {
                Slog.d(TAG_AM, "Freezer enabled");
                enableFreezer(true);

                if (!mCachedAppOptimizerThread.isAlive()) {
                    mCachedAppOptimizerThread.start();
                }

                if (mFreezeHandler == null) {
                    mFreezeHandler = new FreezeHandler();
                }

                Process.setThreadGroupAndCpuset(mCachedAppOptimizerThread.getThreadId(),
                    mCompactionPriority);

            } else {
                Slog.d(TAG_AM, "Freezer disabled");
                enableFreezer(false);
            }
        });
    }

这里针对 R 版本也做了个优化，将enableFreezer() 的过程异步处理。

freezer 功能是否使能，用流程图说明比较清晰：

 

3. cgroups 简介

这里不再补充，详细可以查看 R 版本或《Android 中 cgroup抽象层详解》

这里需要注意的是，R 版本中的 freezer 中，通过 /sys/fs/cgroup/freezer/cgroup.freeze 来确定是否使能 freezer，通过 /sys/fs/cgroup/freezer/cgroup.procs 来进行 frozen / unfrozen 操作。而在 S 版本中，frozen/unfrozen 的操作通过 /sys/fs/cgroup/freezer/cgroup.freeze 节点。详细看下面第 5.2.1 节。

4. enableFreezer()

frameworks/base/services/core/java/com/android/server/am/CachedAppOptimizer.java

    public synchronized boolean enableFreezer(boolean enable) {
        if (!mUseFreezer) {
            return false;
        }

        if (enable) {
            mFreezerDisableCount--;

            if (mFreezerDisableCount > 0) {
                return true;
            } else if (mFreezerDisableCount < 0) {
                Slog.e(TAG_AM, "unbalanced call to enableFreezer, ignoring");
                mFreezerDisableCount = 0;
                return false;
            }
        } else {
            mFreezerDisableCount++;

            if (mFreezerDisableCount > 1) {
                return true;
            }
        }

        // Override is applied immediately, restore is delayed
        synchronized (mAm) {
            synchronized (mProcLock) {
                mFreezerOverride = !enable;
                Slog.d(TAG_AM, "freezer override set to " + mFreezerOverride);

                mAm.mProcessList.forEachLruProcessesLOSP(true, process -> {
                    if (process == null) {
                        return;
                    }

                    final ProcessCachedOptimizerRecord opt = process.mOptRecord;
                    if (enable && opt.hasFreezerOverride()) {
                        freezeAppAsyncLSP(process);
                        opt.setFreezerOverride(false);
                    }

                    if (!enable && opt.isFrozen()) {
                        unfreezeAppLSP(process);

                        // Set freezerOverride *after* calling unfreezeAppLSP (it resets the flag)
                        opt.setFreezerOverride(true);
                    }
                });
            }
        }

        return true;
    }

代码与 R 版本不同，这里通过 mAm.mProcessList.forEachLruProcessesLOSP() 对每个LRU 中的进程进行确认。

进程中引入了 mOptRecord.mFreezerOverride 属性，用以标记对某个进程是否进行 disable freezer 操作。若该值为 true，则表示进程被 disable freezer 过。此时如果再次 enable，需对进程进行 freeze 请求。

当然，CachedAppOptimizer 类中也有这样的成员变量 mFreezerOverride，这个用以控制从外部调用的 freezeAppAsyncLSP()。如果该值为 true，则表示disable freezer了，外部如果有调用 freezeAppAsyncLSP()，则不需要去处理。

 

5. freezeAppAsyncLSP()

    void freezeAppAsyncLSP(ProcessRecord app) {
        final ProcessCachedOptimizerRecord opt = app.mOptRecord;
        if (opt.isPendingFreeze()) {
            // Skip redundant DO_FREEZE message
            return;
        }

        mFreezeHandler.sendMessageDelayed(
                mFreezeHandler.obtainMessage(
                    SET_FROZEN_PROCESS_MSG, DO_FREEZE, 0, app),
                mFreezerDebounceTimeout);
        opt.setPendingFreeze(true);
    }

相比较 R 版本，这里做了一个保护，防止反复进行 freeze 请求。

另外，timeout 从 R 版本中的常量 FREEZE_TIMEOUT_MS 改成可变的 debounce timeout。

注意：冻结时异步操作，使用 CachedAppOptimizer类中定义的 ServiceThread 进行，而解冻是东部操作，没有通过 ServiceThread。

5.1 freeze 消息处理

        public void handleMessage(Message msg) {
            switch (msg.what) {
                case SET_FROZEN_PROCESS_MSG:
                    synchronized (mAm) {
                        freezeProcess((ProcessRecord) msg.obj);
                    }
                    break;
                case REPORT_UNFREEZE_MSG:
                    int pid = msg.arg1;
                    int frozenDuration = msg.arg2;
                    String processName = (String) msg.obj;

                    reportUnfreeze(pid, frozenDuration, processName);
                    break;
                default:
                    return;
            }
        }

对于 freezer 一共有两个消息，REPORT_UNFREEZE_MSG 这个消息是在 unfreeze 之后进行记录的。

本文重点来看下 freeze 的消息处理，这里看到最终调用的是 freezeProcess() 函数，详细查看下一小节

5.2 freezeProcess()

frameworks/base/services/core/java/com/android/server/am/CachedAppOptimizer.java

       private void freezeProcess(final ProcessRecord proc) {
            int pid = proc.getPid(); // Unlocked intentionally
            final String name = proc.processName;
            final long unfrozenDuration;
            final boolean frozen;
            final ProcessCachedOptimizerRecord opt = proc.mOptRecord;

            opt.setPendingFreeze(false);

            try {
                // 确认进程是否存在任意的文件锁，避免不必要的 free/unfreeze操作
                //   这是为了防止冻结进程持有文件锁，从而引起死锁
                //   冻结成功之后，还会再次确认文件锁，如果有锁，则立即解冻
                if (mProcLocksReader.hasFileLocks(pid)) {
                    if (DEBUG_FREEZER) {
                        Slog.d(TAG_AM, name + " (" + pid + ") holds file locks, not freezing");
                    }
                    return;
                }
            } catch (Exception e) {
                Slog.e(TAG_AM, "Not freezing. Unable to check file locks for " + name + "(" + pid
                        + "): " + e);
                return;
            }

            synchronized (mProcLock) {
                pid = proc.getPid();

                // 如果进程没有变成Cached或者不能freeze，则退出此次freeze操作
                if (proc.mState.getCurAdj() < ProcessList.CACHED_APP_MIN_ADJ
                        || opt.shouldNotFreeze()) {
                    return;
                }

                // 如果freezer 处于disable状态，返回，并告知该进程
                if (mFreezerOverride) {
                    opt.setFreezerOverride(true);
                    return;
                }


                // 已经处于frozen，或者不是一个应用进程，则退出此次 freeze操作
                //   pid为0，有可能进程还没有launch完成，或者进程被kill了
                if (pid == 0 || opt.isFrozen()) {
                    // Already frozen or not a real process, either one being
                    // launched or one being killed
                    return;
                }

                Slog.d(TAG_AM, "freezing " + pid + " " + name);

                // 在S版本中，将这部分功能提前，也是正确的行为
                // 冻结 binder
                //    1.如果freezer是使能，将同步发送所有的pending 交互给指定的pid；
                //    2.该函数调用后，所有的binder 请求，都会被block，并返回error给发送请求的进程；
                try {
                    if (freezeBinder(pid, true) != 0) {
                        rescheduleFreeze(proc, "outstanding txns");
                        return;
                    }
                } catch (RuntimeException e) { //如果调用失败，则直接kill该进程
                    Slog.e(TAG_AM, "Unable to freeze binder for " + pid + " " + name);
                    mFreezeHandler.post(() -> {
                        synchronized (mAm) {
                            proc.killLocked("Unable to freeze binder interface",
                                    ApplicationExitInfo.REASON_OTHER,
                                    ApplicationExitInfo.SUBREASON_FREEZER_BINDER_IOCTL, true);
                        }
                    });
                }

                long unfreezeTime = opt.getFreezeUnfreezeTime();

                //核心函数 setProcessFrozen()，同步冻结进程
                try {
                    Process.setProcessFrozen(pid, proc.uid, true);

                    opt.setFreezeUnfreezeTime(SystemClock.uptimeMillis());
                    opt.setFrozen(true);
                } catch (Exception e) {
                    Slog.w(TAG_AM, "Unable to freeze " + pid + " " + name);
                }

                unfrozenDuration = opt.getFreezeUnfreezeTime() - unfreezeTime;
                frozen = opt.isFrozen();
            }

            if (!frozen) {
                return;
            }

            Slog.d(TAG_AM, "froze " + pid + " " + name);

            // 将此次 freeze 记录到 event log 中
            EventLog.writeEvent(EventLogTags.AM_FREEZE, pid, name);

            // See above for why we're not taking mPhenotypeFlagLock here
            if (mRandom.nextFloat() < mFreezerStatsdSampleRate) {
                FrameworkStatsLog.write(FrameworkStatsLog.APP_FREEZE_CHANGED,
                        FrameworkStatsLog.APP_FREEZE_CHANGED__ACTION__FREEZE_APP,
                        pid,
                        name,
                        unfrozenDuration);
            }

            // 确认在冻结的时候，是否收到了 TXNS_PENDING_WHILE_FROZEN的binder请求，
            //    如果有有收到请求，则重新freeze 该进程(unfreeze + freeze)
            try {
                // post-check to prevent races
                int freezeInfo = getBinderFreezeInfo(pid);

                if ((freezeInfo & TXNS_PENDING_WHILE_FROZEN) != 0) {
                    synchronized (mProcLock) {
                        rescheduleFreeze(proc, "new pending txns");
                    }
                    return;
                }
            } catch (RuntimeException e) {
                Slog.e(TAG_AM, "Unable to freeze binder for " + pid + " " + name);
                mFreezeHandler.post(() -> {
                    synchronized (mAm) {
                        proc.killLocked("Unable to freeze binder interface",
                                ApplicationExitInfo.REASON_OTHER,
                                ApplicationExitInfo.SUBREASON_FREEZER_BINDER_IOCTL, true);
                    }
                });
            }

            try {
                // 再次check文件锁，如果该冻结进程持有文件锁，立即unfreeze
                if (mProcLocksReader.hasFileLocks(pid)) {
                    if (DEBUG_FREEZER) {
                        Slog.d(TAG_AM, name + " (" + pid + ") holds file locks, reverting freeze");
                    }
                    unfreezeAppLSP(proc);
                }
            } catch (Exception e) {
                Slog.e(TAG_AM, "Unable to check file locks for " + name + "(" + pid + "): " + e);
                unfreezeAppLSP(proc);
            }
        }

逻辑与R 版本有很大的不同：

  • 在冻结进程之前，调用 freezeBinder()，用以冻结binder 通信；
  • 在冻结进程之后，调用 getBinderFreezeInfo()，确认是否在冻结的时候有 TXNS_PENDING_WHILE_FROZEN 的binder 请求，如果有该请求，则重新freeze 该进程(unfreeze + freeze)；

弄个流程图理解冻结过程：

 5.2.1 setProcessFrozen()

frameworks/base/core/java/android/os/Process.java
 
    public static final native void setProcessFrozen(int pid, int uid, boolean frozen);
frameworks/base/core/jni/android_util_Process.cpp

void android_os_Process_setProcessFrozen(
        JNIEnv *env, jobject clazz, jint pid, jint uid, jboolean freeze)
{
    bool success = true;

    if (freeze) {
        success = SetProcessProfiles(uid, pid, {"Frozen"});
    } else {
        success = SetProcessProfiles(uid, pid, {"Unfrozen"});
    }

    if (!success) {
        signalExceptionForGroupError(env, EINVAL, pid);
    }
}

此处的调用在博文《cgroup抽象层》中已经分析过，通过接口 SetProcessProfiles() 精细是 SetAttributeAction 类型的profile，最终调用 ExecuteForProcess()：

system/core/libprocesscgroup/task_profiles.cpp

bool SetAttributeAction::ExecuteForProcess(uid_t, pid_t pid) const {
    return ExecuteForTask(pid);
}

bool SetAttributeAction::ExecuteForTask(int tid) const {
    std::string path;

    if (!attribute_->GetPathForTask(tid, &path)) {
        LOG(ERROR) << "Failed to find cgroup for tid " << tid;
        return false;
    }

    if (!WriteStringToFile(value_, path)) {
        PLOG(ERROR) << "Failed to write '" << value_ << "' to " << path;
        return false;
    }

    return true;
}

最终写的是 /sys/fs/cgroup/freezer/cgroup.freeze 文件。

某个进程被冻结的旅程图：

6. unfreezeAppLSP()

frameworks/base/services/core/java/com/android/server/am/CachedAppOptimizer.java

   void unfreezeAppLSP(ProcessRecord app) {
        final int pid = app.getPid();
        final ProcessCachedOptimizerRecord opt = app.mOptRecord;

        // 进程已经处于peding freeze中，移除冻结消息
        if (opt.isPendingFreeze()) {
            // Remove pending DO_FREEZE message
            mFreezeHandler.removeMessages(SET_FROZEN_PROCESS_MSG, app);
            opt.setPendingFreeze(false);
        }

        opt.setFreezerOverride(false);

        // 如果进程还没有冻结，则无需做解冻处理
        if (!opt.isFrozen()) {
            return;
        }

        // 冻住的进程可以接收异步binder请求，但是不会处理，只是放入binder buffer， 过多的请求会导致buffer耗尽；
        // 这里需要确认下该进程在解冻之前，进程是否在冰冻期间收到同步的binder 请求，有则kill该进程
        boolean processKilled = false;

        try {
            int freezeInfo = getBinderFreezeInfo(pid);

            if ((freezeInfo & SYNC_RECEIVED_WHILE_FROZEN) != 0) {
                Slog.d(TAG_AM, "pid " + pid + " " + app.processName
                        + " received sync transactions while frozen, killing");
                app.killLocked("Sync transaction while in frozen state",
                        ApplicationExitInfo.REASON_OTHER,
                        ApplicationExitInfo.SUBREASON_FREEZER_BINDER_TRANSACTION, true);
                processKilled = true;
            }

            if ((freezeInfo & ASYNC_RECEIVED_WHILE_FROZEN) != 0 && DEBUG_FREEZER) {
                Slog.d(TAG_AM, "pid " + pid + " " + app.processName
                        + " received async transactions while frozen");
            }
        } catch (Exception e) {
            Slog.d(TAG_AM, "Unable to query binder frozen info for pid " + pid + " "
                    + app.processName + ". Killing it. Exception: " + e);
            app.killLocked("Unable to query binder frozen stats",
                    ApplicationExitInfo.REASON_OTHER,
                    ApplicationExitInfo.SUBREASON_FREEZER_BINDER_IOCTL, true);
            processKilled = true;
        }

        //进程被kill 了，无需 unfreeze
        if (processKilled) {
            return;
        }

        // app.freezeUnfreezeTime记录的是上次free、unfreeze的时间
        long freezeTime = opt.getFreezeUnfreezeTime();

        try {
            freezeBinder(pid, false);
        } catch (RuntimeException e) {
            Slog.e(TAG_AM, "Unable to unfreeze binder for " + pid + " " + app.processName
                    + ". Killing it");
            app.killLocked("Unable to unfreeze",
                    ApplicationExitInfo.REASON_OTHER,
                    ApplicationExitInfo.SUBREASON_FREEZER_BINDER_IOCTL, true);
            return;
        }

        try {
            Process.setProcessFrozen(pid, app.uid, false);

            opt.setFreezeUnfreezeTime(SystemClock.uptimeMillis());
            opt.setFrozen(false);
        } catch (Exception e) {
            Slog.e(TAG_AM, "Unable to unfreeze " + pid + " " + app.processName
                    + ". This might cause inconsistency or UI hangs.");
        }

        if (!opt.isFrozen()) {
            Slog.d(TAG_AM, "sync unfroze " + pid + " " + app.processName);

            mFreezeHandler.sendMessage(
                    mFreezeHandler.obtainMessage(REPORT_UNFREEZE_MSG,
                        pid,
                        (int) Math.min(opt.getFreezeUnfreezeTime() - freezeTime, Integer.MAX_VALUE),
                        app.processName));
        }
    }

逻辑比较清晰，核心处理函数是 setProcessFrozen()，详细的流程在上面第 5.2.1 节中已经分析过。

7. kernel 处理

 

 
 

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/803263.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

【AHK】通过唤醒窗口快捷菜单调节窗口位置/打开窗口控制菜单的其他方法

【AHK】通过唤醒窗口快捷菜单调节窗口位置/打开窗口控制菜单的其他方法

需求&#xff1a;触控板使用AHK传统控制窗口位置和大小的方式不方便&#xff0c;故打算通过快捷方式唤醒窗口移动图标的方式来调节。但本人有使用utools的习惯&#xff0c;altspace打开快捷方式菜单/窗口控制菜单会冲突&#xff0c;所以一直尝试新的打开该菜单的方式——先点击…
阅读更多...
[语义分割] DeepLab v3（Cascaded model、ASPP model、两种ASPP对比、Multi-grid、训练细节）

[语义分割] DeepLab v3（Cascaded model、ASPP model、两种ASPP对比、Multi-grid、训练细节）

Rethinking Atrous Convolution for Semantic Image Segmentation 论文地址&#xff1a;Rethinking Atrous Convolution for Semantic Image SegmentationPytorch 实现代码&#xff1a;pytorch_segmentation/deeplab_v3 这是一篇 2017 年发表在CVPR上的文章。相比 DeepLab V2 有…
阅读更多...
一、前端高德地图注册、项目中引入、渲染标记(Marker)and覆盖物(Circle)

一、前端高德地图注册、项目中引入、渲染标记(Marker)and覆盖物(Circle)

首先说明一下&#xff0c;下面的流程只是个人摸索and看文档梳理出来的&#xff0c;并不作为完全正确的流程。 首先&#xff0c;注册 高德开放平台 没有注册的可以点击右上角点击注册&#xff1b; 我们点个人的就ok&#xff1b; 信息完善之后我们到控制台&#xff0c;点击 应…
阅读更多...
6个高清图片素材网站，免费下载，值得推荐~

6个高清图片素材网站，免费下载，值得推荐~

关于图片素材网站&#xff0c;我一直都在推荐这几个&#xff0c;免费下载&#xff0c;可商用&#xff0c;建议收藏起来~ 菜鸟图库 https://www.sucai999.com/pic.html?vNTYwNDUx 网站主要是为新手设计师提供免费素材的&#xff0c;素材的质量都很高&#xff0c;类别也很多&a…
阅读更多...
手机word怎么转换成pdf？这几个转换方法推荐给你

手机word怎么转换成pdf？这几个转换方法推荐给你

手机word怎么转换成pdf&#xff1f;将Word转换为PDF的主要原因是PDF格式具有更好的文件保护性和稳定性。PDF文件是一种可靠的文件格式&#xff0c;可以保护文件免受恶意软件和病毒的攻击&#xff0c;同时保持文件的格式和布局不变。此外&#xff0c;PDF文件可以在不同的操作系统…
阅读更多...
【1】-Locust性能测试工具介绍与安装

【1】-Locust性能测试工具介绍与安装

Locust介绍 locust是一个开源的压测工具&#xff0c;其官网地址是Locust - A modern load testing framework&#xff0c;通过编写Python代码&#xff0c;可以轻松实现百万级的并发&#xff0c;相对于我们熟悉的Jmeter来说&#xff0c;其对压测机的要求更低&#xff0c;而且使…
阅读更多...
MicroPython for ESP32

MicroPython for ESP32

MicroPython for ESP32 开发板引脚图 环境搭建 参考资料 https://zhuanlan.zhihu.com/p/587027345 官方资料 https://docs.micropython.org/en/latest/ http://vcc-gnd.com/rtd/html/esp32/quickref.html#i2c 创建一个虚拟环境&#xff0c; conda create -n esp32 pytho…
阅读更多...
编辑员工信息

编辑员工信息

1.根据员工id查询信息 Controller层 /** 根据员工id查询信息* */GetMapping("/{id}")ApiOperation("根据员工id查询信息")public Result<Employee> getById(PathVariable Integer id){log.info("根据员工id查询信息{}",id);Employee emplo…
阅读更多...
pdf转换word软件哪个好？式？这款软件帮你轻松实现转换

pdf转换word软件哪个好？式？这款软件帮你轻松实现转换

在工作中&#xff0c;我们常常遇到这样的情况&#xff1a;我们的文件可能是PDF格式的&#xff0c;但对方要求我们以Word形式发送&#xff0c;因为Word相对于PDF占用更小的内存&#xff0c;打开更方便&#xff0c;发送时间更短。这时我们需要将PDF转换为Word格式&#xff0c;然而…
阅读更多...
低代码开发平台源码：可视化敏捷开发工具，拖拽式自定义表单界面

低代码开发平台源码：可视化敏捷开发工具，拖拽式自定义表单界面

低代码开发平台源码 低代码管理系统源码 无需代码或通过少量代码就可以快速生成应用程序的开发平台。 本套低代码管理后台可以支持多种企业应用场景&#xff0c;包括但不限于CRM、ERP、OA、BI、IoT、大数据等。无论是传统企业还是新兴企业&#xff0c;都可以使用管理后台快速构…
阅读更多...
优惠券秒杀(三)

优惠券秒杀(三)

优惠券秒杀一人一单 优惠券的目的是为了引流&#xff0c;但是目前的情况是一个人可以无限制的抢这个优惠券&#xff0c;因此&#xff0c;代码中应该添加一个用户只能下一单的逻辑。保证一个用户只能抢一张券&#xff0c;则只要保证该用户下的优惠券只要一张&#xff0c;即根据优…
阅读更多...
List＜List＜＞＞ 转 List lambda，List＜HashMap＜＞＞转List＜＞

List＜List＜＞＞ 转 List lambda，List＜HashMap＜＞＞转List＜＞

1、在实际的业务处理中&#xff0c;我们经常会碰到需要合并同一个集合内相同属性对象的情况&#xff0c;比如&#xff0c;同一个用户短时间内下的订单&#xff0c;我们需要将各个订单的金额合并成一个总金额。那么用lambda表达式和HashMap怎么分别处理该种情况呢&#xff1f;本…
阅读更多...
vue3如何设置全局过滤器、app.config.globalProperties如何使用配置

vue3如何设置全局过滤器、app.config.globalProperties如何使用配置

vue3 相比于 vue2 取消了很多的API&#xff0c; filter就在其中&#xff0c;但是我们可以使用其他方法替代vue2中的filter 通过 app.config.globalProperties 来注册一个全局都能访问到的属性 我们再来说说 app.config.globalProperties 是什么&#xff0c;如何使用&#xff…
阅读更多...
httpd升级2.4.57及后续问题处理

httpd升级2.4.57及后续问题处理

文章目录 背景信息操作步骤构建rpm包升级httpd启动httpd报错及处理缺少mod_systemd缺少mod_cgi 相关文件 背景信息 由于2.4.37版本httpd有安全漏洞&#xff0c;需要升级到2.4.57版本&#xff0c;2.4.57版本是当前最新的版本&#xff0c;只具备源码包&#xff0c;不具备rpm包&a…
阅读更多...
Quartz 调度原理与源码分析

Quartz 调度原理与源码分析

文章目录 一、Quartz基础1、入门案例 二、获取调度器实例源码分析1、读取配置文件&#xff1a;initialize()2、初始化工作&#xff1a;instantiate()&#xff08;1&#xff09;创建线程池&#xff08;包工头&#xff09;SimpleThreadPool&#xff08;2&#xff09;WorkerThread…
阅读更多...
十五章：使用类别峰值响应的弱监督实例分割

十五章：使用类别峰值响应的弱监督实例分割

0.摘要 目前&#xff0c;使用图像级别标签而不是昂贵的像素级掩码进行弱监督实例分割的研究还未得到充分探索。本文通过利用类别峰值响应来实现一个分类网络&#xff0c;用于提取实例掩码&#xff0c;来解决这个具有挑战性的问题。只通过图像标签的监督下&#xff0c;完全卷积的…
阅读更多...
winform 将resources资源文件反编译为resx文件

winform 将resources资源文件反编译为resx文件

resources资源文件反编译为resx文件 【前景提要】 在日常工作中我们会遇到需要将一个编译后的winform程序反编译出其对应的源码&#xff0c;然而在常用的反编译工具中对于项目中使用的资源文件是编译为resources文件的&#xff0c;这个资源文件在反编译后的源码中是无法直接使用…
阅读更多...
MES管理系统中设备管理功能的原理是什么

MES管理系统中设备管理功能的原理是什么

制造执行系统MES是一种应用于制造工厂的实际操作系统&#xff0c;它通过实时监控和控制生产流程&#xff0c;为生产过程提供全面的管理和优化。在MES管理系统解决方案中&#xff0c;设备管理功能是非常重要的一部分&#xff0c;它可以实现设备实时监控、故障预警、维护保养等功…
阅读更多...
MyBatisPlus从入门到精通-2

MyBatisPlus从入门到精通-2

接着上一讲的Mp的分页功能 下面我们讲解条件查询功能和其他功能 解决一下日志输出和banner问题 每次卞就会输出这些日志 很不美观&#xff0c;现在我们关闭一下 这样建个xml&#xff0c;文件名为logback.xml 文件内容改成这样 配置了logback但是里面什么都没写就不会说有日…
阅读更多...
视频监控汇聚平台EasyCVR向上级联时，上级一直回复401是什么原因？

视频监控汇聚平台EasyCVR向上级联时，上级一直回复401是什么原因？

视频监控管理EasyCVR视频融合平台基于云边端一体化架构&#xff0c;可支持多协议、多类型设备接入&#xff0c;具体包括&#xff1a;NVR、IPC、视频编码器、无人机、车载设备、智能手持终端、移动执法仪等。平台具有强大的数据接入、处理及分发能力&#xff0c;可在复杂的网络环…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023