精华内容
下载资源
问答
  • DTaskManager是一款支持用户为标准的Windows任务管理器添加了额外功能的小工具,DTaskManager绿色版功能强劲,能够帮助用户整理内存的使用情况,批量设置优先权,临时挂起进程,监视端口活动,隐藏窗口等等,欢迎...
  • 一个系统中存在着大量的调度任务,同时调度任务存在时间的滞后性,而大量的调度任务如果每一个都使用自己的调度管理任务的生命周期的话,浪费cpu的资源而且很低效。 本文来介绍 go-zero 中 延迟操作,它可能让...

    一个系统中存在着大量的调度任务,同时调度任务存在时间的滞后性,而大量的调度任务如果每一个都使用自己的调度器来管理任务的生命周期的话,浪费cpu的资源而且很低效。

    本文来介绍 go-zero延迟操作,它可能让开发者调度多个任务时,只需关注具体的业务执行函数和执行时间「立即或者延迟」。而 延迟操作,通常可以采用两个方案:

    1. Timer:定时器维护一个优先队列,到时间点执行,然后把需要执行的 task 存储在 map 中
    2. collection 中的 timingWheel ,维护一个存放任务组的数组,每一个槽都维护一个存储task的双向链表。开始执行时,计时器每隔指定时间执行一个槽里面的tasks。

    方案2把维护task从 优先队列 O(nlog(n)) 降到 双向链表 O(1),而执行task也只要轮询一个时间点的tasks O(N),不需要像优先队列,放入和删除元素 O(nlog(n))

    我们先看看 go-zero 中自己对 timingWheel 的使用 :

    cache 中的 timingWheel

    首先我们先来在 collectioncache 中关于 timingWheel 的使用:

    timingWheel, err := NewTimingWheel(time.Second, slots, func(k, v interface{}) {
      key, ok := k.(string)
      if !ok {
        return
      }
      cache.Del(key)
    })
    if err != nil {
      return nil, err
    }
    
    cache.timingWheel = timingWheel

    这是 cache 初始化中也同时初始化 timingWheel 做key的过期处理,参数依次代表:

    • interval:时间划分刻度
    • numSlots:时间槽
    • execute:时间点执行函数

    cache 中执行函数则是 删除过期key,而这个过期则由 timingWheel 来控制推进时间。

    接下来,就通过 cachetimingWheel 的使用来认识。

    初始化

    // 真正做初始化
    func newTimingWheelWithClock(interval time.Duration, numSlots int, execute Execute, ticker timex.Ticker) (
        *TimingWheel, error) {
        tw := &TimingWheel{
            interval:      interval,                     // 单个时间格时间间隔
            ticker:        ticker,                       // 定时器,做时间推动,以interval为单位推进
            slots:         make([]*list.List, numSlots), // 时间轮
            timers:        NewSafeMap(),                 // 存储task{key, value}的map [执行execute所需要的参数]
            tickedPos:     numSlots - 1,                 // at previous virtual circle
            execute:       execute,                      // 执行函数
            numSlots:      numSlots,                     // 初始化 slots num
            setChannel:    make(chan timingEntry),       // 以下几个channel是做task传递的
            moveChannel:   make(chan baseEntry),
            removeChannel: make(chan interface{}),
            drainChannel:  make(chan func(key, value interface{})),
            stopChannel:   make(chan lang.PlaceholderType),
        }
        // 把 slot 中存储的 list 全部准备好
        tw.initSlots()
        // 开启异步协程,使用 channel 来做task通信和传递
        go tw.run()
    
        return tw, nil
    }

    554d5e74961d9fd8eba17dc29d7ea87d.png

    以上比较直观展示 timingWheel“时间轮”,后面会围绕这张图解释其中推进的细节。

    go tw.run() 开一个协程做时间推动:

    func (tw *TimingWheel) run() {
        for {
            select {
          // 定时器做时间推动 -> scanAndRunTasks()
            case <-tw.ticker.Chan():
                tw.onTick()
          // add task 会往 setChannel 输入task
            case task := <-tw.setChannel:
                tw.setTask(&task)
            ...
            }
        }
    }

    可以看出,在初始化的时候就开始了 timer 执行,并以internal时间段转动,然后底层不停的获取来自 slot 中的 list 的task,交给 execute 执行。

    161769e3f74972f3f7319a5f3108d11e.png

    Task Operation

    紧接着就是设置 cache key

    func (c *Cache) Set(key string, value interface{}) {
        c.lock.Lock()
        _, ok := c.data[key]
        c.data[key] = value
        c.lruCache.add(key)
        c.lock.Unlock()
    
        expiry := c.unstableExpiry.AroundDuration(c.expire)
        if ok {
            c.timingWheel.MoveTimer(key, expiry)
        } else {
            c.timingWheel.SetTimer(key, value, expiry)
        }
    }
    1. 先看在 data map 中有没有存在这个key
    2. 存在,则更新 expire -> MoveTimer()
    3. 第一次设置key -> SetTimer()

    所以对于 timingWheel 的使用上就清晰了,开发者根据需求可以 add 或是 update

    同时我们跟源码进去会发现:SetTimer() MoveTimer() 都是将task输送到channel,由 run() 中开启的协程不断取出 channel 的task操作。

    SetTimer() -> setTask()

    • not exist task:getPostion -> pushBack to list -> setPosition
    • exist task:get from timers -> moveTask()

    MoveTimer() -> moveTask()

    由上面的调用链,有一个都会调用的函数:moveTask()

    func (tw *TimingWheel) moveTask(task baseEntry) {
        // timers: Map => 通过key获取 [positionEntry「pos, task」]
        val, ok := tw.timers.Get(task.key)
        if !ok {
            return
        }
    
        timer := val.(*positionEntry)
          // {delay < interval} => 延迟时间比一个时间格间隔还小,没有更小的刻度,说明任务应该立即执行
        if task.delay < tw.interval {
            threading.GoSafe(func() {
                tw.execute(timer.item.key, timer.item.value)
            })
            return
        }
        // 如果 > interval,则通过 延迟时间delay 计算其出时间轮中的 new pos, circle
        pos, circle := tw.getPositionAndCircle(task.delay)
        if pos >= timer.pos {
            timer.item.circle = circle
                    // 记录前后的移动offset。为了后面过程重新入队
            timer.item.diff = pos - timer.pos
        } else if circle > 0 {
            // 转移到下一层,将 circle 转换为 diff 一部分
            circle--
            timer.item.circle = circle
            // 因为是一个数组,要加上 numSlots [也就是相当于要走到下一层]
            timer.item.diff = tw.numSlots + pos - timer.pos
        } else {
            // 如果 offset 提前了,此时 task 也还在第一层
            // 标记删除老的 task,并重新入队,等待被执行
            timer.item.removed = true
            newItem := &timingEntry{
                baseEntry: task,
                value:     timer.item.value,
            }
            tw.slots[pos].PushBack(newItem)
            tw.setTimerPosition(pos, newItem)
        }
    }

    以上过程有以下几种情况:

    • delay < internal:因为 < 单个时间精度,表示这个任务已经过期,需要马上执行
    • 针对改变的 delay
      • new >= old<newPos, newCircle, diff>
      • newCircle > 0:计算diff,并将 circle 转换为 下一层,故diff + numslots
      • 如果只是单纯延迟时间缩短,则将老的task标记删除,重新加入list,等待下一轮loop被execute

    Execute

    之前在初始化中,run() 中定时器的不断推进,推进的过程主要就是把 list中的 task 传给执行的 execute func。我们从定时器的执行开始看:

    // 定时器 「每隔 internal 会执行一次」
    func (tw *TimingWheel) onTick() {
            // 每次执行更新一下当前执行 tick 位置
        tw.tickedPos = (tw.tickedPos + 1) % tw.numSlots
            // 获取此时 tick位置 中的存储task的双向链表
        l := tw.slots[tw.tickedPos]
        tw.scanAndRunTasks(l)
    }

    紧接着是如何去执行 execute

    func (tw *TimingWheel) scanAndRunTasks(l *list.List) {
        // 存储目前需要执行的task{key, value}  [execute所需要的参数,依次传递给execute执行]
        var tasks []timingTask
    
        for e := l.Front(); e != nil; {
            task := e.Value.(*timingEntry)
                    // 标记删除,在 scan 中做真正的删除 「删除map的data」
            if task.removed {
                next := e.Next()
                l.Remove(e)
                tw.timers.Del(task.key)
                e = next
                continue
            } else if task.circle > 0 {
                // 当前执行点已经过期,但是同时不在第一层,所以当前层即然已经完成了,就会降到下一层
                            // 但是并没有修改 pos
                task.circle--
                e = e.Next()
                continue
            } else if task.diff > 0 {
                // 因为之前已经标注了diff,需要再进入队列
                next := e.Next()
                l.Remove(e)
                pos := (tw.tickedPos + task.diff) % tw.numSlots
                tw.slots[pos].PushBack(task)
                tw.setTimerPosition(pos, task)
                task.diff = 0
                e = next
                continue
            }
            // 以上的情况都是不能执行的情况,能够执行的会被加入tasks中
            tasks = append(tasks, timingTask{
                key:   task.key,
                value: task.value,
            })
            next := e.Next()
            l.Remove(e)
            tw.timers.Del(task.key)
            e = next
        }
        // for range tasks,然后把每个 task->execute 执行即可
        tw.runTasks(tasks)
    }

    具体的分支情况在注释中说明了,在看的时候可以和前面的 moveTask() 结合起来,其中 circle 下降,diff 的计算是关联两个函数的重点。

    至于 diff 计算就涉及到 pos, circle 的计算:

    // interval: 4min, d: 60min, numSlots: 16, tickedPos = 15
    // step = 15, pos = 14, circle = 0
    func (tw *TimingWheel) getPositionAndCircle(d time.Duration) (pos int, circle int) {
        steps := int(d / tw.interval)
        pos = (tw.tickedPos + steps) % tw.numSlots
        circle = (steps - 1) / tw.numSlots
        return
    }

    上面的过程可以简化成下面:

    steps = d / interval
    pos = step % numSlots - 1
    circle = (step - 1) / numSlots

    总结

    1. timingWheel 靠定时器推动,时间前进的同时会取出当前时间格list「双向链表」的task,传递到 execute 中执行。因为是是靠 internal 固定时间刻度推进,可能就会出现:一个 60s 的task,internal = 1s,这样就会空跑59次loop。

    2. 而在扩展时间上,采取 circle 分层,这样就可以不断复用原有的 numSlots ,因为定时器在不断 loop,而执行可以把上层的 slot 下降到下层,在不断 loop 中就可以执行到上层的task。这样的设计可以在不创造额外的数据结构,突破长时间的限制。

    同时在 go-zero 中还有很多实用的组件工具,用好工具对于提升服务性能和开发效率都有很大的帮助,希望本篇文章能给大家带来一些收获。

    项目地址

    https://github.com/tal-tech/go-zero

    好未来技术

    展开全文
  • Process Explorer是一款系统进程管理和查看工具,它的功能比WIN自带的任务管理器要强大得多,能够查看正在运行的所有进程,每个进程都可查看CPU占用率,占用的字节数PID值及功能描述,所属公司名称。设置进程的优先...
  • 1.任务管理器关闭资源管理器 explorer.exe重开 **无效** 2.因个性化无法打开 然后修改注册表里的一个文件 从0改成1 **无效** 3.surface自带完全重置系统 **无效** 4.想用U盘重装 弄了好久不知道怎么设置USB...
  • 13、分片广播任务:执行集群部署时,任务路由策略选择"分片广播"情况下,一次任务调度将会广播触发集群中所有执行执行一次任务,可根据分片参数开发分片任务; 14、动态分片:分片广播任务以执行为维度进行分...
  • 降低程序的优先级别

    千次阅读 2005-04-08 16:36:00
    发信人: leavy (☆星河☆), 信区: Fortran标 题: Re: 到现在为止,我的程序已经运行了10个小时发信站: ...这是程序占cpu通常会临时降低win下面: 任务管理器-进程-选中程序右键-设置优先级低于标准linux下: renice N
    发信人: leavy (☆星河☆), 信区: Fortran
    标 题: Re: 到现在为止,我的程序已经运行了10个小时
    发信站: 南京大学小百合站 (Mon Aug 16 20:06:05 2004)

    可以把优先级降低,这样你不操作时cpu全部利用,你运行其他软件也会比较快,这是程序占cpu通常会临时降低
    win下面: 任务管理器-进程-选中程序右键-设置优先级低于标准
    linux下: renice NI jobid (0<NI<=19,可以就设为19最低级别,0是标准级别)
    【 在 coolmaize (断了翅膀) 的大作中提到: 】
    : 我说机子很破因为它是单CPU通道,只要算题,cpu就是100%
    : 出了上上bbs,什么都不可以作。
    : :(
    : 【 在 Quantum (※量子※) 的大作中提到: 】
    : : CPU会一直运行,如果读写文件很多会频繁动用硬盘


    --
    ※ 来源:.南京大学小百合站 bbs.nju.edu.cn.[FROM: 172.16.66.171]
    展开全文
  • 上一篇笔记介绍了一些绕开排程(或调度程序,scheduler)来进行时间管理的一些小方法。这一篇详细介绍RTX的任务调度原理。 RTX主要有三种调度方式: Pre-emptive: 抢断式Round robin: 轮转式Co-operative: ...

    嵌入式OS入门笔记-以RTX为案例:六.RTX的任务调度


    上一篇笔记介绍了一些绕开排程器(或调度程序,scheduler)来进行时间管理的一些小方法。这一篇详细介绍RTX的任务调度原理。

    RTX主要有三种调度方式:

    • Pre-emptive: 抢断式
    • Round robin: 轮转式
    • Co-operative: 合作式

    在正式介绍这些方式之前。先看一下RTX的进程优先等级设置。


    1.RTX的优先度

    每个task在创建之初都会有一个优先级(os_tsk_create(task_name,priority);)。优先级是一个从0到255的整形数据,该数据越高的task。优先级越高。每个优先级都有一个先入先出的队列结构。

    详细说来:

    首先,RTX并不能处理高速中断(FIQ。ARM处理器中最高优先级的中断),相反地,当高速中断发生时。RTX内核可能会被打断。

    然后到普通中断,普通中断并非一个进程,所以不须要设定优先度,但普通中断一定会打断进程。

    然后就到优先度为2-255的进程,这些进程会依照先入先出的顺序执行。低优先度的进程不能打断高优先度的进程,但高优先度的进程会打断低优先度的进程。假设当前最高优先度是x。但全部优先度为x的进程都处于等待状态,那么排程器就会考虑下一优先度(x-1)的进程。但一旦任一x进程进入就绪状态。排程器会打断低优先度进程。

    优先度为1的进程时轮转进程,以下介绍到轮转排程时会记录它与优先度为2-255进程的差别。


    优先度为0的进程为空暇进程。

    当没有进程运行时,RTX会运行它,并提升其优先度到1.


    几个特殊进程的优先度:os_idle_demon(void) 的优先度永远为0, RTX实在没进程可跑才会执行这个进程。os_error (U32 err_code)的优先度永远为255。用于处理错误的。这两个进程原型都在RTX_CONFIG.C文件里。


    另外,除了创建时给进程分配优先级。优先级也是能够通过调用下面服务改变:

    os_tsk_prio(taskID,priority);用于改变其它进程的优先度。

    os_tsk_prio_self(priority); 用于改变当前进程的优先度。


    2.RTX的调度


    搞清楚RTX的优先级后,事实上RTX的调度不难理解。



    1. pre-emptive

    每个进程都有不同的优先级。最高优先级的进程会执行,排程器不会终止它。所以它会执行直到它自行中止挂起(blocked),或者被更高优先级的进程打断。

    自行挂起的办法事实上我们上一节介绍过,就三个:os_tsk_pass();, os_dly_wait(delay_time);os_itv_wait(void);.假设其被中止挂起。其余优先级最高的进程会执行。这个配置的办法就是除能在RTX_CONFIG.C中的Round-Robin Task Switching项。



    2. Round robin


    每个进程的优先级都是1。每个进程都会被分配到一个时间片,在执行完这个时间片后,该进程就会增加优先级为1的队列的末端,然后队列最前端的进程继续执行。

    时间片由RTX_CONFIG.C中的Round_Robin Timeout[ticks]决定。准确时间是Round_Robin Timeout[ticks]×Time tick value[us] (μs). 如上图所看到的。那么时间片就是10000×5=50000μs.配置该排程须要使能Round-Robin Task switching项。



    3. Co-operative


    这个是全部进程都是同样的优先度(比如1,)且除能了轮转式排程。

    在这样的合作模式下,进程不会被排程器挂起,仅仅能自己中止。


    3.小结


    事实上RTX的任务调度非常灵活,最经常使用的就是轮转和抢断式调度混用: 一部分进程的优先度是大于2的。其它进程的优先度是1(轮转式排程)。也就是说假设优先度大于2的进程就绪了,优先执行,假设没有就绪的大于2的进程,那么就先执行轮转式的进程。并且加上不同的进程间能够相互调节进程的优先度,所以调度的自由度非常大的。


    另一些具体的细节问题,比如优先度反转等问题,在记录到进程间通讯后。再具体记录一下吧。


    展开全文
  • 对实际编程来说,理解您的内存管理器的能力与局限性至关重要。在大部分系统语言中,比如 C 和 C++,您必须进行内存管理。本文将介绍手工的、半手工的以及自动的内存管理实践的基本概念。 追溯到在 Apple II 上...
  • 设置查询优先顺序 119 禁用会话缓存 121 向动态 SQL 添加应用程序上下文 122 保存的报表输出 123 设置文件位置以在 IBM Cognos 8 部保存报表输出的副本 123 设置文件位置以在 IBM Cognos 8 中保存报表输出的副本 124...
  • 任务委派给现有自定义管理员 36 为管理员分配文件夹权限 37 分配文件夹权限 37 为管理员分配任务 37 分配或更改对象权限 37 为用户提供资源 38 将资源发布给用户 38 面向多个用户安装应用程序 38 为所有用户安装...
  • 组织单元是可以指派组策略设置或委派管理权限的最小作用域或单位。使用组织单元,用户可在组织单元中代表逻辑层次结构的域中创建容器。这样用户就可以根据用户的组织模型管理账户和资源的配置和使用。 1 e+ }# `! n6...
  • 6-1使用任务管理器监控内存和CPU的使用情况17:28 6-2使用资源管理器监控性能08:15 6-3性能监视器监控性能指标19:47 6-4管理Windows日志08:52 第7章配置系统安全策略1小时27分钟8节 7-1配置账户密码策略20:21 7-2账户...
  • 进程管理经典软件MFC

    2010-12-03 13:45:48
    Svchost.exe:这个进程要着重说明一下,有不少朋友都有这种错觉:若是在“任务管理器”中看到多个Svchost.exe在运行,就觉得是有病毒了。其实并不一定,系统启动的时候,Svchost.exe将检查注册表中的位置来创建需要...
  • DtaskManager

    2011-06-08 13:44:30
    DtaskManager 是一款单文件绿色增强型任务管理器软件。该工具标准的 Windows 任务管理器添加了额外的功能,弥补windows自带任务管理器的不足。内存占用也很小,不影响你的任何其他操作。该工具提供了结束管理进程的...
  • 3)查看:可以配置其他分栏的外观,如:资源管理器、大纲、输出窗口等;另外可以配置光标大小和颜色。 4)窗口:当时学Vim的时候,有一个很好的功能:保存当前工作环境,以便下次可以继续当前的工作。窗口就是用于...
  • 在Microsoft SQL Server 2000的企业管理器中完成数据库和数据表的创建,具体SQL脚本请参见附录gz.sql SET ANSI_NULLS ON GO SET QUOTED_IDENTIFIER ON GO IF NOT EXISTS (SELECT * FROM sys.objects WHERE object_...
  • NOD32ID生成

    2010-02-22 19:54:16
    5、增加ID发布页智能排列的功能(只限顺序读取),当排在前面的发布页无效时会把有效获取到ID的发布页排列到前面,在以后就会优先获取这个发布页。 1.7.1.4_x64更新:2009-11-07 1、修正内置ID发布页。 2、修正非...
  • nod32 id获取

    2010-02-26 18:15:32
    5、增加ID发布页智能排列的功能(只限顺序读取),当排在前面的发布页无效时会把有效获取到ID的发布页排列到前面,在以后就会优先获取这个发布页。 1.7.1.4_x64更新:2009-11-07 1、修正内置ID发布页。 2、修正非...
  • 操作系统(内存管理)

    热门讨论 2009-09-20 12:55:25
    对实际编程来说,理解您的内存管理器的能力与局限性至关重要。在大部分系统语言中,比如 C 和 C++,您必须进行内存管理。本文将介绍手工的、半手工的以及自动的内存管理实践的基本概念。 追溯到在 Apple II 上进行...
  • nod32激活码获取

    热门讨论 2009-10-16 02:46:08
    1.6.5.4更新 1、关闭在压缩包里运行时自动更新 ...5、增加ID发布页智能排列的功能(只限顺序读取),当排在前面的发布页无效时会把有效获取到ID的发布页排列到前面,在以后就会优先获取这个发布页。
  • 5、增加ID发布页智能排列的功能(只限顺序读取),当排在前面的发布页无效时会把有效获取到ID的发布页排列到前面,在以后就会优先获取这个发布页。 1.7.1.4_x64更新:2009-11-07 1、修正内置ID发布页。 2、修正非...
  • 打开组策略编辑,依次选择“计算机配置→Windows设置→安全设置→本地策略→安全选项”,双击“网络访问:本地账号的共享和安全模式”策略,将默认设置“仅来宾—本地用户以来宾身份验证”,更改为“经典:本地...
  • 精易模块3.80

    2014-08-09 01:43:36
    5、新增“进程_取句柄数”,功能与XP系统下任务管理器一样。 6、新增“进程_取IO读取计数”,功能与XP系统下任务管理器一样。 7、新增“进程_取IO读取字节”,功能与XP系统下任务管理器一样。 8、新增“进程_取IO其它...
  • 如何提高英雄联盟FPS

    千次阅读 2017-07-17 20:00:42
    1,右击计算机(我的电脑),选择属性,选择高级系统设置,在性能中点击设置,选择调整为最佳性能2,在右下角电源中选择高性能电源计划3,在任务管理器设置优先级,英雄联盟进程为实时4,打开NVDIA控制面板,选择...

    当FPS特别低的时候,你会觉得画面一直在晃动,眼睛特别累,俗称“卡屏”。

    这里介绍几种立竿见影地不需要升级硬件的提升游戏FPS的方法。

    1,右击计算机(我的电脑),选择属性,选择高级系统设置,在性能中点击设置,选择调整为最佳性能

    2,在右下角电源中选择高性能电源计划

    3,在任务管理器中设置优先级,英雄联盟进程为实时

    4,打开NVDIA控制面板,选择“通过预览调整图像设置”,点击“使用我的优先选择,侧重于性能,可增FPS

    5,打开NVDIA控制面板,选择“管理3D设置”,添加英雄联盟GAME文件夹中的league of legend,在垂直同步选择关
    如图

    6,关闭任何其他进程,包括杀毒,浏览器

    优先级介绍
    你设置了A的优先级高于B,然后A的传输速度就比B的快些啦
    因为电脑的资源都优先传输A 接着再传输B
    进程优先级就是说系统将资源优先给那个进程来使用 比如你想一边看电影一边打文字或干别的什么话,那么就调整那个电影播放器的进程,设置为“低于标准”,这样前台程序就会比后台程序(播放软件)优先,系统会让前台程序优先执行,前台程序空闲的时候再让后台程序满负荷工作。这样就可以充分占用前台程序剩下的系统资源,达到对系统资源的高效利用。
    优先级设成高一般只能在WINDOWS系统发现物理内存不足 使用缓存时才可以体现出也就是说,如果你只开了魔兽,没打开其它耗费大资源软件的话,基本上没影响;如果你开了魔兽,又打开了其它的耗费大量系统资源的软件,那设置魔兽优先级为高的话,系统就分配较多的资源给魔兽,可以提高游戏的运行速度。

    展开全文
  • 任务管理页面按钮展示优化; 日志管理页面增加任务描述信息; JSON构建前端form表单不能缓存数据问题修复; HIVE JSON构建增加头尾选项参数; 备注: 2.1.1版本不建议升级,数据源信息加密方式变更会导致之前已加密...
  • 电脑杀毒

    2020-03-20 11:58:26
    [一].安全模式普通杀毒 1.开机F8键 2.选择安全模式,Enter 3.如果有360等安全软件,优先使用安全软件查看杀毒 如果没有安全...Win(键盘上方块的按键)+R(同时按)进入任务管理器 一、自己动手前,切记有备无患—...
  • 上班族必备软件: HideWizard 窗口隐藏精灵 v6.4 ...  HideWizard是一款专业的图标、窗口隐藏... 综合设置里可以为程序添加密码,并且还实用的添加了屏蔽任务管理器功能,让你需要隐藏的程序做到真正的消失去无踪。
  • 1.80端口被占用,apache启动不了. 问题描述:默认安装apache,安装完成后可以自启动apache,但是... 排查过程:cmd窗口输入netstat –ano,发现80端口已被监听,PID=4,然后在任务管理器查询到PID是系统进程,所以只有网上...
  • NetLimiter v4.1.6.0.zip

    2021-02-18 08:59:17
    优先级 – 允许您优先选择所选应用的流量优先于其他应用; 配额设定 – 如果达到指定的数据传输配额,则阻止或限制应用程序; 流量统计 – 长期数据传输统计;限速范围 – 为计算机中运行的任何应用程序设置最大传输...

空空如也

空空如也

1 2 3 4 5 ... 8
收藏数 147
精华内容 58
关键字:

任务管理器设置优先