精华内容
下载资源
问答
  • 如何创建守护进程
    2021-09-06 17:52:27

    如何创建守护进程

    1. 使用 nohup 命令创建守护进程,使得程序挂在后台,但是程序执行完成后就会退出,程序的输出会存入 log 文件。

    2. 从 fork 开始按按步骤创建

      1. 在父进程中执行 fork 函数,并且父进程退出,子进程将被 init 进程托管;

      2. 在子进程中使用 setsid 函数创建新的会话,目的是让子进程脱离终端的控制,并且摆脱父进程的影响;

        进程是属于进程组的,进程组的组号 gid 就是进程组组长的 pid,登录会话可以包括多个进程组,这些进程组共享一个控制终端,如果想要创建守护进程就要让这个进程脱离出来,自己单独成一个进程组,setsid 就能够将进程完全独立出来,脱离其他进程的控制。

      3. 在子进程中调用 chdir 函数让当前的根目录成为子进程的工作目录

      4. 使用 umask 函数,把文件创建掩码设为 0,umask(0)

        文件创建掩码是指屏蔽掉文件创建时的对应位。由于使用fork函数新建的子进程继承了父进程的文件创建掩码,这就给该子进程使用文件带来了诸多的麻烦。因此,把文件创建掩码设置为0,可以大大增强该守护进程的灵活性。

      5. 关闭文件描述符

        因为用fork新建的子进程会从父进程那里继承一些已经打开了的文件。这些被打开的文件可能永远不会被守护进程读或写,但它们一样消耗系统资源,可能导致所在的文件系统无法卸载。

    3. daemon() 函数直接创建守护进程

      #include <unistd.h>
      int daemon(int nochdir, int noclose);
      
      1. 第一个参数 nochdir 若为 0,将当前工作目录更改为根目录,否则为当前工作目录
      2. 第二个参数 noclose 若为 0,将标准输入、标准输出、标准错误都重定向到 /dev/null; 否则不会修改

      deamon() 调用了 fork(),如果fork成功,那么父进程就调用 _exit() 退出,因此只能通过子进程看到进一步的错误。如果成功函数返回 0,否则返回 -1 并设置 errno。

    更多相关内容
  • Linux C创建守护进程步骤 前言 我觉得在学习如何学习创建守护进程前首先应知道何为守护进程,那么什么是守护进程呢? 刘忆智等编著的《Linux从入门到精通》(第2版)一书中是这样定义的:守护进程(daemon)是一类在后台...

    Linux C 创建守护进程步骤

    前言

    我觉得在学习如何学习创建守护进程前首先应知道何为守护进程,那么什么是守护进程呢?

    刘忆智等编著的《Linux从入门到精通》(第2版)一书中是这样定义的:守护进程(daemon)是一类在后台运行的特殊进程,用于执行特定的系统任务。很多守护进程在系统引导的时候启动,并且一直运行直到系统关闭。另一些只在需要的时候才启动,完成任务后就自动结束。而我理解的是:运行于后台,且不会受终端控制的特殊进程。

    下面我们先来看下一个创建守护进程的过程。

    1. 创建孤儿进程(创建子进程,终止父进程):fork(),exit();
    2. 创建一个新的会话,成为会话组长:setsid();
    3. 更改程序运行目录:chdir();
    4. 修改文件掩码:umask();
    5. 关闭文件描述符:getdtablesize(),close();

    下面我们来看下完整的代码:

    #include <stdio.h>
    #include <string.h>
    #include <stdlib.h>
    #include <strings.h>
    #include <sys/stat.h>
    #include <unistd.h>
    
    int main()
    {
    	//成为孤儿
    	pid_t pid = fork();
    	if(pid == -1)
    	{
    		perror("fork");
    		exit(-1);
    	}
    	else if(pid > 0)
    	{
    		exit(0);
    	}
    	//创建新会话
    	if(setsid()== (pid_t)-1)
    	{
    		perror("setsid");
    		exit(-1);
    	}
    	//更改运行目录
    	if(-1 == chdir("/tmp"))
    	{
    		perror("chdir");
    		exit(-1);
    	}
    	//修改文件掩码
    	umask(0);
    	//关闭文件描述符
    	int i;
    	for(i = 0; i < getdtablesize(); i++)
    	{
    		close(i);
    	}
    	while(1)
    	{
    		//任务处理
    		printf{"Hello World !"};
    	}
    	exit(0);
    }
    

    下面详细介绍一下几个函数:

    创建进程fork()

    函数功能:创建一个子进程(相对当前进程)
    函数头文件

    #include <sys/types.h>
    #include <unistd.h>
    

    函数原型:

    pid_t fork(void);
    

    函数返回值:
    成功:主进程返回子进程pid号,子进程返回0
    失败:返回-1和错误码
    例如:

    pid_t pid = fork();
    switch(pid)
    {
    	case -1:
    	{
    		perror("Fork");
    		exit(0)}
    	case 0:
    	{
    		while(1)
    		{
    			//子进程
    		}
    		break;
    	}
    	default{
    		while(1)
    		{
    			//主进程
    		}
    		break;
    	}
    }
    

    新建一个会话setsid()

    函数功能:创建会话并设置进程组ID
    函数头文件

     #include <unistd.h>
    

    函数原型

    pid_t setsid(void);
    

    函数返回值:
    成功:返回会话组id
    失败:返回-1和错误码

    更改目录chdir()、fchdir()

    函数功能:更改工作目录
    函数头文件

     #include <unistd.h>
    

    函数原型

    int chdir(const char *path);
    int fchdir(int fd);
    

    函数返回值
    成功:返回0
    失败:返回-1和错误码
    参数说明
    path:文件路径
    fd:文件描述符

    修改文件掩码umask()

    函数功能:设置并获取文件模式创建掩码
    函数头文件

    #include <sys/stat.h>
    

    函数原型

    mode_t umask(mode_t cmask);
    

    函数返回值
    此函数总是返回为成功,使用时可不做错误判断
    参数说明
    cmask:权限值

    获取文件描述符表大小getdtablesize()

    函数功能:获取文件描述符表大小
    函数头文件

    #include <sys/stat.h>
    

    函数原型

    int getdtablesize(void);
    

    函数返回值
    当前对每个进程打开的文件数量

    展开全文
  • 本篇文章主要介绍了linux下如何创建守护进程步骤,小编觉得挺不错的,现在分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • 创建守护进程步骤

    万次阅读 多人点赞 2018-08-03 21:30:55
    什么是守护进程? 答:守护进程是后台运行的、系统启动是就存在的、不予任何终端关联的,用于处理一些系统级别任务的特殊进程。...根据上述的特性,我们便可以创建一个简单的守护进程,这里以 Linux 系统下从终...

    什么是守护进程?

    答:守护进程是后台运行的、系统启动是就存在的、不予任何终端关联的,用于处理一些系统级别任务的特殊进程。

    实现思路:

    实现一个守护进程,其实就是将普通进程按照上述特性改造为守护进程的过程。
    需要注意的一点是,不同版本的 Unix 系统其实现机制不同,BSD 和 Linux 下的实现细节就不同。

    根据上述的特性,我们便可以创建一个简单的守护进程,这里以 Linux 系统下从终端 Shell 来启动为例。

    在此有必要说一下两个概念:会话和进程组。

    参考 linux内核之进程的基本概念(进程,进程组,会话关系) - 笨拙的菜鸟 - 博客园

    进程都有父进程,父进程也有父进程,这就形成了一个以init进程为根的家族树。除此以外,进程还有其他层次关系:进程、进程组和会话。进程组和会话在进程之间形成了两级的层次:进程组是一组相关进程的集合,会话是一组相关进程组的集合。

    这样说来,一个进程会有如下ID:

    ·PID:进程的唯一标识。对于多线程的进程而言,所有线程调用getpid函数会返回相同的值。

    ·PGID:进程组ID。每个进程都会有进程组ID,表示该进程所属的进程组。默认情况下新创建的进程会继承父进程的进程组ID。

    ·SID:会话ID。每个进程也都有会话ID。默认情况下,新创建的进程会继承父进程的会话ID。

    前面提到过,新进程默认继承父进程的进程组ID和会话ID,如果都是默认情况的话,那么追根溯源可知,所有的进程应该有共同的进程组ID和会话ID。但是调用ps axjf可以看到,实际情况并非如此,系统中存在很多不同的会话,每个会话下也有不同的进程组。

    为何会如此呢?

    就像家族企业一样,如果从创业之初,所有家族成员都墨守成规,循规蹈矩,默认情况下,就只会有一个公司、一个部门。但是也有些“叛逆”的子弟,愿意为家族公司开疆拓土,愿意成立新的部门。这些新的部门就是新创建的进程组。如果有子弟“离经叛道”,甚至不愿意呆在家族公司里,他别开天地,另创了一个公司,那这个新公司就是新创建的会话组。由此可见,系统必须要有改变和设置进程组ID和会话ID的函数接口,否则,系统中只会存在一个会话、一个进程组。

    进程组和会话是为了支持shell作业控制而引入的概念。

    当有新的用户登录Linux时,登录进程会为这个用户创建一个会话。用户的登录shell就是会话的首进程。会话的首进程ID会作为整个会话的ID。会话是一个或多个进程组的集合,囊括了登录用户的所有活动。在登录shell时,用户可能会使用管道,让多个进程互相配合完成一项工作,这一组进程属于同一个进程组。

    当用户通过SSH客户端工具(putty、xshell等)连入Linux时,与上述登录的情景是类似的。

    通常,会话开始于用户登录,终止于用户退出,期间的所有进程都属于这个会话。一个会话一般包含一个会话首进程、一个前台进程组和一个后台进程组,控制终端可有可无;此外,前台进程组只有一个,后台进程组可以有多个,这些进程组共享一个控制终端。

    • 前台进程组:
      该进程组中的进程可以向终端设备进行读、写操作(属于该组的进程可以从终端获得输入)。该进程组的 ID 等于控制终端进程组 ID,通常据此来判断前台进程组。

    • 后台进程组:
      会话中除了会话首进程和前台进程组以外的所有进程,都属于后台进程组。该进程组中的进程只能向终端设备进行写操作。

    下图为会话、进程组、进程和控制终端之间的关系(登录 shell 进程本身属于一个单独的进程组)。

     

    想了解更多关于会话 Sessions 内容,可以认真读一下 APUE 这本书。

    如果调用进程非组长进程,那么就能创建一个新会话:

    • 该进程变成新会话的首进程
    • 该进程成为一个新进程组的组长进程
    • 该进程没有控制终端,如果之前有,则会被中断(会话过程对控制终端的独占性)

    也就是说:组长进程不能成为新会话首进程,新会话首进程必定成为组长进程。

    1、fork()创建子进程,父进程exit()退出;

    这是创建守护进程的第一步。由于守护进程是脱离控制终端的,完成这一步后就会在Shell终端里造成程序已经运行完毕的假象。之后的所有工作都在子进程中完成,而用户在Shell终端里则可以执行其他命令,从而在形式上做到了与控制终端的脱离,在后台工作。

    由于父进程先于子进程退出,子进程就变为孤儿进程,并由 init 进程作为其父进程收养。

    2、在子进程调用setsid()创建新会话;

    在调用了 fork() 函数后,子进程全盘拷贝了父进程的会话期、进程组、控制终端等,虽然父进程退出了,但会话期、进程组、控制终端等并没有改变。这还不是真正意义上的独立开来,而 setsid() 函数能够使进程完全独立出来

     setsid()创建一个新会话,调用进程担任新会话的首进程,其作用有:

    • 使当前进程脱离原会话的控制
    • 使当前进程脱离原进程组的控制
    • 使当前进程脱离原控制终端的控制

    这样,当前进程才能实现真正意义上完全独立出来,摆脱其他进程的控制。

    3、再次 fork() 一个子进程,父进程exit退出;

    现在,进程已经成为无终端的会话组长,但它可以重新申请打开一个控制终端,可以通过 fork() 一个子进程,该子进程不是会话首进程,该进程将不能重新打开控制终端。退出父进程。

    也就是说通过再次创建子进程结束当前进程,使进程不再是会话首进程来禁止进程重新打开控制终端

    4、在子进程中调用chdir()让根目录“/”成为子进程的工作目录;

    这一步也是必要的步骤。使用fork创建的子进程继承了父进程的当前工作目录。由于在进程运行中,当前目录所在的文件系统(如“/mnt/usb”)是不能卸载的,这对以后的使用会造成诸多的麻烦(比如系统由于某种原因要进入单用户模式)。因此,通常的做法是让"/"作为守护进程的当前工作目录,这样就可以避免上述的问题,当然,如有特殊需要,也可以把当前工作目录换成其他的路径,如/tmp。改变工作目录的常见函数是chdir。(避免原父进程当前目录带来的一些麻烦)

    5、在子进程中调用umask()重设文件权限掩码为0;

    文件权限掩码是指屏蔽掉文件权限中的对应位。比如,有个文件权限掩码是050,它就屏蔽了文件组拥有者的可读与可执行权限(就是说可读可执行权限均变为7)。由于使用fork函数新建的子进程继承了父进程的文件权限掩码,这就给该子进程使用文件带来了诸多的麻烦。因此把文件权限掩码重设为0即清除掩码(权限为777),这样可以大大增强该守护进程的灵活性。通常的使用方法为umask(0)。(相当于把权限开发)

    6、在子进程中close()不需要的文件描述符;

    同文件权限码一样,用fork函数新建的子进程会从父进程那里继承一些已经打开了的文件。这些被打开的文件可能永远不会被守护进程读写,但它们一样消耗系统资源,而且可能导致所在的文件系统无法卸下。其实在上面的第二步之后,守护进程已经与所属的控制终端失去了联系。因此从终端输入的字符不可能达到守护进程,守护进程中用常规方法(如printf)输出的字符也不可能在终端上显示出来。所以,文件描述符为0、1和2 的3个文件(常说的输入、输出和报错)已经失去了存在的价值,也应被关闭。(关闭失去价值的输入、输出、报错等对应的文件描述符

    for (i=0; i < MAXFILE; i++)
        close(i); 

    7、守护进程退出处理

    当用户需要外部停止守护进程运行时,往往会使用 kill 命令停止该守护进程。所以,守护进程中需要编码来实现 kill 发出的signal信号处理,达到进程的正常退出。

    一张简单的图可以完美诠释之前几个步骤:

    至此为止,一个简单的守护进程就建立起来了。

    注意守护进程一般需要在 root 权限下运行。

    通过

    ps -ef | grep 'daemon'

    对比执行前后确实可以看到多了一个进程:

    并且产生了 daemon.log,里面是这样的时间标签

    1. Thu Dec 8 14:35:11 2016

    2. Thu Dec 8 14:36:11 2016

    3. Thu Dec 8 14:37:11 2016

    最后我们想退出守护进程,只需给守护进程发送 SIGQUIT 信号即可

    sudo kill -3 26454 

    再次使用 ps 会发现进程已经退出。

    程序如下:

    #include <unistd.h>
    #include <signal.h>
    #include <stdlib.h>
    #include <string.h>
    #include <fcntl.h>
    #include <sys/stat.h>
    #include <time.h>
    #include <stdio.h>
     
    static bool flag = true;
    void create_daemon();
    void handler(int);
     
    int main()
    {
    	time_t t;
    	int fd;
    	create_daemon();
    	struct sigaction act;
    	act.sa_handler = handler;
    	sigemptyset(&act.sa_mask);
    	act.sa_flags = 0;
    	if(sigaction(SIGQUIT, &act, NULL))
    	{
    		printf("sigaction error.\n");
    		exit(0);
    	}
    	while(flag)
    	{
    		fd = open("/home/mick/daemon.log", O_WRONLY | O_CREAT | O_APPEND, 0644);
    		if(fd == -1)
    		{
    			printf("open error\n");
    		}
    		t = time(0);
    		char *buf = asctime(localtime(&t));
    		write(fd, buf, strlen(buf));
    		close(fd);
    		sleep(60);
    	}
    	return 0;
    }
    void handler(int sig)
    {
    	printf("I got a signal %d\nI'm quitting.\n", sig);
    	flag = false;
    }
    void create_daemon()
    {
    	pid_t pid;
    	/*(1)-----创建一个进程来用作守护进程-----*/
    	pid = fork();
    	
    	if(pid == -1)
    	{
    		printf("fork error\n");
    		exit(1);
    	}
    	/*(1.1)-----------原父进程退出-------------*/
    	else if(pid)
    	{
    		exit(0);
    	}
     	/*(2)---setsid使子进程独立。摆脱会话控制、摆脱原进程组控制、摆脱终端控制----*/
    	if(-1 == setsid())
    	{
    		printf("setsid error\n");
    		exit(1);
    	}
      	/*(3)---通过再次创建子进程结束当前进程,使进程不再是会话首进程来禁止进程重新打开控制终端----*/
    	pid = fork();
    	if(pid == -1)
    	{
    		printf("fork error\n");
    		exit(1);
    	}
    	else if(pid)
    	{
    		exit(0);
    	}
      	/*(4)---子进程中调用chdir()让根目录成为子进程工作目录----*/
    	chdir("/");
    	int i;
    	/*(6)---关闭文件描述符(常说的输入,输出,报错3个文件)----*/
    	for(i = 0; i < 3; ++i)
    	{
    		close(i);
    	}
    	/*(5)---重设文件掩码为0(将权限全部开放)----*/
    	umask(0);
    	return;
    }
    

    以下为其他的两种实现,大同小异:

     C++实现 :

    #include<stdio.h>
    #include<fcntl.h>
    #include<sys/stat.h>
    #include<string.h>
    #include<sys/types.h>
    #include<unistd.h>
    #include<stdlib.h>
    
    int main(){
        pid_t pid;
        char buf[]="this is a dameon\n";
        pid=fork();//创建一个进程用来做守护进程
        if(pid>0){ //父进程退出,此时 子进程变为孤儿进程。
            exit(0);
        }
        setsid();   //使子进程独立1.摆脱原会话控制 2.摆脱原进程组的控制 3.摆脱控制终端的控制
        chdir("/"); //改变当前工作目录,这也是为了摆脱父进程的影响
        umask(0);   //重设文件权限掩码
        int i;
        for(i=0;i<1024;i++){    //关闭文件描述符(常说的输入,输出,报错3个文件),
            close(i);            //因为守护进程要失去了对所属的控制终端的联系,这三个文件要关闭
        }
    
        int fd=open("dameon.txt",O_CREAT|O_WRONLY|O_APPEND,0777);
        if(fd<0){
            perror("open");
            return -1;
        }
        while(1){
            write(fd,buf,strlen(buf)+1);
    		printf("This is a deamon!!\n");
            sleep(5);
        }
    
        close(fd);
    }

    C语言实现(有时间再研究):

    test.c文件

    #include <unistd.h>
    #include <stdio.h> 
    #include <time.h>
    #include <stdlib.h>
    
    void init_daemon(void);//守护进程初始化函数
    main()
    {
    	FILE *fp;
    	time_t t;
    	init_daemon();//初始化为Daemon
    	while (1)//每隔一分钟向test.log报告运行状态 
    	{
    		sleep(10);//睡眠一分钟 
    		if ((fp = fopen("test.log", "a")) >= 0)
    		{
    			t = time(0);
    			fprintf(fp, "I'm here at %sn",asctime(localtime(&t)) );
    			fclose(fp);
    		}
    	}
    }

    init.c文件

    #include<unistd.h>
    #include <signal.h> 
    #include <sys/param.h> 
    #include <sys/types.h> 
    #include <sys/stat.h>
    #include <stdlib.h>
    void init_daemon(void)
    {
    	int pid;
    	int i;
    
    	if (pid = fork())
    		exit(0);//是父进程,结束父进程 
    	else if (pid< 0)
    		exit(1);//fork失败,退出 
    				//是第一子进程,后台继续执行
    
    	setsid();//第一子进程成为新的会话组长和进程组长 
    			 //并与控制终端分离 
    	if (pid = fork())
    		exit(0);//是第一子进程,结束第一子进程 
    	else if (pid< 0)
    		exit(1);//fork失败,退出 
    				//是第二子进程,继续 
    				//第二子进程不再是会话组长
    
    	for (i = 0; i< NOFILE; ++i)//关闭打开的文件描述符 
    		close(i);
    	chdir("/tmp");//改变工作目录到/tmp 
    	umask(0);//重设文件创建掩模 
    	return;
    }

    编译:gcc –g –o test init.c test.c 
    执行:./test 
    查看进程:ps –ef 
    从输出可以发现test守护进程的各种特性满足上面的要求。

    展开全文
  • 创建守护进程步骤笔记目录:1.了解基本概念2.守护进程创建的注意事项3.写出守护进程的代码1.了解基本概念首先我们要了解一些基本概念:进程组 :·每个进程也属于一个进程组·每个进程主都有一个进程组号,该号等于...

    创建守护进程步骤

    笔记目录:

    1.了解基本概念

    2.守护进程创建的注意事项

    3.写出守护进程的代码


    1.了解基本概念


    首先我们要了解一些基本概念:

    进程组 :

    ·每个进程也属于一个进程组

    ·每个进程主都有一个进程组号,该号等于该进程组组长的PID号 .

    ·一个进程只能为它自己或子进程设置进程组ID号

    会话期:

    会话期(session)是一个或多个进程组的集合。

    setsid()函数可以建立一个对话期:

     如果,调用setsid的进程不是一个进程组的组长,此函数创建一个新的会话期

        (1)此进程变成该对话期的首进程

        (2)此进程变成一个新进程组的组长进程。

        (3)此进程没有控制终端,如果在调用setsid前,该进程有控制终端,那么与该终端的联系被解除。 如果该进程是一个进程组的组长,此函数返回错误。

        (4)为了保证这一点,我们先调用fork()然后exit(),此时只有子进程在运行


    2.守护进程创建的注意事项

    守护进程的第一步也是最重要的一步是是否以最高管理员的权限的进行创建

    /(ㄒoㄒ)/~~ 实验课上搞半天,才发现管理员的身份不是最高权限


    现在我们来给出创建守护进程所需步骤:

    编写守护进程的一般步骤步骤:

    (1)在父进程中执行fork并exit推出;

    (2)在子进程中调用setsid函数创建新的会话;

    (3)在子进程中调用chdir函数,让根目录 ”/” 成为子进程的工作目录;

    (4)在子进程中调用umask函数,设置进程的umask为0;

    (5)在子进程中关闭任何不需要的文件描述符

     


    3.写出守护进程的代码


    #include <stdio.h>
    
    #include <unistd.h>
    
    #include <stdlib.h>
    
    #include <time.h>
    
    #include <fcntl.h>
    
    #include <string.h>
    
    #include <sys/stat.h>
    
     
    
    #define ERR_EXIT(m) \
    
    do\
    
    {\
    
        perror(m);\
    
        exit(EXIT_FAILURE);\
    
    }\
    
    while (0);\
    
     
    
    void creat_daemon(void);
    
    int main(void)
    
    {
    
        time_t t;
    
        int fd;
    
        creat_daemon();
    
        while(1){
    
            fd = open("daemon.log",O_WRONLY|O_CREAT|O_APPEND,0644);
    
            if(fd == -1)
    
                ERR_EXIT("open error");
    
            t = time(0);
    
            char *buf = asctime(localtime(&t));
    
            write(fd,buf,strlen(buf));
    
            close(fd);
    
            sleep(60);
    
               
    
        }
    
        return 0;
    
    }
    
    void creat_daemon(void)
    
    {
    
        pid_t pid;
    
        pid = fork();
    
        if( pid == -1)
    
            ERR_EXIT("fork error");
    
        if(pid > 0 )
    
            exit(EXIT_SUCCESS);
    
        if(setsid() == -1)
    
            ERR_EXIT("SETSID ERROR");
    
        chdir("/");
    
        int i;
    
        for( i = 0; i < 3; ++i)
    
        {
    
            close(i);
    
            open("/dev/null", O_RDWR);
    
            dup(0);
    
            dup(0);
    
        }
    
        umask(0);
    
        return;
    

    参看博客:

    https://blog.csdn.net/one_piece_hmh/article/details/52770111

    展开全文
  • 创建子进程,父进程退出 这是编写守护进程的第一步。... 在子进程中创建新会话 这个步骤创建守护进程中最重要的一步,虽然它的实现非常简单,但它的意义却非常重大。在这里使用的是系统函数setsid,在具体
  • 1、什么是守护进程 守护进程是运行在后台的一种特殊进程,它独立于控制终端并且周期性地执行某种任务或循环等待处理某些事件的发生;...3、创建守护进程步骤 (1) fork()创建子进程,父进程exit()退出 这是创建守
  • 创建守护进程关键步骤

    千次阅读 2020-08-25 22:22:45
    创建一个守护进程,有几个关键的步骤,也有几个地方需要注意,几个关键的步骤有:1:清除文件创建权限2:调用fork,然后使父进程退出3:调用setsid以创建一个新的会话4:切换工作目录5:关闭不需要的文件描述符 ...
  • Linux守护进程1. 进程组2. 会话 1. 进程组 也称之为作业。进程组ID等于第一个进程ID,因此可以通过进程ID是否等于进程组ID来判断该进程是不是进程组的组长。 只要进程组中有一个进程存在,进程组就存在,哪怕组长...
  • 02守护进程学习之创建守护进程的七步骤及其分析 1 守护进程的概念 1)脱离终端,运行于inux中的后台服务进程,不能直接和用户交互。不受用户登录、注销的影响。 2)在后台周期执行任务或等待处理某些事件。一般采用...
  • 守护进程创建示例
  • 何为守护进程 、进程组 / 组长进程 / 会话 / 会话首进程 、守护进程的创建步骤创建守护进程程序示例
  • Golang创建守护进程

    2021-04-12 19:46:19
    一、 守护进程创建步骤 二、代码实现 func Daemon() { //父进程为init,已经是一个守护进程 if syscall.Getppid() == 1 { fmt.Println("process is already a daemon") } /* *fork 一个子进程 若...
  • 创建守护进程步骤与setsid() -- linux

    千次阅读 2015-09-01 16:09:02
    一,守护进程概述 Linux Daemon(守护进程)是运行在后台的一种特殊进程。它独立于控制终端并且周期性地执行某种任务或等待处理某些发生的事件。它不需要用户输入就能运行而且提供某种服务,不是对整个系统就是对...
  • Linux系统下创建守护进程(Daemon)

    万次阅读 多人点赞 2018-07-30 17:29:50
    守护进程(daemon)是指在后台运行的,没有控制终端与之相连的进程。它独立于控制终端,周期性地执行某种任务。Linux的大多数服务器就是用守护进程的方式实现的。如web服务器进程http等。守护进程在后台运行,类似于...
  • 创建守护进程步骤

    2008-12-18 22:53:00
    8.2.1 实现守护进程步骤在Linux系统中,要编程实现一个守护进程必须遵守如下的步骤。1.让init进程成为新产生进程的父进程。调用fork函数创建子进程后,使父进程立即退出。这样,产生的子进程将变成孤儿进程,并...
  • 守护进程 我们一般使用ps命令查看运行的进程信息。top命令为动态显示 当前进程ID PID 父进程ID PPID 进程组ID PGID 会话期ID SID 控制终端 TTY 终端进程组 TPGID ...创建守护进程步骤 1.创建子进程,父进程...
  • 原文地址:守护进程创建方法和步骤 作者:fussfuss1概念: 守护进程(Daemon)是运行在后台的一种特殊进程。它独立于控制终端并且周期性地执行某种任务或等待处理某些发生的事件。守护进程是一种很有用的进程。...
  • 创建守护进程为什么要fork两次

    千次阅读 2017-06-19 17:12:27
    1、守护进程的概念与特点 2、创建守护进程 3、创建守护进程为什么需要fork两次
  • 守护进程 守护进程的概念 Ssh、打印、ftp等均属于守护进程。进程类型为d。 特点:始终在后台运行,独立于任何终端,周期性的执行某种任务或等待处理特定事件。 会话和控制终端:linux以会话、进程组的方式管理进程,...
  • 我们可以写一个创造守护进程的函数,在程序运行时调用这个函数从而把这个程序变成一个守护进程。 这个函数需要有以下几个...下面就是一个创建守护进程的函数了。 void create_daemon(void) { pid_t pid = 0; pi
  • 守护进程创建步骤

    千次阅读 2019-04-21 15:08:23
    转自 ...什么是守护进程? 答:守护进程是后台运行的、系统启动是就存在的、...实现一个守护进程,其实就是将普通进程按照上述特性改造为守护进程的过程。 需要注意的一点是,不同版本的 Unix 系统其实现机制不同,BSD ...
  • 文章目录守护进程步骤 守护进程特点:运行周期长(开机直至你关机或者系统关闭),在后台运行,不用和用户交互(脱离终端) 会话:每打开一个终端就建立了一个会话 会话首进程:该会话运行的第一个进程(bash)(用该bash...
  • python创建守护进程

    千次阅读 2019-06-18 01:06:41
    # description: 一个守护进程的简单包装类, 具备常用的start|stop|restart|status功能, 使用方便 # 需要改造为守护进程的程序只需要重写基类的run函数就可以了 # date: 2015-10-29 # usage: 启动: python daemon...
  • 我们先来了解一下什么是守护进程守护进程 守护进程也称精灵进程(Daemon) 它是运⾏在后台的⼀种特殊进程。它独⽴于控制终端并且周期性地执⾏某种任务或等待处理某些发⽣的事件。守护进程是⼀种很有⽤的进程。...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 42,928
精华内容 17,171
关键字:

创建守护进程的步骤