精华内容
下载资源
问答
  • 可以清理内存的任务管理器,选中进程,回车即清
  • 【转】:...其实原理很简单,只要获得了该进程的hProcess后,就可以调用SetProcessWorkingSetSize来设置内存使用,这里的参数设置为0xFFFFFF,就把该程序的内存使用设为0,由于该程序还在运行
    【转】:http://bbs.pediy.com/showthread.php?t=17473
    作者:oHuangKeo
    日期:2005-10-10
      现在有很多的内存清理工具,有的还要收费。其实原理很简单,只要获得了该进程的hProcess后,就可以调用SetProcessWorkingSetSize来设置内存使用,这里的参数设置为0xFFFFFF,就把该程序的内存使用设为0,由于该程序还在运行中,所以内存使用量并不是0,会是实际使用大小。
      好了,不多说了,动手做吧,不然要被人扔鸡蛋砸我了。

    1。查找程序处理键盘按键位置。
      用资源编辑工具打开taskmgr.exe(我用的是freeRess),找到快捷键定义,分析一下。第一个就是Del键。Del的值是1050,这是十进制,换成十六进制为0x41A。用OD打开taskmgr.exe,搜索所有Switchs,找0x41A应该在哪里处理。找哇找,找到了,0100CECB处为Switch(case 3F0..41A),好去那里看看。为了测试这是不是就是DEL键,可以在这里下断,然后运行taskmgr.exe,在进程里随便选一个进程,然后按DEL键,OD会断下的,ecx里就是0x41A.证明我们找对地方了。那么我们定义个什么键来做为快捷键清理内存呢?我是用的Enter键(0x418),你也可以设置别的键,要想知道快捷键的值是多少,用刚才的方法,看看ecx里的值是多少就可以了。

    2。找个空地写我们的代码。
      我选择的是从1014F00开始的地址。代码如下:
    01014F00   > /60            pushad                                   ;  进栈保护寄存器的值
    01014F01   .  E8 3A000000   call    taskmgr.01014F40                 ;  这里用Call是方便后面好写代码
    01014F06   .  61            popad                                    ;  出栈,恢复寄存器
    01014F07   .  81E9 F0030000 sub     ecx, 3F0                         ;  原程序中被覆盖的代码
    01014F0D   .^ E9 BF7FFFFF   jmp     taskmgr.0100CED1                 ;  跳回去
    01014F12   .  53 65 74 50 7>ascii   "SetProcessWorkin"               ;  这里开始到1014F2A是字符串SetProcessWorkingSetSize
    01014F22   .  67 53 65 74 5>ascii   "gSetSize",0                     ;  因为程序中没有这个函数,所以要用GetProcAddress来得到函数地址
    01014F2B   .  6B 65 72 6E 6>ascii   "kernel32.dll",0
    01014F38      00            db      00
    01014F39      00            db      00
    01014F3A      00            db      00
    01014F3B      00            db      00
    01014F3C      00            db      00
    01014F3D      00            db      00
    01014F3E      00            db      00
    01014F3F      00            db      00
    01014F40  /$  81F9 18040000 cmp     ecx, 418                         ;  比较是不是回车键
    01014F46  |.  75 37         jnz     short taskmgr.01014F7F           ;  不是就跳去返回
    01014F48  |.  FF70 08       push    dword ptr ds:[eax+8]             ; /[eax+8]里就是当前所选进程的ProcessId
    01014F4B  |.  6A 00         push    0                                ; |Inheritable = FALSE
    01014F4D  |.  68 00010000   push    100                              ; |Access = SET_QUOTA
    01014F52  |.  E8 2291807B   call    kernel32.OpenProcess             ; /OpenProcess
    01014F57  |.  83F8 00       cmp     eax, 0                           ;  打开成功了吗?
    01014F5A  |.  74 23         je      short taskmgr.01014F7F           ;  失败就跳去返回
    01014F5C  |.  50            push    eax                              ;  进栈保存打开的hProcess
    01014F5D  |.  68 2B4F0101   push    taskmgr.01014F2B                 ; /FileName = "kernel32.dll"
    01014F62  |.  E8 10CE7E7B   call    kernel32.LoadLibraryA            ; /LoadLibraryA
    01014F67  |.  68 124F0101   push    taskmgr.01014F12                 ; /ProcNameOrOrdinal = "SetProcessWorkingSetSize"
    01014F6C  |.  50            push    eax                              ; |hModule
    01014F6D  |.  E8 B65C7F7B   call    kernel32.GetProcAddress          ; /GetProcAddress
    01014F72  |.  83F8 00       cmp     eax, 0                           ;  函数地址获得成功了吗?
    01014F75  |.  74 08         je      short taskmgr.01014F7F           ;  不成功就跳去返回
    01014F77  |.  5A            pop     edx                              ;  出栈,取出刚才打开的hProcess
    01014F78  |.  6A FF         push    -1
    01014F7A  |.  6A FF         push    -1
    01014F7C  |.  52            push    edx                              ;  hProcess
    01014F7D  |.  FFD0          call    near eax                         ;  call SetProcessWorkingSetSize
    01014F7F  />  C3            retn                                     ;  返回

    这样添加好后,在把刚才原程序中0100CECB该成"jmp 01014F00",跳转到我们添加的代码就OK了。保存文件,运行一下试试。选择一个进程,按回车键,嘿嘿,内存减少了,嘻嘻。(不能是系统进程,因为权限不够。)

        在分析taskmgr.exe时还发现它会去打开注册表中的[HKEY_CURRENT_USER/Software/Microsoft/Windows/CurrentVersion/Policies/System/DisableTaskMgr]键值,如果不为0就会弹出“任务栏已被管理员禁止”。地址是
    01005527  |. /74 4B         je      short taskmgr.01005574
    这个是关键性的跳转。不跳就弹出“任务栏已被管理员禁止”,跳就继续后面的工作。

    我修改好的下载地址:http://ohko.ys168.com
     
    展开全文
  • 如何打开任务管理器

    2020-03-30 10:40:04
    我们在平常使用电脑的过程中,经常会同时开多个软件,导致电脑内存不够,变得卡顿,这时我们便可以通过两步法...下面我就给大家介绍最常见、最快捷的六种打开任务管理器的方法,以后关闭程序再也不用等待或者重启了。

    我们在平常使用电脑的过程中,经常会同时开多个软件,导致电脑内存不够,变得卡顿,这时我们便可以通过两步法——关闭不需要运行的程序+清理缓存垃圾来使电脑重新运行的飞起。
    但是有时候电脑卡顿到关闭不了进程怎么办?程序一直强行关闭也不行怎么办?这时候需要我们的任务管理器出手了。那么问题来了,如何打开任务管理器呢?下面我就给大家介绍最常见、最快捷的六种打开任务管理器的方法,以后关闭程序再也不用等待或者重启了。

    方法一:右键点击任务栏空白处,然后点击“任务管理器”即可。
    在这里插入图片描述
    方法二:命令提示符界面打开。

    (1)同时按下“Win+R”键,然后在弹出的对话框中输入“cmd”并按回车键。
    在这里插入图片描述
    (2)接着在命令提示符界面(DOS系统)中输入“taskmgr”运行即可。
    在这里插入图片描述
    方法三:同时按下“Ctrl+Alt+Delete”快捷键,再点击任务管理器即可。
    在这里插入图片描述
    方法四:同时按下“Esc+Shift+Ctrl”快捷键,直接打开任务管理器。
    在这里插入图片描述
    方法五:使用文件打开任务管理器。

    (1)首先,先新建一个记事本,在记事本中输入:C:\Windows\system32\taskmgr.exe
    在这里插入图片描述
    (2)然后点击左上角的【文件】-【另存为】,将文件保存为【任务管理器.bat】。在这里插入图片描述
    (3)双击或右键打开这个任务管理器文件即可。在这里插入图片描述
    方法六:文件夹搜索栏打开任务管理器。

    (1)先打开任意一个文件夹,点击左上角的小文件夹。
    在这里插入图片描述
    (2)在文件夹搜索栏中输入“ C:\Windows\system32\taskmgr.exe ” 。在这里插入图片描述
    (3)点击回车键运行,即可打开任务管理器。
    在这里插入图片描述
    以上就是打开任务管理器的六种方法,希望对大家有所帮助。

    你得丢开往事,才能继续前行。

    展开全文
  • android 任务管理器

    2012-11-08 13:41:23
    1. 任务管理 对后台运行的进程进行管理,可对某个进程进行查看程序详情、杀死进程、打开程序操作 2. 应用管理 对手机全部应用进行管理 3. 系统资源监控 可以实时查看手机运行时的CPU利用率、内存利用率、已使用内存...
  • 一个基于MFC的简单的任务管理器,支持基本进程操作,内存清理,模块查看,运行新进程,关机重启等功能。
  • 这是以前写的,本来想做商业...此软件实现了一下功能:窗口管理 进程管理 CPU查看 垃圾清理 痕迹清理 安装程序管理。 另外补充一句,如果有什么不明白的地方或有什么好的意见欢迎来信,我的邮件:ziming1985@163.com
  • Linux7:多进程初步:进程相关概念,创建进程,特殊的进程进程资源清理进程退出,exec函数族以及system函数 1.进程描述: 进程初探: 程序 可执行的二进制代码文件 进程 程序被加载到内存中运行 ...任务管理器

    Linux7:多进程初步:进程相关概念,创建进程,特殊的进程,进程资源清理,进程退出,exec函数族以及system函数

    1.进程描述:

    进程初探:

    程序
    可执行的二进制代码文件
    进程
    程序被加载到内存中运行
    系统中基本的执行单元
    联系
    具有一定独立功能的程序的一次运行活动,操作系统动态执行的单元,包含程序从调度到消亡的整个过程是动态的过程
    运行着的程序都是一个进程
    系统本身也运行着许多管理系统资源和用户访问的程序
    一个程序可以被加载多次成为不同的进程

    查看进程:

    windows操作系统下:
    任务管理器:
    在这里插入图片描述

    Linux 操作系统下:
    shell命令:

    ps命令:
    
    ps -ef
      UID      PID        PPID             C       STIME       TTY           TIME             CMD
    用户ID    进程ID号    父进程ID      CPU占用率    开始时间    启动的终端   占用CPU总时间      启动命令
    
    
     ps -aux//查看进程的详细信息
      stat
       S:睡眠
       R:运行
        执行或即将运行状态
       D:不可中断的睡眠(等待)
        通常等待输入或输出的完成
       T:停止
        通常是被shell或调试器控制停止
       N:低优先级任务
        nice值被修改
       Z
        僵尸进程
       X
        死进程
       s:进程是会话期首进程
       +:后台进程
        和用户交互的任务
       l:进程是多线程的
       <:高优先级任务

    在这里插入图片描述
    在这里插入图片描述
    进程号:

    进程的标识号(pid) 无符号整形 唯一
    内核限制进程号小于等于32767,达到时重置进程号计数器
    计数器重置从300开始,1-300被系统进程和守护进程占用
    32位开发平台最大是32767,64位达2的22次方
    /proc/sys/kernel/pid_max

    进程状态:

    执行态:该进程正在运行,即进程正在占用 CPU, 任何时候都只有一个进程。
    就绪态:进程已经具备执行的一切条件,正在等待分配 CPU 的处理时间片。
    等待态:进程正在等待某些事件,当前不能分配时间片, 进程不能使用 CPU,若等待事件发生(等待的资源分配到)则可将其唤醒,变成就绪态

    相关概念:

    父进程
    创建/启动一个进程的进程称之为该进程的父进程
    子进程
    相对于改程序的父进程,该进程为子进程
    父子进程是相对的概念

    内存布局:

    每一个进程有独立的空间
    文本段
    包含进程运行的程序机器语言指令
    只读性
    防止进程通过错误指针修改自身的指令
    数据段
    初始化数据段
    包含显示初始化的全局变量和静态变量
    程序加载到内存的时候读取这部分变量
    未初始化数据段(BSS段)
    未进行初始化的全局变量和静态变量
    程序启动之前,系统将本段所有的内存初始化为0

    动态开辟的内存

    动态增长和收缩的段,由栈帧组成,存放局部变量、函数参数值等

    如图:
    在这里插入图片描述

     size命令 
      //查看进程所占资源
    

    任务调度:

    按一定的算法,从一组待运行的进程中选出一个进程占用CPU

    进程特点:

    动态性
    并发性
    独立性
    异步性

    杀死进程:

    ps  //查看进程
    kill -9 进程ID   //杀死进程

    2.进程的使用:

    子进程:

    用户进程创建子进程,子进程存在于系统,独立于父进程
    可被系统调度,可被分配系统资源

    查看进程号:

    getpid:
    功能
    获得进程id
    函数原型
    pid _t getpid(void)
    所属头文件
    #include <sys/types.h>
    #include <unistd.h>
    参数

    返回值
    调用该函数的进程id

    getppid:
    功能
    获得父进程id
    函数原型
    pid_t getppid(void)
    所属头文件
    #include <sys/types.h>
    #include <unistd.h>
    参数

    返回值
    调用该函数的进程的父进程id

    创建进程:

    fork函数:
    功能:
    创建新进程
    原型
    pid_t fork(void)
    所属头文件
    <unistd.h>
    参数

    返回值
    在父进程中返回子进程的PID,在子进程中返回0,失败返回-1
    特点
    fork成功后,会创建一个子进程,子进程会复制父进程资源父子进程同时从fork函数以下开始并行运行。互不干扰。拥有独立的数据段、堆栈,但无法确定父子进程的运行顺序

    代码演示demo2.c:

    #include <stdio.h>
    #include <sys/types.h>
    #include <unistd.h>
    int main()
    {
    pid_t pid;
    pid=getpid();
    fork();//创建一个进程,两个进程在运行,返回两个pid
    if(pid==getpid())
    {
     printf("fujincheng\n");
    }else
    {
     printf("zijincheng\n");
    }
    printf("my pid :%d\n当前pid:%d\n",pid,getpid());
    return 0;
    }
    

    运行结果:
    在这里插入图片描述

    vfork函数:
    功能
    创建子进程,并且阻塞父进程
    原型
    pid_t vfork(void)
    所属头文件
    <unistd.h> <sys/type.h>
    参数

    返回值
    在父进程中返回子进程的PID,在子进程中返回0,失败返回-1
    特点
    vfork成功后,会创建一个子进程,子进程共用(独占)父进程资源,子进程退出父进程才会得到执行。分享父进程的数据段、堆,一定是子进程先运行
    注意
    使用vfork的时候,为了保证子进程比父进程先运行,只有子进程运
    行exec或者exit函数之后,才会去运行父进程
    ,否则会发生段错误

    代码演示:

    #include <stdio.h>
    #include <sys/types.h>
    #include <unistd.h>
    #include <stdlib.h>
    int main()
    {
      int cnt=0;
      pid_t pid;
      pid=vfork();//创建子进程
      if(pid>0)
      {
       while(1){
       printf("fujincheng\n");
       sleep(1);
       }
      }else if(pid==0)
      {
       while(1){
       printf("ZIjincheng\n");
       sleep(1);
       cnt++;
       if(cnt==3)
       {
         exit(0);
       }
       }
      }
     return 0;
    }
    

    代码实现:当子进程中cnt==3时,退出,再去执行父进程

    运行结果:
    在这里插入图片描述

    特殊进程:

    0号进程:
    操作系统的引导程序
    祖先进程:
    操作系统启动的第一个程序,1号进程
    孤儿进程:
    父进程先退出,子进程被init接管,子进程退出后init会回收其占用的相关资源
    在Ubuntu的图形界面下,孤儿进程会被upstart收养而不是init
    upstart是Ubuntu使用的用来代替init的,可更快的启动系统,以及在硬件热拔插的时候启动或者停止相关服务
    ps -x |grep +僵尸进程的进程号
    缺点
    子进程的相关资源无法清理回收
    僵尸进程:
    子进程退出,父进程没有做清理工作
    一种非常特殊的进程,它几乎已经放弃了所有内存空间,没有任何可执行代码,也不能被调度,仅仅在进程列表中保留一个位置,记载该进程的退出状态等信息供其他进程收集,除此之外,僵尸进程不再占有任何内存空间
    父进程退出会清理子进程

    进程等待:

    wait以及waitpid会等待指定的子进程退出然后做清理工作
    wait函数
    功能
    等待调用它的进程,直到子进程结束
    函数原型
    pid_t wait(int *status);
    所属头文件
    <sys/types.h><sys/wait.h>
    参数
    status 若为空,则代表任意状态结束的子进程
    status 若不为空,则代表指定状态结束的子进程
    一般默认为NULL
    返回值
    成功返回终止的那个子进程的id,失败返回-1

    wait代码演示:

    #include <sys/types.h>
    #include <sys/wait.h> 
    #include <unistd.h> 
    #include <stdlib.h>
     #include <stdlib.h> 
    #include <stdio.h> 
    int main() 
    { 
    pid_t pid,pc; 
    int status; 
    printf("wait实例:\n"); 
    pid=fork(); 
    if(pid<0)//创建出错, 
    printf("error ocurred!\n"); 
    else if(pid == 0) //如果是子进程 
    { 
    printf("我是子进程的ID=%d\n",getpid());
     sleep(10); //睡眠10秒 
    exit(7); 
    } 
    else //父进程 
    { 
    pc=wait(&status); //等待子进程结束; 得到子进程的ID
    if(WIFEXITED(status)) //子程序正常结束返回非0值,异常返回0
    { 
    printf("我是父进程,我等待的子进程的id号=%d\n",pc); 
    printf("退出码是%d\n",WEXITSTATUS(status)); 
    } 
    else 
    { 
    printf("子进程退出异常!\n"); 
    } 
    } 
    exit(0);
    }
    

    代码实现:父进程等待子进程退出。
    在第3行结果打印出来前有10 秒钟的等待时间,这就是我们设定的让子进程睡眠的时间,只有子进程从睡眠中苏醒过来,它才能正常退出,也就才能被父进程捕捉到
    运行结果:
    在这里插入图片描述

    waitpid函数
    功能
    暂时停止目前进程的执行,直到有信号来到或子进程结束
    原型
    pid_t waitpid(pid_t pid,int * status,int options);
    所属头文件
    #include<sys/types.h>
    #include<sys/wait.h>
    参数
    status:保存进程退出时状态
    pid
    0:等待指定的pid
    -1:等待任意的PID
    options
    0:同 wait,阻塞父进程,等待子进程退出–一般为0
    返回值
    成功返回子进程识别码(PID) ,如果有错误发生则返回返回值-1
    waitpid(pid,NULL,0);//指定的进程退出
    waitpid(-1,NULL,0)//同wait(NULL);

    waitpid代码演示:

    #include <sys/types.h>
    #include <sys/wait.h> 
    #include <unistd.h> 
    #include <stdlib.h>
     #include <stdlib.h> 
    #include <stdio.h> 
    int main() 
    { 
    pid_t pid,pc;
     pid=fork(); 
    int status; 
    if(pid<0) 
    { 
    printf("创建进程失败!\n"); 
    } 
    else if(pid==0) 
    { 
    printf("我是子进程,我的ID=%d\n",getpid());
     sleep(10); 
    exit(0); 
    } 
    else 
    { 
    do
    { 
    pc=waitpid(pid,&status,WNOHANG);//使用了WNOHANG参数,waitpid就不会等待,直接返回0. 
    // pc=waitpid(pid,&status,0); 
    if(pc==0) 
    { 
    printf("没有收集到子进程!\n"); 
    sleep(1); 
    } 
    }while(pc==0);//等不到,继续等, 
    if(pid==pc) 
    printf("等到了子进程\n");
     else printf("出错了\n");
     printf("我是父进程,我要等的进程id是%d\n",pc); 
    } 
    exit(0); 
    }
    

    运行结果:

    在这里插入图片描述
    从结果看出:

    先执行父进程,输出"没有收集到子进程",然后sleep(1),此时执行了子进程,输出"我是…31842",sleep(10);然后执行父进程,因为父进程不会等待子进程,所以不断的收集子进程,直到子进程sleep(10),结束后,才会收集到.

    进程退出:

    方法:
    exit();//正常结束一个进程会清理缓冲区
    0 表示正常结束;其他值表示错误,进程非正常结束
    函数的参数可在shell中查看
    _exit();直接进入内核释放用户进程的地址空间
    exit 和_exit 函数都是用来终止进程的。当程序执行到 exit 或_exit 时,进程会无条件地停止剩下的所有操作,清除包数据结构,并终止本进程的运行。
    return //自然返回也会结束进程
    return语句会被编译器翻译为调用exit
    信号
    ctrl + c
    ctrl +
    kill -9 进程号
    //杀死指定进程

    退出清理函数:

    函数原型
    int atexit(void (*function)(void));
    函数功能
    注册退出清理函数,在任意进程结束的时候,自动执
    行退出清理函数
    函数参数
    void (*function)(void)
    函数指针,指向一个无参数,无返回值的函数
    函数返回值
    成功返回0,失败返回非0值
    注意:该函数不需要被调用,只要在函数
    开始之前进行注册,在进程结束的时候就会自己执行

    参考代码:

    #include <stdio.h>
    #include <sys/types.h>
    #include <sys/ipc.h>
    #include <sys/msg.h>
    #include <string.h>
    #include <unistd.h>
    #include <stdlib.h>
    int i=0;
    void clean(void)
    {
    i++;
    printf("i=%d\n",i);
    }
    int main()
    {
    atexit(clean);
    fork();
    fork();
    }

    运行结果:
    在这里插入图片描述
    atexit:
    是在进程结束的时候自动执行清理函数。

    3.执行程序:

    常用的函数族:

    exec 函数族就提供了一个在进程中启动另一个程序执行

    #include <unistd.h>
    extern char **environ;
    
    int execl(const char *path, const char *arg, ...);
    int execlp(const char *file, const char *arg, ...);
    int execle(const char *path, const char *arg,..., char * const envp[]);
    int execv(const char *path, char *const argv[]);
    int execvp(const char *file, char *const argv[]);
    int execvpe(const char *file, char *const argv[],char *const envp[]);

    使用原因:
    当进程认为自己不能再为系统和用户做出任何贡献时,就可以调用任何 exec 函数族让自己重生
    如果一个进程想执行另一个程序,那么它就可以调用 fork 函数新建一个进程,然后调用任何一个 exec,这样看起来就好像通过执行应用程序而产生了一个新进程。

    exec函数族:
    int execl(const char *path, const char *arg, …);逐个列举的方式
    int execlp(const char *file, const char *arg, …);从PATH 环境变量中查找文件并执行
    int execle(const char *path, const char *arg,…, char * const envp[]);
    int execv(const char *path, char *const argv[]);将所有参数整体构造指针数组传递
    int execvp(const char *file, char *const argv[]);
    l->list
    命令参数以列表的方式提供,NULL结尾
    v->vector
    命令参数以二维数组形式提供,数组的每一行为一个命令行参数
    e->environment
    传递给程序的环境列表

    execl
    功能
    使用完整的文件目录来查找对应的可执行文件。注意目录必须以“/”开头,否则将其视为文件名
    原型
    int execl(const char *path, const char *arg, …);
    所属头文件
    #include <unistd.h>
    参数
    path:执行文件的路径
    arg:可执行文件所需要的参数
    参数要以NULL 结尾 (char *)0
    返回值

    特点
    当调用execl函数的时候,程序的代码段发生变化,变为execl要执行的功能的代码段,必须以 NULL 表示结束,如果使用逐个列举方式,那么要把它强制转化成一个字符指针
    system:
    运行shell指令系统函数正常函数调用

    参考代码:execl和system函数的比较:

    演示代码:

    /*******************************
    *文件名称: stack.c
    *创建时间:20.10.10
    *修改时间:20.10.10
    *文件功能:顺序栈
    *文件版本:v1.0
    ********************************/
    #include <stdio.h>
    #include <string.h>
    #include <unistd.h>
    #include <stdlib.h>
    #define MAX 7
    enum result
    {
     ERR=-1,OK
    };
    struct stack
    {
     int data[MAX];
     int top;
    };
    int push(struct stack *p,int num);
    int pop(struct stack *p,int *d);
    int main()
    {
     struct stack s;
     s.top = -1;
     int i = 0,num;
     for(i=0;i<9;i++)
     {
      if(push(&s,i)==-1)
       printf("%d\t栈满,无法继续添加数据\n",i);
     } 
     printf("~~~~~~~~~~~~~\n");
     //execl("/bin/ls","ls","-l",NULL);//覆盖原程序,进行执行
     system("ls -l");//执行终端指令  ---执行完,继续原程序
     for(i=0;i<9;i++)
     {
      if(pop(&s,&num) ==0)
       printf("%d 出栈\n",num);
      else
       printf("栈空\n");
     }
     return 0;
    }

    execl和fork函数的搭配使用:

    演示代码:

    #include <stdio.h>
    #include <unistd.h>
    #include <stdlib.h>
    #include <sys/wait.h>
    int main()
    {
     int num = 10;
     pid_t pid = fork();
     if(pid < 0)
     {
      perror("fork");
      return -1;
     }
     else if(pid == 0)
     {
      printf("child process\n");
      execl("/bin/ls","ls","-l",NULL);
     }
     else
     {
      wait(NULL);
      printf("parent process\n");  
     }
     return 0;
    }
    

    运行结果:
    在这里插入图片描述
    在这里插入图片描述

    execl和vfork函数的搭配使用:

    vfork父子进程资源共享:在调用exit,exec函数族之前和父进程共享资源。
    补充:子进程结束必须要exit或者函数族,如果不使用,运行时会出现段错误。

    演示代码:

    #include <stdio.h>
    #include <unistd.h>
    #include <stdlib.h>
    int main()
    {
     int num = 10;
     pid_t pid = vfork();
     if(pid < 0)
     {
      perror("vfork");
      return -1;
     }
     else if(pid == 0)
     {
      num++;
      printf("child process\n");
      execl("./w","./w","/home/li/text","./89",NULL);
      exit(0);
     }
     else
     {
      printf("parent: num=%d\n",num);
      printf("parent process\n");
     }
     return 0;
    }
    

    运行结果:和fork一样
    在这里插入图片描述
    在这里插入图片描述

    execlp:
    execlp()会从PATH 环境变量所指的目录中查找符合参数file的文件名,找到后便执行该文件,然后将第二个以后的参数当做该文件的argv[0]、argv[1]……,最后一个参数必须用空指针(NULL)作结束。如果用常数0来表示一个空指针,则必须将它强制转换为一个字符指针,否则将它解释为整形参数
    原型
    int execlp(const char * file,const char * arg,…,(char *)0);

    演示代码:

    #include <stdio.h>
    #include <unistd.h>
    #include <stdlib.h>
    #include <sys/wait.h>
    int main()
    { 
      //execl("/bin/ls","ls","-l",NULL);
      execlp("ls","ls","-l",NULL);
     return 0;
    }
    

    运行结果:

    在这里插入图片描述

    execle:
    可以传递一个指向环境字符串指针数组的指针。
    例如:
    char *env_init[] = {“AA=aa”,”BB=bb”,NULL};

    #include <stdio.h>
    #include <unistd.h>
    #include <stdlib.h>
    #include <sys/wait.h>
    int main()
    { 
      char *envp[]={"AA=HELLO","BB=123",NULL};//sizeof(envp)=12;shuzuzhizhen(4)
      //execl("/bin/ls","ls","-l",NULL);
      //execlP("ls","ls","-l",NULL);
      execle("/bin/ls","ls","-l",NULL,envp);  
     return 0;
    }
    

    运行结果:
    在这里插入图片描述

    execv:
    应先构造一个指向各参数的指针数组,然后将该数组的地址作为这些函数的参数。
    例如:
    如char *arg[]这种形式,且arg最后一个元素必须是NULL
    char *arg[] = {“ls”,”-l”,NULL};

    演示代码:
    execv.c

    #include <stdio.h>
    #include <string.h>
    #include <unistd.h>
    #include <stdlib.h>
    extern char **environ;
    int main()
    { 
     char *arg[]={"./hello",NULL}; 
     execv("./hello",arg); 
     return 0;
    }

    hello.c

    #include <stdio.h>
    #include <unistd.h>
    extern char **environ;
    int main()//循环打印环境变量
    {
     printf("%s is called %d\n",__FILE__,__LINE__);
     
     while(*environ)
     {
      printf("%s\n",*environ++);
     } 
      return 0;
    }

    运行结果:
    在这里插入图片描述

    5.shell命令调用:

    system
    函数原型
    #include <stdlib.h>
    int system(const char *command);
    函数功能
    执行可执行程序
    函数参数
    command–要执行的可执行程序
    函数返回值
    参考man帮助

    system函数通过调用shell程序/bin/sh–c来执行string所指定的命令,该函数在内部是通过调用fork、
    execve(“/bin/sh”,…)、waitpid函数来实现的。通过system创建子进程后,原进程和子进程各自运行,相互间
    关联较少。如果system调用成功,将返回0。

    参考文章:
    多进程初步
    参考结构流程图:
    多进程初步
    注:需要使用xmind软件进行查看

    展开全文
  • 由于不是系统级的应用, 也没有获得ROOT权限, 所以自己实现任务管理器其实意义并不是很大, 就像没有root的手机安装了LBE这类的手机助手, 虽然也带一键清理内存清理后台进程的功能, 但由于手机助手没有ROOT的最高权限,...

    由于不是系统级的应用, 也没有获得ROOT权限, 所以自己实现任务管理器其实意义并不是很大, 就像没有root的手机安装了LBE这类的手机助手, 虽然也带一键清理内存清理后台进程的功能, 但由于手机助手没有ROOT的最高权限, 因此面对开启了守护进程或者其他自启动的应用进程也是手无举措. 而随着谷歌的推动, 即将推送面世的新系统Android  M, 也对权限的管理越来越严格, 这也看出一个趋势, 对移动系统的安全和稳定性要求是越来越高.


    虽然意义并不是很大, 但我们还是来练练手吧, 说不定哪天就用上了呢... 哈哈哈.

    (效果图)



    API是直接提供获取包信息, 应用进程信息以及关闭后台进程等接口的. 思路大概是, 首先获取所有正在运行的进程, 包括系统应用进程和非系统应用进程. 为了防止误关系统进程而引起的错误, 我们过滤掉系统进程, 只在列表显示非系统进程. 然后根据进程的包名, 可以实现关闭正在运行的某个进程或所有进程. 


    但这里通过这里的例子, 发现关闭了比如微信这样的软件, 但很快又在后台重新创建线程继续运行, 所以做的再好的第三方手机助手应用, 只要这个应用程序没有获取root权限或者系统权限, 依然是无法彻底关闭进程或者防止自启的. 就算加入了类似锁屏自动清后台, 一键清理内存等等这样的功能, 没有root权限的普通应用只能通过类似守护进程的方式, 维持本应用的生命力, 然后每隔一段时间就清一次后台进程. 也额外的耗一点电. 当然这好不好, 就看后台一个应用程序能不能"杀"掉众多第三方后台应用而比原来更节电, 见仁见智吧哈.


    实现的过程, 并没有什么困难的地方, 所以就直接上代码了:

    首先是ListView的item布局文件 process_list_item.xml :

    <RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
        xmlns:tools="http://schemas.android.com/tools"
        android:layout_width="match_parent"
        android:layout_height="100dp"
        android:padding="10dp"
        android:descendantFocusability="blocksDescendants"
        >
    
        <ImageView
            android:id="@+id/imv_avatar"
            android:layout_width="45dp"
            android:layout_height="45dp"
            android:layout_alignParentLeft="true"
            android:layout_centerVertical="true"
            android:src="@mipmap/ic_launcher"
            />
    
        <TextView
            android:id="@+id/tv_app_name"
            android:layout_width="wrap_content"
            android:layout_height="30dp"
            android:gravity="center_vertical|left"
            android:layout_toRightOf="@+id/imv_avatar"
            android:layout_centerVertical="true"
            android:layout_marginLeft="15dp"
            android:textSize="18sp"
            android:text=""
            />
    
        <TextView
            android:id="@+id/tv_app_process_name"
            android:layout_width="160dp"
            android:layout_height="40dp"
            android:gravity="center"
            android:layout_centerVertical="true"
            android:textSize="18sp"
            android:visibility="gone"
            android:maxLines="2"
            />
    
        <Button
            android:id="@+id/btn_stop_app"
            android:layout_width="80dp"
            android:layout_height="50dp"
            android:layout_alignParentRight="true"
            android:layout_centerVertical="true"
            android:text="关闭进程"
            />
    
    </RelativeLayout>

    然后是主类布局文件 activity_main.xml :

    <RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
        xmlns:tools="http://schemas.android.com/tools"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:orientation="vertical"
        >
    
        <TextView
            android:id="@+id/tv_main_title"
            android:layout_width="match_parent"
            android:layout_height="50dp"
            android:text="任务管理器"
            android:gravity="center"
            android:textSize="18sp"
            android:background="#BDBDBD"
            android:layout_alignParentTop="true"
            />
        <Button
            android:id="@+id/btn_main_clear"
            android:layout_width="match_parent"
            android:layout_height="50dp"
            android:text="一键清理"
            android:gravity="center"
            android:textSize="16sp"
            android:textColor="#23BB67"
            android:layout_below="@+id/tv_main_title"
            />
    
        <ListView
            android:id="@+id/lv_main"
            android:layout_width="match_parent"
            android:layout_height="match_parent"
            android:layout_below="@+id/btn_main_clear"
            />
    
    
    </RelativeLayout>
    

    进程信息对象 ProcessInfo :

    /**
     * Created by AlexTam on 2015/7/29.
     */
    public class ProcessInfo {
        private String labelName;
        private Drawable labelIcon;
        private String processName;
    
        public ProcessInfo(){ }
    
        public ProcessInfo(String labelName, Drawable labelIcon, String processName) {
            this.labelName = labelName;
            this.labelIcon = labelIcon;
            this.processName = processName;
        }
    
        public String getLabelName() {
            return labelName;
        }
    
        public void setLabelName(String labelName) {
            this.labelName = labelName;
        }
    
        public Drawable getLabelIcon() {
            return labelIcon;
        }
    
        public void setLabelIcon(Drawable labelIcon) {
            this.labelIcon = labelIcon;
        }
    
        public String getProcessName() {
            return processName;
        }
    
        public void setProcessName(String processName) {
            this.processName = processName;
        }
    }

    然后是Adapter, 里面给每个item的按钮都添加点击事件 : 

    /**
     * Created by AlexTam on 2015/7/29.
     */
    public class ProcessListAdapter extends BaseAdapter{
        private Context context;
        private List<ProcessInfo> processList;
        private viewHolder holder;
        private processListButtonClick listener;
    
    
        public ProcessListAdapter(Context context, List<ProcessInfo> processList,
                processListButtonClick listener)
        {
            this.context = context;
            this.processList = processList;
            this.listener = listener;
        }
    
        @Override
        public int getCount() {
            return processList.size();
        }
    
        @Override
        public Object getItem(int position) {
            return processList.get(position);
        }
    
        @Override
        public long getItemId(int position) {
            return position;
        }
    
        @Override
        public View getView(int position, View convertView, ViewGroup parent) {
            ProcessInfo processInfo = (ProcessInfo)getItem(position);
    
            if(convertView == null)
            {
                holder = new viewHolder();
                convertView = View.inflate(context, R.layout.process_list_item, null);
                holder.imv_avatar = (ImageView) convertView.findViewById(R.id.imv_avatar);
                holder.tv_name = (TextView) convertView.findViewById(R.id.tv_app_name);
                holder.tv_processName = (TextView) convertView.findViewById(R.id.tv_app_process_name);
                holder.btn = (Button) convertView.findViewById(R.id.btn_stop_app);
            }
            else
            {
                holder = (viewHolder)convertView.getTag();
            }
    
            holder.imv_avatar.setImageDrawable(processInfo.getLabelIcon());
            holder.tv_name.setText(processInfo.getLabelName());
            holder.tv_processName.setText(processInfo.getProcessName());
            holder.btn.setOnClickListener(new POnClickListener(processInfo.getProcessName()));
    
            convertView.setTag(holder);
    
            return convertView;
        }
    
        private class POnClickListener implements View.OnClickListener
        {
            private String processName;
    
            public POnClickListener(String processName)
            {
                this.processName = processName;
            }
    
            @Override
            public void onClick(View v)
            {
                if(listener != null)
                    listener.onButtonClick(processName);
            }
        }
    
        private class viewHolder
        {
            ImageView imv_avatar;
            TextView tv_name;
            TextView tv_processName;
            Button btn;
        }
    
        public interface processListButtonClick
        {
            void onButtonClick(String processName);
        }
    
    }

    OK, 最后是主类 MainActivity :

    /**
     * Created by AlexTam on 2015/7/29.
     */
    public class MainActivity extends Activity {
        private ListView ll_main;
    
        private List<ProcessInfo> processList
                = new ArrayList<ProcessInfo>();
        private List<ApplicationInfo> applicationInfoList ;
    
        private ProcessListAdapter adapter = null;
    
        private Button btn_clear;
    
        private List<String> processNamelist = new ArrayList<String>();
    
        private ProgressDialog progressDialog;
    
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_main);
    
            ll_main = (ListView) findViewById(R.id.lv_main);
            btn_clear = (Button) findViewById(R.id.btn_main_clear);
    
            getProcessList();
    
            btn_clear.setOnClickListener(new MyOnclick());
        }
    
    
        @Override
        public void onDestroy()
        {
            super.onDestroy();
        }
    
    
        private class MyOnclick implements View.OnClickListener
        {
            @Override
            public void onClick(View v)
            {
                if(v == btn_clear)
                {
                    clearAllBackgroundProcess();
                }
            }
        }
    
    
        /**
         * 获取进程信息列表
         */
        private void getProcessList()
        {
            ActivityManager activityManager
                    = (ActivityManager)getSystemService(ACTIVITY_SERVICE);
    
            //获取所有将运行中的进程
            List<ActivityManager.RunningAppProcessInfo> runningAppList
                    = activityManager.getRunningAppProcesses();
    
            PackageManager packageManager
                    = this.getPackageManager();
    
            //获取所有包信息
            applicationInfoList
                    = packageManager.getInstalledApplications(PackageManager.GET_UNINSTALLED_PACKAGES);
    
    
            if(processList != null && processList.size() > 0)
                processList.clear();
    
            if(processNamelist != null && processNamelist.size() > 0)
                processNamelist.clear();
    
            for(ActivityManager.RunningAppProcessInfo process : runningAppList)
            {
                if(process.processName.indexOf(this.getPackageName()) < 0)
                {   //过滤本应用包名
                    ProcessInfo p = new ProcessInfo();
    
                    ApplicationInfo appInfo = getApplicationInfoByProcessName(process.processName);
                    if(appInfo == null)
                    {
                        //有些应用的守护进程并没有目标应用对应,此时返回null
                    }
                    else
                    {
                        p.setLabelIcon(appInfo.loadIcon(packageManager));
                        p.setLabelName(appInfo.loadLabel(packageManager).toString());
                        p.setProcessName(appInfo.processName);
    
                        processNamelist.add(appInfo.processName);
                        processList.add(p);
                    }
                }
            }
    
            if(adapter == null)
            {
                adapter = new ProcessListAdapter(MainActivity.this, processList,new ItemButtonClick());
                ll_main.setAdapter(adapter);
                ll_main.setOnItemClickListener(new MyOnItemClickListener());
            }
            else
            {
                adapter.notifyDataSetChanged();
            }
    
        }
    
        /**
         * 根据进程名获取应用信息
         * @param processNames
         * @return
         */
        private ApplicationInfo getApplicationInfoByProcessName(String processNames)
        {
            if(applicationInfoList == null || applicationInfoList.size() < 1)
                return null;
    
            for(ApplicationInfo applicationInfo : applicationInfoList)
            {
                if(applicationInfo.processName.equals(processNames)
                        && (applicationInfo.flags & ApplicationInfo.FLAG_SYSTEM) <= 0)
                    //只显示第三方的应用进程,不显示系统应用
                    //要显示所有应用进程,删去(applicationInfo.flags & ApplicationInfo.FLAG_SYSTEM) <= 0 即可
                    return applicationInfo;
            }
            return null;
        }
    
        private class MyOnItemClickListener implements AdapterView.OnItemClickListener
        {
            @Override
            public void onItemClick(AdapterView<?> parent, View view, int position, long id)
            {
                TextView tv_appName = (TextView) view.findViewById(R.id.tv_app_name);
                TextView tv_processName = (TextView) view.findViewById(R.id.tv_app_process_name);
    
                String appName = tv_appName.getText().toString();
                String processName = tv_processName.getText().toString();
    
                Toast.makeText(MainActivity.this, "应用: " + appName + "\n进程: " + processName,
                        Toast.LENGTH_SHORT).show();
            }
        }
    
        private class ItemButtonClick implements ProcessListAdapter.processListButtonClick
        {
            String pName = null;
    
            @Override
            public void onButtonClick(String processName) {
                pName = processName;
    
                AlertDialog.Builder builder = new AlertDialog.Builder(MainActivity.this);
                builder.setTitle("关闭进程")
                        .setMessage("确定要关闭 " + processName+" 进程吗?")
                        .setPositiveButton("确定", new DialogInterface.OnClickListener(){
                            public void onClick(DialogInterface dialog, int which)
                            {
                                if(pName != null)
                                {
                                    ActivityManager activityManager
                                            = (ActivityManager)MainActivity.this.
                                            getSystemService(ACTIVITY_SERVICE);
    
                                    activityManager.killBackgroundProcesses(pName);
                                    getProcessList();
                                }
                            }
                        })
                        .setNegativeButton("取消", new DialogInterface.OnClickListener(){
                            public void onClick(DialogInterface dialog, int which)
                            {
                                dialog.dismiss();
                            }
                        });
    
                builder.show();
            }
        }
    
    
        private Handler mHandler = new Handler()
        {
            @Override
            public void handleMessage(Message msg)
            {
                if(msg.what == 0x1)
                {
                    startClearAnim();
                }
                else if(msg.what == 0x2)
                {
                    stopClearAnim();
                    getProcessList();
                }
                super.handleMessage(msg);
            }
        };
    
    
        /**
         * 一键清理
         */
        private void clearAllBackgroundProcess()
        {
            mHandler.sendEmptyMessage(0x1);
    
            ActivityManager activityManager
                    = (ActivityManager)MainActivity.this.getSystemService(ACTIVITY_SERVICE);
    
            if(processNamelist != null && processNamelist.size() > 0)
            {
                for(String processName : processNamelist)
                {
                    activityManager.killBackgroundProcesses(processName);
                }
            }
            mHandler.sendEmptyMessageDelayed(0x2, 2000);
        }
    
        private void startClearAnim()
        {
            progressDialog = new ProgressDialog(MainActivity.this);
            progressDialog.setMessage("努力清理中...");
            progressDialog.show();
        }
    
        private void stopClearAnim()
        {
            progressDialog.dismiss();
        }
    
    
    }

    因为是探讨功能, 一键清理并没有加入复杂的动画. 如果要加入, 可以考虑在视图中间隐藏一个ImageView, 然后用AnimatorSet存放两个属性动画去实现, 一个是控制ImageView从透明到完全显示, 同时大小也是从0.0f 到1.0f . 第二个是控制无限的旋转. 当然, 用Animation也能实现, 一样的哈. 最后当清理完成, 就再次隐藏ImageView, 设为gone. 至于那些将快捷方式放到手机桌面, 然后点击快捷方式组件就有个动画出来, 同时清理后台的, 可以考虑做一个Activity, theme为一个dialog, 然后播放动画同时清理后台. 也能达到类似的效果.


    相信很多人都明白, 其实Android系统有自己的运行机制, 每个应用都有自己的进程, 每个进程对应有一个虚拟机, 这样设计为的是当自己这个进程挂掉也不会影响系统的运行和其他进程. 而当运行一些比较占内存的应用时, 系统也会自动将优先级低, 视为"无用,过时"的后台进程关闭, 从而挤出内存. 当然这不是万能的, 因为系统也并不总是能这么及时的处理, 以至于我们在使用比如游戏这样的应用时, 低内存的手机还是会由于内存不足的原因感觉有些卡顿. 所以显得手动请后台有一定的合理性.



    展开全文
  • C++/MFC多功能任务管理器项目

    千次阅读 2018-11-17 13:30:28
    扫描清理VS工程垃圾 获取文件信息,创建时间,修改时间,文件大小 遍历进程 遍历线程 遍历模块 遍历堆 结束进程,挂起线程,恢复线程,结束线程 获取CPU,内存信息 源码分享:https://github.com/Mr-Hock/MyTask ...
  • 一款很好用的窗口操作工具,融合了Spy++的功能,可以拖动找窗口,然后对窗口进行置顶、取消置顶、隐藏、显示等功能,还具备进程清理和禁止启动的功能(有时候调试程序会看到任务管理器出现一堆adb.exe,可任务管理器...
  • 一个简单的Android进程管理器(初稿) 实现一个Android系统下的进程管理APP,主要功能有:1)实现进程的查看,包括进程总数,进程名,pid,uid,以及进程占有的内存,优先级等 2)结束某个进程 3)一键清理...
  • 最近改bug的时候看到我们的软件在本地如果不点击退出登陆,直接用任务管理器杀死的话,在服务器端依旧保持着在线状态,直到Token过期(我们的Token四个小时才过期。。。我也不懂为什么要这么设计)。但是既然存在...
  •  意天Windows进程管理助手拥有非常强大的删除进程功能,能够删除任务管理器不能杀死的进程。  其删除进程 功能比很多同类软件要强大。同时意天Windows进程管理助手还能查看系统当前所打开的所有网络端口,通过该...
  • Software Reporter Tool是一个Chrome清理工具,用于清理...任务管理器,在进程运行时右键打开所在文件夹, 或自己手动在谷歌浏览器文件夹中找到,C:\Users\321\AppData\Local\Google\Chrome\User Data\SwReporter\83.
  • 清理IE缓存

    2017-11-14 17:40:48
    首先关闭浏览器,在任务管理器结束“iexplore.exe”进程。 1.重新打开浏览器,在“工具”菜单下打开“开发人员工具”,清理缓存即可。 2.依次打开“控制面板”、“Internet选项”、“常规”、“删除”即可。...
  • 记一次Windows Server2008木马清理过程

    千次阅读 2019-06-19 17:56:26
    oVirt虚拟化平台上跑的几台Server08的服务器最近总显示CPU爆满,任务管理器中看到有好多powershell.exe的进程,可是跑的服务中跟比没有需要调用powershell的,肯定有问题.用火绒剑查了一下网络: 尼玛这几个IP是日本\...
  • 如果在adb shell当中kill掉进程模拟应用被意外杀死的情况(或者用360手机卫士进行清理操作),如果服务的onStartCommand返回START_STICKY,在进程管理器中会发现过一小会后被杀死的进程的确又会出现在任务管理器中,...
  • 鼠标右击任务栏,打开任务管理器,结束java进程。 键盘按Win+R组合键,调出运行窗口,在窗口中输入%userprofile%,删除Teamcenter目录和FCCCache目录。 键盘按Win+R组合键,调出运行窗口,在窗口中输入%...
  • 近期电脑svchost进程占用内存超大,有时候会...任务管理器中打开资源管理器,先在内存页面找内存最高的,勾选后进入cpu页面,然后打开服务项,右击停止服务。没意外的话,应该是windows update更新服务。这个服务...
  • windows系统进程漫谈

    千次阅读 2007-11-20 23:17:00
    刚刚装完系统时,打开任务管理器你会发现进程数并不多(我的干净的无任何驱动windows 2000在18个左右).可过一段时间你会发现进程数莫名增加,下决心清理一下,结果机器挂了,看来只是胆子大是不行的.正所谓知己知彼...
  • 解决方法: 1、断开网络连接 2、打开“任务管理器”,有个SVOHOST.EXE进程,把它结束掉。到C:WINDOWSsystem32里找到SVOHOST.EXE把它删除。 3、执行“开始”-“运行”-输入“regedit”打开注册表 4、找到HKEY_...
  • 冲击波病毒的清理

    2017-11-12 21:49:00
    开始=》运行=》taskmgr,启动任务管理器。在其中查找msblast.exe进程,找到后在进程上单击右键,选择“结束进程”,点击“是”。2.检查系统的%systemroot%system32目录下(win2k一般是c:winntsystem32)是否存在...
  • J-Task代替

    2011-11-06 14:24:54
    这是一个很好的任务管理器,支持的功能很全,进程管理,服务管理,端口监视,文件管理,文件监视,垃圾清理
  • win7如何清理图标缓存

    千次阅读 2011-11-21 21:51:35
    1. 打开任务管理器,结束Explorer.exe进程。 2.选择"文件->新建任务(运行...)",输入cmd并确定。 3.依次运行命令: cd /d%userprofile%\AppData\Local del IconCache.db /a exit 4.在任务管理器中,选择...
  • 清理Java缓存步骤:

    万次阅读 2017-11-14 17:42:01
    首先关闭Java程序,在任务管理器中结束“java.exe”、“javaw.exe”等j开头的Java进程。 方法1.依次打开或操作“控制面板”、“Java”、“常规/设置”、“拷贝临时文件路径”、“删除临时文件路径下缓存文件”、...
  • 电脑清理,病毒查杀

    2017-03-25 08:04:34
    任务管理器中你是找不出哪些可以关的。你可以: 1、开始-运行(输入msconfig)-回车-引导---高级选项---勾选"处理器个数",选择最大核心数--勾选"最大内存" -- 确定。回到系统配置窗口-启动,保留杀毒软件和...
  • 清理windows的弹窗的办法

    千次阅读 2019-03-13 17:19:11
    使用过windows系统的朋友肯定都遇到过自己的电脑有时莫名其妙的弹出一些窗口出来,一般都是一些什么热点新闻。...下次大家看到这种弹窗后,打开任务管理器,找到对应的进程或者线程: 如果在应用程...
  • 打开任务管理器,结束Explorer.exe进程。 单击“文件&gt;新建任务”输入Cmd.exe,确定,打开命令提示符,然后输入: cd /d %userprofile%\AppData\Local attrib –h IconCache.db del IconCache.db start ...

空空如也

空空如也

1 2 3 4 5 ... 10
收藏数 192
精华内容 76
关键字:

任务管理器进程清理