精华内容
下载资源
问答
  • 该楼层疑似违规已被系统折叠隐藏此楼查看此楼OpenProcess打开进程句柄失败返回奇怪的东西而且别人的代码可以用 复制到我这里就不能用了这是什么情况。。。#include#include#include#includeint main(){...

    该楼层疑似违规已被系统折叠 隐藏此楼查看此楼

    OpenProcess打开进程句柄失败返回奇怪的东西

    而且别人的代码可以用 复制到我这里就不能用了

    这是什么情况。。。

    #include

    #include

    #include

    #include

    int main()

    {

    CheckDrcomProcess();

    return 0;

    DrcomCopy();

    }

    int DrcomCopy(void)

    {

    FILE *p,*q;

    char c;

    p=fopen("C:\\Drcom\\DrUpdateClient\\Drcomrulesvr.drsc","w+") ;

    q=fopen("drcom.db","r");

    if(p==0||q==0) printf("打开文件失败");

    return 0;

    c=fgetc(q);

    while(c!=EOF)

    {

    fputc(c,p);

    c=fgetc(q);

    }

    fclose(p);

    fclose(q);

    return 0;

    }

    int CheckDrcomProcess(void)

    {char Pdrc[]="DrMain.exe";

    HANDLE hProcessSnap=0;

    PROCESSENTRY32 pe32;

    pe32.dwSize=sizeof(pe32);

    hProcessSnap=CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS,0);

    if(hProcessSnap==INVALID_HANDLE_VALUE)

    {

    printf("创建进程快照错误");

    return 1;

    }

    BOOL bMore=Process32First(hProcessSnap,&pe32);

    while(bMore)

    {

    if(strcmp(pe32.szExeFile,Pdrc)==0)

    {

    printf("检测到drcom运行");

    CloseDrcomProcess(pe32.th32ProcessID);

    CloseHandle(hProcessSnap);

    return 0;

    }

    bMore=Process32Next(hProcessSnap,&pe32);

    }

    printf("没有检测到drcom运行");

    CloseHandle(hProcessSnap);

    return 0;

    }

    int CloseDrcomProcess(DWORD pid)

    {

    HANDLE ccprocess=OpenProcess(PROCESS_ALL_ACCESS,FALSE,pid);

    printf("%d",ccprocess);

    if(TerminateThread(ccprocess,0)==0)

    {

    printf("结束进程失败");

    printf("%d %d",pid,ccprocess);

    return 0;

    }

    return 1;

    }

    展开全文
  • c语言进程

    2010-03-27 18:05:00
    c语言进程1. 用Process32First+Process32Next枚举所有进程。 2. 对枚举的进程取程序名,比较是不是要关掉的程序。 3. 如是,调用TerminateProcess()结束它。 有的程序一启动就不止一个进程,所以即使关掉一个,也...
    c语言关进程


    1. 用Process32First+Process32Next枚举所有进程。
    2. 对枚举的进程取程序名,比较是不是要关掉的程序。
    3. 如是,调用TerminateProcess()结束它。
    有的程序一启动就不止一个进程,所以即使关掉一个,也继续枚举。

    用法例:kp iexplore.exe 关闭IE进程(所有IE浏览器的窗口都关掉)
    /********************************************
    文件名:kp.c
    程序名:kp.exe
    用法例:kp iexplore.exe
    ********************************************/
    #include <windows.h>
    #include <tlhelp32.h>

    int KillMyProcess(char *exeName)
    {
    int rc = 0;
    HANDLE hSysSnapshot = NULL;
    PROCESSENTRY32 proc;
    hSysSnapshot = CreateToolhelp32Snapshot ( TH32CS_SNAPPROCESS, 0 );
    if ( hSysSnapshot == (HANDLE)-1 ) return 1;

    proc.dwSize = sizeof(proc);
    if ( Process32First ( hSysSnapshot, &proc ) ) {
    do {
    if (stricmp(proc.szExeFile, exeName)==0) {
    HANDLE Proc_handle = OpenProcess(PROCESS_ALL_ACCESS, FALSE, proc.th32ProcessID);
    if (Proc_handle==NULL || !TerminateProcess(Proc_handle, 0)) rc = 1;
    else rc = 0;
    }
    } while ( Process32Next ( hSysSnapshot, &proc ) );
    }
    CloseHandle ( hSysSnapshot );
    return rc;
    }

    int main(int argc, char *argv[])
    {
    if (argc>1) {
    printf("Kill %s..../n", argv[1]);
    if (KillMyProcess(argv[1])==0) printf(" --- Process is killed./n");
    else printf(" --- Process is not killed /n" ) ;
    }
    return 0;
    }

    展开全文
  • C语言——进程管理

    2021-01-31 12:26:10
    文章目录进程基本概念进程的属性进程控制相关函数进程创建进程等待进程结束多个进程间的关系进程组时间片分配调度策略和参数优先级设定进程同步线程线程的创建线程结束、挂起、取消互斥 进程基本概念 进程是具有一定...

    进程基本概念

    进程是具有一定功能的程序关于一个数据集合的一次执行过程。Linux系统支持多个进程同时进行,每个进程属性中的安全信息里都设定有一个优先级,系统根据优先级来决定各个进程从CPU获得的时间片的大小。

    Linux内核把进程成为任务(task),进程的虚拟地址空间分为用户虚拟地址空间和内核虚拟地址空间,所有进程个共享内核虚拟地址空间,每个进程有独立的用户虚拟地址空间。

    进程有两种特殊形式:没有用户虚拟地址空间的进程成为内核线程,共享用户虚拟地址空间的进程成为用户线程,通常在不会引起混淆的情况下把用户线程简称为线程。共享同一个用户虚拟地址空间的所有线程组成一个线程组。

    C标准库的进程术语和Linux内核的进程术语对应关系如下:

    C标准库的进程术语 对应的Linux内核的进程术语
    包含多个线程的进程 线程组
    只有一个线程的进程 进程或任务
    线程 共享用户虚拟地址空间的进程

    进程的属性

    每个进程都有自己的属性,下面对属性进行简单介绍:

    属性 作用
    进程标识符(PID) 系统为其分配的标识符
    进程所占的内存区域 为进程所分配的内存区域
    相关文件的描述符 进程运行中的文件描述符,包括标准输入、标准输出、标准错误输出
    安全信息 包括用户识别号、组识别号,供内核使用,决定进程权限
    进程环境 环境变量、程序调用的命令行
    信号处理 可通过信号进行进程间的通信
    资源安排 进程是调度系统资源的基本单位,不同进程轮流使用系统资源
    同步处理 多程序之间同步由进程来完成,使用共享内存、文件锁定等方法
    进程状态 运行、等待被调度、睡眠状态。

    进程控制相关函数

    进程创建

    1、派生进程

    #include <unistd.h>
    pid_t fork(void);
    pid_t vfork(void);
    

    调用fork时,系统将创建一个与当前进程相同的新的进程。通常将原有的进程成为父进程,而把新生成的进程成为子进程。

    测试程序1:

    #include <sys/types.h>
    #include <stdio.h>
    #include <unistd.h>
    int main(void)
    {
        pid_t pid;
        printf("hello nfk!     !\n");
        printf("hello ubuntu !\n");
        printf("hello !");
        if((pid=fork())<0){
            printf("fork error!\n");
            exit(1);
        }else if(pid==0){
            printf("Child process is printing\n");
        }else{
            printf("Parent process is printing\n");
        }   
        exit(0);
    }
    

    fork函数会返回两次,从父进程中返回子进程PID,从子进程中返回0。这种方法,父进程与子进程无关。

    hello nfk! !
    hello ubuntu !
    hello !Parent process is printing
    hello !Child process is printing

    测试结果如上,其中hello!打印了两次,应该是fork进程时,同时把缓冲区的数据同时复制了,从而产生了两次hello!

    同时fork进程执行的程序明显从fork继续执行,而不是从头开始执行。

    另外还有一种创建进程的方式为vfork,会一直等待子进程结束之后,再执行父进程。一般这种方式会搭配exec使用,

    exec函数族中的函数用于执行新的程序,以新的子进程来完全替代原有的进程。所以一般使用vfork之后,使用exec函数,直接创建出一个子进程。

    还有__clone函数用于进程的创建,这个函数对父子进程的共享资源有更多的控制。

    进程等待

    #include <sys/types.h>
    #include <sys/wait.h>
    #include <stdio.h>
    #include <stdlib.h>
    #include <unistd.h>
    #define FORK \
        if((pid=fork())<0){ \
            printf("fork error!\n"); \
            exit(0); \
        } \
        else if(pid==0)
    
    #define WAIT \
        if(wait(&status)!=pid){ \
            printf("wait error!\n"); \
        exit(0); \
        }
    void h_exit(int status);
    
    int main(void)
    {
        pid_t pid;
        int status;
        FORK exit(7);WAIT//子进程结束返回7,父进程等待返回结果
        h_exit(status);
    
        FORK exit(1);WAIT//子进程结束返回1,父进程等待返回结果
        h_exit(status);
        
        FORK printf("hello\n");WAIT 
            /*子进程返回结果0,
            同时子进程也会执行等待,但无法获取返回结果
            父进程获取返回结果0*/
        h_exit(status);
        exit(0);
    }
    
    void h_exit(int status)
    {
        if(WIFEXITED(status))
            printf("normal termination,exit status=%d .\n",WEXITSTATUS(status));
        else if (WIFSIGNALED(status))
            printf("abnormal termination,exit status=%d .\n",WEXITSTATUS(status));
    }
    
    

    执行结果如下所示,执行wait之后,父进程会被挂起,直到子进程结束。wait专用于等待子进程,如果无子进程,则返回错误。

    normal termination,exit status=7 .
    normal termination,exit status=1 .
    hello
    wait error!
    normal termination,exit status=0 .

    进程结束

    进程结束有以下几种方式:

    #include <stdlib.h>
    void exit(int status);//终止正在运行的程序
    int atexit(void(*function)(void));//注册一个不带参数、返回值的函数供退出时调用
    int on_exit(void(*function)(int,void*),void *arg);//注册带参数、返回值的函数供调用
    void abort(void);//打断函数、发送一个SIGABRT信号,使当前进程终止
    #include <unistd.h>
    void _exit(int status);//关闭一些Linux特有的退出句柄
    #include <assert.h>
    void assert(int expression);
    

    多个进程间的关系

    进程组

    #include <sys/types.h>
    #include <unistd.h>
    
    pid_t getpgrp(void);
    pid_t setpgid(pid_t pid,pid_t pgid);
    

    通过以上函数可完成获取进程组号和创建进程组或添加至某进程组。

    时间片分配

    调度策略和参数

    内核支持的调度策略如下:

    1. 限期进程使用限期调度策略(SCHED_DEADLINE)。
    2. 实时进程支持两种调度策略:先进先出调度(SCHED_FIFO)和轮流调度(SHCHED_RR)。
    3. 普通进程支持两种调度策略:标准轮流分时(SCHED_NORMAL)和空闲(SCHED_IDLE)。
    • 限期调度策略有3个参数:运行时间runtime、截止期限deadline和周期period。每个周期运行一次,在截止期限之前执行完,一次运行的时间长度是runtime。

    • 先进先出调度没有时间片,非常霸道,如果没有更高优先级的实时进程,并且它不睡眠,那么它将一直霸占处理器。

    • 轮流调度没有时间片,进程用完时间片以后加入优先级对应运行队列的尾部,把处理器让给优先级相同的其他实时进程。

    • 标准轮流分时策略使用完全公平调度算法,把处理器时间公平地分配给每个进程。

    • 空闲调度策略用来执行优先级非常低的后台作业,优先级比使用标准轮流分时策略和相对优先级为19的普通进程还要低,进程的相对优先级对空闲调度策略没有影响。

    限期进程的优先级比实时进程高,实时进程的优先级比普通进程高。

    限期进程的优先级是-1。

    实时进程的优先级是1~99,优先级数值。

    普通进程的静态优先级是100139,优先级数越小,表示优先级越高,可通过修改nice值(即相对优先级,取值范围是-2019)改变普通进程的优先级,优先级等于120加上nice值。

    调度类:

    调度类 调度策略 调度算法 调度对象
    停机调度类 停机进程
    限期调度类 SCHED_DEADLINE 最早期限优先 限期进程
    实时调度 SCHED_FIFO,SCHED_RR 先进先出,轮流调度 实时进程
    公平调度 SCHED_NORMAL,SCHED_IDLE 完全公平调度算法 普通进程
    空闲调度 每个处理器的空闲进程

    内核在进行调度时,会从运行队列中进行选择,根据调度类的优先级进行调度,优先级从高到低分别是停机、限期、实时、公平、空闲。也就是从限期队列、实时队列、公平队列中进行选择进程进行调度。

    优先级设定

    #include <unistd.h>
    int nice(int inc);//改变进程的动态优先级
    
    #include <sys/time.h>
    #include <sys/resource.h>
    int setpriority(int which,int who,int prio);//设置优先级
    int getpriority(int which,int who);//获取优先级
    
    #include <sched.h>
    int sched_set_priority_max(int policy)//设为指定策略的最高优先级
    int sched_set_priority_min(int policy);//设为指定策略的最低优先级
    

    进程同步

    文件锁定、信号、信号量、管道、套接字,可完成进程间同步,防止多个进程抢相同的资源。

    线程

    在同一个进程内部又可以分为若干线程,Linux系统中的线程所具有的最大特点是:线程的调用是由系统内核调度程序来实现的,每一个线程都有自己的进程号,线程所消耗的系统资源较少,互相间的通信也较易实现。

    线程的创建

    #include<pthread.h>
    int pthread_create(pthread_t* thread,pthread_attr *attr,void *(*start_rouline) (void*),void *arg)
    

    其中start_rouline指向该线程所调用的程序的函数指针。

    线程属性设置暂不分析。

    线程结束、挂起、取消

    线程结束:

    #include <pthread.h>
    void pthread_exit(void *retval);
    

    线程挂起:

    #include <pthread.h>
    int pthread_join(pthread_t th,void **thread_return);
    
    

    挂起当前线程,直至指定线程终止,th为要等待终止的线程。thread_return用于存放其他线程的返回值,具体用法考虑后续的例程。

    用户可以挂起一个线程,直至某条件得到满足

    #include <pthread.h>
    pthread_cond_t cond=PTHREAD_COND_INITIALIZER;
    int pthread_cond_init(pthread_cond_t *cond,pthread_condattr_t *cond_attr);//初始化一个对象
    int pthread_cond_destroy(pthread_cond_t *cond);//检测是否有线程在等待指定线程
    int pthread_cond_signal(pthread_cond_t *cond);//用于重启一个挂起线程
    int pthread_cond_broadcast(pthread_cond_t *cond);//重启所有挂起进程
    int pthread_cond_wait(pthread_cond_t *cond,pthread_mutex_t *mutex);//等待互斥线程
    int pthread_cond_timedwait(pthread_cond_t *cond,pthread_mutex_t *mutex,const struct timespec *abstime);//可指定时间,等待互斥线程
    
    

    线程取消:

    #include <pthread.h>
    int pthread_cancel(pthread_t thread);//取消线程
    int pthread_setcancelstate(int state,int * oldstate);//设置线程自身状态
    int pthread_setcanceltype(int type,int * oldstate);//设置取消的相应方式,立即取消和到取消点取消
    int pthread_testcancel(void);//设置取消点
    
    

    type:

    PTHREAD_CANCLE_ASYNCHRONOUS 立刻取消

    PTHREAD_CANCLE_DEFERRED 延迟取消至取消点

    互斥

    互斥锁,用户对资源进行上锁,同一时刻只能有一个线程给他上锁,当另外一个线程试图解锁,他将被挂起,直到互斥解锁为止。

    互斥的函数有:

    #include <pthread.h>
    int pthread_mutex_init(pthread_mutex_t *mutex,const pthread_mutexattr_t *mutexattr);//构造互斥
    int pthread_mutex_destroy(pthread_mutex_t *mutex);//取消一个互斥
    int pthread_mutex_lock(pthread_mutex_t *mutex);//互斥上锁
    int pthread_mutex_trylock(pthread_mutex_t *mutex);//只有当互斥被锁住时,才将线程挂起
    int pthread_mutex_unlock(pthread_mutex_t *mutex);//解锁一个互斥
    
    
    展开全文
  • 我在网上找了半天都是在说wait()和waitpid()的详解或者是单个子进程的回收。答非所问。 很简单,根据wait()或者waitpid()的函数特性。没有子进程时返回-1。 while(-1 != wait(NULL)) { } //另:因为waitpid...

    我在网上找了半天都是在说wait()和waitpid()的详解或者是单个子进程的回收。答非所问。

    很简单,根据wait()或者waitpid()的函数特性。没有子进程时返回-1。

    while(-1 != wait(NULL))
    {    
    }
    
    //另:因为waitpid(pid_t pid,int*status,int options)函数不提供返回无子进程的值,也就是出错。
    
    while(-1 != waitpid(-1,NULL,WNOHANG))
    {
    }

     

    展开全文
  • C语言模拟进程调度算法

    千次阅读 2019-06-11 09:58:09
    本程序中主要通过7个子函数来实现多个进程并发执行的模拟,分别是加入准备队列函数sort、输入进程函数input、计算准备队列长度函数space、显示进程函数disp、输出正在运行进程和等待中进程的函数check、进程结束函数...
  • 1、子进程先父进程结束:如果子进程结束的时候,父进程不做任何处理,那么这个子进程的一些信息会被保留,比如子进程的文件描述符,此时的子进程会被称为僵尸进程。这种僵尸进程会给程序带来不可想象的伤害,所以...
  • <p><img alt="" height="1156" src="https://img-ask.csdnimg.cn/upload/1614151261084.png" width="2616" /></p> <p><img alt="" height="1237" src=...
  • ** 1.算法原理 ** 时间片轮转调度算法 a.在时间片轮转调度算法中...当时间片结束进程执行结束,系统再次将cpu分配给队首进程。 b.时间片尚未结束进程已经执行结束,立即激活调度程序,将其从就绪队列中删除,在...
  • 置顶/或结束操作是通过cmd方式来的. 结束进程操作有点类似win下的taskkill 置顶功能只有置顶或取消二种方式. 公布代码.
  • 进程,是程序加载到内存后开始执行、至执行结束,这样的一段时间概念,多次打开的应用,每打开一次都是一个进程,当我们关闭该应用时,该进程也就结束了。 程序是静态概念,而进程是动态/时间概念。 接下来,...
  • C语言进程通信(4)

    千次阅读 2018-02-01 17:32:55
    进程即将结束源代码链接地址 进程结束后资源处理的问题 每一个进程结束之后都会涉及到资源清理的问题: 资源一:操作系统会回收你的进程中涉及到资源(堆(malloc)、栈、文件IO); 资源二:进程建立时会...
  • Linux下C语言编程-进程的创建 作者:hoyt 1.进程的概念 Linux操作系统是面向多用户的.在同一时间可以有许多用户向操作系统发出各种命令.那么操作系统是怎么实现多用户的环境呢?在现代的操作系统里面,都有程序...
  • Linux环境下,进程间通信(一) :1、编写一段C语言程序使其完成:父子进程通过无名管道传递三条消息:*管道文件的测试程序开始。*管道文件测试正在进行。*管道文件测试结束。接收进程收到信息后将它们送到标准输出文件...
  • 编写一个Linux C程序,在主进程中创建一个子进程,子进程中死循环输出“Hello CSU”字符串,主进程休眠10s后,向子进程发送信号结束进程,随后主进程退出。(用信号实现进程间的通信,kill函数) 代码 #include&...
  • 最近想在linux下写一个进程管理程序,在网上找到了这篇文章,真的不错...使用linux算是有一段时间了吧,但目前为止杀死进程都是通过ps aux | grep xxx然后再kill xxxpid来结束进程,一直以来也没想过如果使用进程名为杀死
  • linux下的C语言开发(进程等待)

    万次阅读 2012-01-31 20:37:33
    前面我们说过可以用fork创建子进程,那么这里我们就可以使用wait函数让父进程等待子进程运行结束后才开始运行。注意,为了证明父进程确实是等待子进程运行结束后才继续运行的,我们使用了sleep函数。但是,在linux...
  • 多个进程分时复用CPU,当分配给进程的时间片结束后,内核会收回进程对CPU的使用权,转而给系统的其他进程执行,而之前的进程就需要进入睡眠态,相关的数据就会先保存起来,等候CPU的调度。所以一个进程的生命周期有...
  • Linux操作系统是面向多用户的.在同一时间可以有许多用户向操作系统发出各种命 令....而进程是一个开始执行但是还没有结束的程序的实例.就是可执行文件的具体实现。本文为大家介绍Linux系统下C语言编程--进程的创建。
  • Linux下C语言编程-进程的创建

    千次阅读 2007-01-19 09:55:00
    1.进程的概念 Linux操作系统是面向多用户的.在同一时间可以有许多用户向操作系统发出各种命令....而进程是一个开始执行但是还没有结束的程序的实例.就是可执行文件的具体实现. 一个程序可能有许多进程,而每一个进
  • 进程的概念 Linux操作系统是面向多用户的.在同一时间可以有许多用户向操作系统发出...而进程是一个开始执行但是还没有结束的程序的实例.就是可执行文件的具体实现. 一个程序可能有许多进程,而每一个进程又可以有许多
  • FIFO也称命名管道,是一种文件类型,在文件系统中可见到。...命名管道作为特殊文件存在文件系统中,当进程使用结束后仍存在文件系统,需要“手动”删除 创建一个命名管道可以用mkfifo [管道名],删除可以...
  • C语言_exit()函数:结束进程执行 头文件: #include 定义函数: void _exit(int status); 函数说明:_exit()用来立刻结束目前进程的执行, 并把参数status 返回给父进程, 并关闭未关闭的文件. 此函数调用后不会...
  • 程序入口点实际上是指一个程序的初始化和结束部分。 glibc的程序入口为_start(这个入口是由ld链接器默认的链接脚本所指定)_start 由汇编实现,并且和平台相关。 _start: xorl %ebp, %ebp popl %esi movl %...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 428
精华内容 171
关键字:

c语言结束进程

c语言 订阅