linux实现守护进程

⑴ linux守护进程详解

在Linux服务器实际应用中，经常会有需要长时间执行的任务。这类任务若在前台运行，用户无法进行其他操作或者断开与服务器的连接，否则任务将被中止。此时适合使用守护进程。为了使用守护进程，需要了解Linux前台、后台、守护进程的概念与使用，本文将对此进行讲解。

可以看出，”后台任务”与”前台任务”的重要区别： 是否继承标准输入 。所以，执行后台任务的同时，用户还可以输入其他命令。

为了理解守护任务为何在结束session时也不退出，需要先了解Linux下退出session时发生的操作。

Session退出时，linux系统设计如下：

前台任务会随着session的退出而退出是因为它收到了 SIGHUP信号 。
后台任务是否会受到SIGNUP信号，取决于shell的 huponexit 参数。可以通过 $ shopt | grep huponexit 查看该参数的值。大多数Linux系统，这个参数默认关闭（off）。因此，session退出的时候，不会把SIGHUP信号发给”后台任务”，即此时的后台任务是守护进程，但这显然不够安全。并不保险，因为有的系统的 huponexit 参数可能是打开的（on）状态。

更保险的方法是使用 disown命令。它可以将指定任务从”后台任务”列表（jobs命令的返回结果）之中移除 。一个”后台任务”只要不在这个列表之中，session 就肯定不会向它发出SIGHUP信号。

执行上面的命令以后， server.js 进程就被移出了”后台任务”列表。你可以执行 jobs 命令验证，输出结果里面，不会有这个进程。

但是，这样还存在问题。因为 ”后台任务”的标准 I/O 继承自当前 session， disown 命令并没有改变这一点 。一旦”后台任务”读写标准 I/O，就会发现它已经不存在了，所以就 报错终止执行 。 为了解决这个问题，需要对”后台任务”的 标准 I/O 进行重定向 。

这样基本上就没有问题了。

注：
/dev/null 文件的作用
这是一个无底洞，任何东西都可以定向到这里，但是却无法打开。
所以一般很大的stdou和stderr当你不关心的时候可以利用stdout和stderr定向到这里

nohup命令对server.js进程做了三件事。
阻止SIGHUP信号发到这个进程。
关闭标准输入。该进程不再能够接收任何输入，即使运行在前台。
重定向标准输出和标准错误到文件nohup.out。

也就是说，nohup命令实际上将子进程与它所在的 session 分离了。 注意，nohup命令不会自动把进程变为”后台任务”，所以必须加上&符号

守护进程创建方法：

方法一：

方法二：

方法三：

fg、bg、jobs、&、nohup、ctrl+z、ctrl+c 命令

一、&
加在一个命令的最后，可以把这个命令放到后台执行，如：

二、ctrl + z
可以将一个正在前台执行的命令放到后台，并且处于暂停状态。

CTRL+Z 和 CTRL+C的对比

CTRL+Z 和 CTRL+C 都是中断命令,但是他们的作用却不一样.
CTRL+C 是强制中断程序的执行，而 CTRL+Z 的是将任务中断,但是此任务并没有结束,仍然在进程中，只是维持挂起的状态，用户可以使用 fg/bg 操作继续前台或后台的任务。

三、jobs
查看当前有多少在后台运行的进程

jobs -l选项可显示所有任务的PID，jobs的状态可以是running, stopped, Terminated。但是如果任务被终止了（kill），shell 从当前的shell环境已知的列表中删除任务的进程标识。

四、fg
将后台中的命令调至前台继续运行。如果后台中有多个命令，可以用 fg %jobnumber （jobnumber是命令编号，不是进程号）将选中的命令调出。

五、bg

将一个在后台暂停的命令，变成在后台继续执行。

如果后台中有多个命令，可以用 bg %jobnumber 将选中的命令调出。

六、kill

方法1：通过jobs命令查看job号（假设为num），然后执行

方法2：通过ps命令查看job的进程号（PID，假设为pid），然后执行

前台进程的终止：Ctrl+c

七、nohup

如果想让程序即使在关闭当前的终端后也始终在后台执行（之前的&做不到），需要使用nohup命令。
nohup命令可以在你退出帐户/关闭终端之后继续运行相应的进程。
关闭终端后，在另一个终端jobs已经无法看到后台跑的程序了，此时利用ps（进程查看命令）查看进程。

http://m.2cto.com/os/201301/185701.html

http://www.cnblogs.com/kaituorensheng/p/3980334.html

http://m.blog.csdn.net/article/details?id=50766752

⑵ 如何编写Linux Daemon后台程序

守护进程（Daemon）是运行在后台的一种特殊进程。它独立于控制终端并且周期核瞎模性地执行某种任务或等待处理某些发生的事件。守护进程是一种很有用的进 程。Linux的大多数服务器就是用守护进程实现的。比如，Internet服务器inetd，Web服务器httpd等。同时，守护进程完成许多系统任 务。比如，作业规划进程crond，打印进程lpd等。 x0dx0a守护进程的编程本身并不复杂，复杂的是各种版本的Unix的实现机制不尽相同，造成不同Unix环境下守护进程的编程规则并不一致。这需要读者注意，照搬 某些书上的规则（特别是BSD4.3和低版本的System V）到Linux会出现错误的。下面将全面介绍Linux下守护进程的编程要点并给出详细实例。 x0dx0a一． 守护进程及其特性 x0dx0a守护进程最重要的特性是后台运行。在这一点上DOS下的常驻内存程序TSR与之相似。其次，守护进程必须与其运行前的环境隔离开来。这些环境包括未关闭的 文件描述符，控制终端，会话和进程组，工作目录以及文件创建掩模等。这些环境通常是守护进程从执行它的父进程（特别是shell）中继承下来的。最后，守 护进程的启动方式有其特殊之处。它可以在Linux系统启动时从启动脚本/etc/rc.d中启动，可以由作业规划进程crond启动，还可以由用户终端 （通常是shell）执行。 x0dx0a总之，除开这些特殊性以外，守护进程与普通进程基本上没有什么区别。因此，编写守护进程实际上是把一个普通进程按照上述的守护进程的特性改造成为守护进程。如果读者对进程有比较深入的认识就更容易理解和编程了。 x0dx0a二． 守护进程的编程要点 x0dx0a前面讲过，不同Unix环境下守护进程的编程规则并不一致。所幸的是守护进程的编程原则其实都一样，区别在于具体的实现细节不同。这个原则就是要满足守护 进程的特性。同时，Linux是基于Syetem V的SVR4并遵循Posix标准，实现起来与BSD4相比更方便。编程要点如下； x0dx0a1. 在后台运行。 x0dx0a为避免挂起控制终端将Daemon放入后台执行。方法是在进程中调用fork使父进程终止，让Daemon在子进程中后台执行。改缓 x0dx0aif(pid=fork()) x0dx0aexit(0);//是父进程，结束父进程，子进程继续 x0dx0a2. 脱离控制终端，登录会话和进程组 x0dx0a有必要先介绍一下Linux中的进程与控制终端，登录会话和进程组之间的关系：进程属于一个进程组，进程组号（GID）就是进程组长的进程号（PID）。登录会话可以包含多个进程组。这些进程组共享一个控制终端。这个控制终端通常是创建进程的登录终端。 x0dx0a控制终端，登录会话和进程组通常是从父进程继承下来的。我们的目的就是要摆脱它们，使之不受它们的影响。方法是在第1点的基础上，调用setsid()使进程成为会话组长： x0dx0asetsid(); x0dx0a说明：当进程是会话组长时setsid()调用失败。但第一点已经保证进程不是会话组长。setsid()调用成功后，进程成为新的会话组长和新的进程组长，并与原来的登录会话和进程组脱离。由于会话过程对控制终端的独占性，进程同时与控制终端脱离。 x0dx0a3. 禁止进程重新打开控制终端 x0dx0a现在，进程已经成为无终端的会话组长。但它可以重新申请打开一个控制终端。可以通过使进程不再成为会话组长来禁止进程重新打开控制终端： x0dx0aif(pid=fork()) x0dx0aexit(0);//结束第一子进程，第二子进程继续（第二子进程不再是会话组长） x0dx0a4. 关闭打开的文件描述符 x0dx0a进程从创建它的父进程那里继承了打开的文件描述符。如不关闭，将会浪费系统资源，造成进程所在的文件系统无法卸下以及引起无法预料的错误。按如下方法关神郑闭它们： x0dx0afor(i=0;i 关闭打开的文件描述符close(i);> x0dx0afor(i=0;i< NOFILE;++i)x0dx0a5. 改变当前工作目录 x0dx0a进程活动时，其工作目录所在的文件系统不能卸下。一般需要将工作目录改变到根目录。对于需要转储核心，写运行日志的进程将工作目录改变到特定目录如/tmpchdir("/") x0dx0a6. 重设文件创建掩模 x0dx0a进程从创建它的父进程那里继承了文件创建掩模。它可能修改守护进程所创建的文件的存取位。为防止这一点，将文件创建掩模清除：umask(0); x0dx0a7. 处理SIGCHLD信号 x0dx0a处理SIGCHLD信号并不是必须的。但对于某些进程，特别是服务器进程往往在请求到来时生成子进程处理请求。如果父进程不等待子进程结束，子进程将成为 僵尸进程（zombie）从而占用系统资源。如果父进程等待子进程结束，将增加父进程的负担，影响服务器进程的并发性能。在Linux下可以简单地将 SIGCHLD信号的操作设为SIG_IGN。 x0dx0asignal(SIGCHLD,SIG_IGN); x0dx0a这样，内核在子进程结束时不会产生僵尸进程。这一点与BSD4不同，BSD4下必须显式等待子进程结束才能释放僵尸进程。 x0dx0a三． 守护进程实例 x0dx0a守护进程实例包括两部分：主程序test.c和初始化程序init.c。主程序每隔一分钟向/tmp目录中的日志test.log报告运行状态。初始化程序中的init_daemon函数负责生成守护进程。读者可以利用init_daemon函数生成自己的守护进程。 x0dx0a1． init.c清单 x0dx0a#include < unistd.h > x0dx0a#include < signal.h > x0dx0a#include < sys/param.h > x0dx0a#include < sys/types.h > x0dx0a#include < sys/stat.h > x0dx0avoid init_daemon(void) x0dx0a{ x0dx0aint pid; x0dx0aint i; x0dx0ax0dx0aif(pid=fork()) x0dx0aexit(0);//是父进程，结束父进程 x0dx0aelse if(pid< 0) x0dx0aexit(1);//fork失败，退出 x0dx0a//是第一子进程，后台继续执行 x0dx0ax0dx0asetsid();//第一子进程成为新的会话组长和进程组长 x0dx0a//并与控制终端分离 x0dx0aif(pid=fork()) x0dx0aexit(0);//是第一子进程，结束第一子进程 x0dx0aelse if(pid< 0) x0dx0aexit(1);//fork失败，退出 x0dx0a//是第二子进程，继续 x0dx0a//第二子进程不再是会话组长 x0dx0ax0dx0afor(i=0;i< NOFILE;++i)//关闭打开的文件描述符 x0dx0aclose(i); x0dx0achdir("/tmp");//改变工作目录到/tmp x0dx0aumask(0);//重设文件创建掩模 x0dx0areturn; x0dx0a} x0dx0a2． test.c清单 x0dx0a#include < stdio.h > x0dx0a#include < time.h > x0dx0avoid init_daemon(void);//守护进程初始化函数 x0dx0amain() x0dx0a{ x0dx0aFILE *fp; x0dx0atime_t t; x0dx0ainit_daemon();//初始化为Daemon x0dx0awhile(1)//每隔一分钟向test.log报告运行状态 x0dx0a{ x0dx0asleep(60);//睡眠一分钟 x0dx0aif((fp=fopen("test.log","a")) >=0) x0dx0a{ x0dx0at=time(0); x0dx0afprintf(fp,"I'm here at %sn",asctime(localtime(&t)) ); x0dx0afclose(fp); x0dx0a} x0dx0a} x0dx0a} x0dx0a以上程序在RedHat Linux6.0下编译通过。步骤如下： x0dx0a编译：gcc _g _o test init.c test.c x0dx0a执行：./test x0dx0a查看进程：ps _ef x0dx0a从输出可以发现test守护进程的各种特性满足上面的要求。

⑶ linux 如何实现java守护进程编程开发

可以通过GuardServer实现，具体代码如下;

1publicclassGuardServer{
2privateStringservername;
3
4publicGuardServer(Stringservername){
5this.servername=servername;
6}
7
8publicvoidstartServer(Stringcmd)throwsException{
9System.out.println("StartServer:"+cmd);
10//将命令分开
11//String[]cmds=cmd.split("");
12//ProcessBuilderbuilder=newProcessBuilder(cmds);
13
14//
15ProcessBuilderbuilder=newProcessBuilder(newString[]{"/bin/sh","-c",cmd});
16//将服务器程序的输出定位到/dev/tty
17builder.redirectOutput(newFile("/dev/tty"));
18builder.redirectError(newFile("/dev/tty"));
19builder.start();//throwsIOException
20Thread.sleep(10000);
21}
22
23/**
24*检测服务是否存在
25*
26*@return返回配置的java程序的pid
27*@returnpid>0返回的是pid<=0代表指定java程序未运行
28***/
29publicintcheckServer()throwsException{
30intpid=-1;
31Processprocess=null;
32BufferedReaderreader=null;
33process=Runtime.getRuntime().exec("jps-l");
34reader=newBufferedReader(newInputStreamReader(process.getInputStream()));
35Stringline;
36while((line=reader.readLine())!=null){
37String[]strings=line.split("\s{1,}");
38if(strings.length<2)
39continue;
40if(strings[1].contains(servername)){
41pid=Integer.parseInt(strings[0]);
42break;
43}
44}
45reader.close();
46process.destroy();
47returnpid;
48}
49}

⑷ 如何在Linux下用c语言创建守护进程并监控系统运行期间的所有进程

可以分三步来做：

1. 做两个简单的守护进程，并能正常运行


2. 监控进程是否在运行


3. 启动进程

综合起来就可以了，代码如下：
被监控进程thisisatest.c（来自）：
#include<unistd.h>
#include<signal.h>
#include<stdio.h>
#include<stdlib.h>
#include<sys/param.h>
#include<sys/types.h>
#include<sys/stat.h>
#include<time.h>


void init_daemon()
{
int pid;
int i;
pid=fork();
if(pid<0)
exit(1); //创建错误，退出
else if(pid>0) //父进程退出
exit(0);

setsid(); //使子进程成为组长
pid=fork();
if(pid>0)
exit(0); //再次退出，使进程不是组长，这样进程就不会打开控制终端
else if(pid<0)
exit(1);


//关闭进程打开的文件句柄
for(i=0;i<NOFILE;i++)
close(i);
chdir("/root/test"); //改变目录
umask(0);//重设文件创建的掩码
return;
}


void main()
{
FILE *fp;
time_t t;
init_daemon();
while(1)
{
sleep(60); //等待一分钟再写入
fp=fopen("testfork2.log","a");
if(fp>=0)
{
time(&t);
fprintf(fp,"current time is:%s ",asctime(localtime(&t))); //转换为本地时间输出
fclose(fp);
}
}
return;
}


监控进程monitor.c：
#include<unistd.h>
#include<signal.h>
#include<stdio.h>
#include<stdlib.h>
#include<sys/param.h>
#include<sys/types.h>
#include<sys/stat.h>
#include<time.h>


#include<sys/wait.h>
#include<fcntl.h>
#include<limits.h>


#define BUFSZ 150


void init_daemon()
{
int pid;
int i;
pid=fork();
if(pid<0)
exit(1); //创建错误，退出者氏
else if(pid>0) //父进程退出
exit(0);


setsid(); //使子进程成为组长
pid=fork();
if(pid>0)
exit(0); //再次退出，使进程不是组长，这样进程就不会打开控制终端
else if(pid<0)
exit(1);


//关闭进程打开的文件句柄
for(i=0;i<首搏散NOFILE;i++)
close(i);
chdir("/root/test"); //改变目录
umask(0);//重设文件创建的掩码银历
return;
}


void err_quit(char *msg)
{
perror(msg);
exit(EXIT_FAILURE);
}


// 判断程序是否在运行
int does_service_work()
{
FILE* fp;
int count;
char buf[BUFSZ];
char command[150];
sprintf(command, "ps -ef | grep thisisatest | grep -v grep | wc -l" );


if((fp = popen(command,"r")) == NULL)
err_quit("popen");


if( (fgets(buf,BUFSZ,fp))!= NULL )
{
count = atoi(buf);
}
pclose(fp);
return count;
// exit(EXIT_SUCCESS);
}




void main()
{
FILE *fp;
time_t t;
int count;
init_daemon();
while(1)
{
sleep(10); //等待一分钟再写入
fp=fopen("testfork3.log","a");
if(fp>=0)
{
count = does_service_work();
time(&t);
if(count>0)
fprintf(fp,"current time is:%s and the process exists, the count is %d ",asctime(localtime(&t)), count); //转换为本地时间输出
else
{
fprintf(fp,"current time is:%s and the process does not exist, restart it! ",asctime(localtime(&t))); //转换为本地时间输出
system("/home/user/daemon/thisisatest"); //启动服务
}


fclose(fp);
}
}
return;
}


具体CMD命令：


cc thisisatest.c -o thisisatest
./thisisatest
cc monitor.c -o monitor
./monitor


tail -f testfork3.log -- 查看日志

⑸ 如何正确编写linux守护进程

1、守护进程，也就是通常说的Daemon进程，是Linux中的后台服务进程。它是一个生存期较长的进程，通常独立于控制终端并且周期性地执行某种任务或等待处理某些发生的事件。如果想让某个进程不因为用户或终端或其他地变化而受到影响，那么就必须把这个进程变成一个守护进程。
2、创建守护进程步骤
1）创建子进程，父进程退出
之后的所有工作都在子进程中完成，而用户在Shell终端里则可以执行其他命令，从而在形式上做到了与控制终端的脱离。
在Linux中父进程先于子进程退出会造成子进程成为孤儿进程，而每当系统发现一个孤儿进程时，就会自动由1号进程（init）收养它，这样，原先的子进程就会变成init进程的子进程。
2）在子进程中创建新会话
进程组：是一个或多个进程的集合。进程组有进程组ID来唯一标识。除了进程号（PID）之外，进程组ID也是一个进程的必备属性。每个进程组都有一个组长进程，其组长进程的进程号等于进程组ID。且该进程组ID不会因组长进程的退出而受到影响。
会话周期：会话期是一个或多个进程组的集合。通常，一个会话开始于用户登录，终止于用户退出，在此期间该用户运行的所有进程都属于这个会话期。
（1）pid_t setsid(void);
setsid() creates a new session if the calling process is not a process group leader. The calling process will be the only process in this new process group and in this new session.
setsid函数用于创建一个新的会话，并担任该会话组的组长。调用setsid有下面的3个作用：
① 让进程摆脱原会话的控制
② 让进程摆脱原进程组的控制
③ 让进程摆脱原控制终端的控制
有以下三个结果：
（a)成为新会话的首进程
（b）成为一个新进程组的组长进程
（c）没有控制终端。
有些人建议在此时再次调用fork，并使父进程终止。第二个子进程作为守护进程继续运行。这样就保证了该守护进程不是会话首进程。
setsid函数能够使进程完全独立出来，从而摆脱其他进程的控制。
setsid()调用成功后，进程成为新的会话组长和新的进程组长，并与原来的登录会话和进程组脱离。由于会话过程对控制终端的独占性，进程同时与控制终端脱离。 子进程可以自己组成一个新的进程组,即调用setpgrp()与原进程组脱离关系,产生一个新的进程组,进程组号与它的进程号相同.这样,父进程退出运行后就不会影响子进程的当前运行.
3）改变当前目录为根目录
使用fork创建的子进程继承了父进程的当前工作目录；进程活动时，其工作目录所在的文件系统不能卸下。通常的做法是让"/"作为守护进程的当前工作目录，也可以是其他目录，如/tmp，使用chdir。
4）重设文件权限掩码
文件权限掩码是指屏蔽掉文件权限中的对应位。比如，有个文件权限掩码是050，它就屏蔽了文件组拥有者的可读与可执行权限。mask = mask & ~050
通常，把文件权限掩码设置为0，umask(0)。
5）关闭文件描述符
用fork函数新建的子进程会从父进程那里继承已经打开了的文件描述符。这些被打开的文件可能永远不会被守护进程读写，但它们一样消耗系统资源，而且可能导致所在的文件系统无法卸下。
在上面的第二步之后，守护进程已经与所属的控制终端失去了联系。因此从终端输入的字符不可能达到守护进程，守护进程中用常规方法（如printf）输出的字符也不可能在终端上显示出来。所以，文件描述符为0、1和2 的3个文件（常说的输入、输出和报错）已经失去了存在的价值，也应被关闭。
for(i=0;i<MAXFILE;i++)
close(i);
6）守护进程退出处理
当用户需要外部停止守护进程运行时，往往会使用 kill命令停止该守护进程。所以，守护进程中需要编码来实现kill发出的signal信号处理，达到进程的正常退出。
signal(SIGTERM, sigterm_handler);
void sigterm_handler(int arg)
{
_running = 0;
}
7）处理SIGCHLD信号
处理SIGCHLD信号并不是必须的。但对于某些进程，特别是服务器进程往往在请求到来时生成子进程处理请求。如果父进程不等待子进程结束，子进程将成为僵尸进程（zombie）从而占用系统资源。如果父进程等待子进程结束，将增加父进程的负担，影响服务器进程的并发性能。在Linux下可以简单地将 SIGCHLD信号的操作设为SIG_IGN。
signal(SIGCHLD,SIG_IGN);
这样，内核在子进程结束时不会产生僵尸进程。

⑹ Linux 简单的守护进程 程序源代码是什么怎么写

//根据麦子学院视频改编。。。。 #include #include #include #include #include #include #include int main(int argc,char**argv) { int num=0; //sundy print log char content[128]=""; //1,创建一个子进程，退出父进程 pid_t pid=fork(); if(pid0) { exit(0); } //2,设置新的会话 pid_t ret=setsid(); if(ret0) { sprintf(content, "sundy print log = %d\n", num); write(fd,content,strlen(content)); close(fd); } num++; sleep(3); } return 0; }

⑺ Linux系统中的守护进程讲解

守护进程daemon，是生存期较长的一种进程。它们常常在系统自举时启动，仅在系统关闭时才终止。因为它们没有控制终端，所以说它们是在后台运行的。UNIX系统有很多守护进程，它们执行日常事务活动。

1、系统自举

自举（bootstrapping）一词来自于人都是靠自身的自举机构站立起来的这一思想。计算机必须具备自举能力将自己所有的元件激活，以便能完成加载操作系统这一目的，然后再由操作系统承担起那些单靠自举代码无法完成的更复杂的任务。

自举只有两个功能：加电自检和磁盘引导。

加电自检：当我们按下计算机电源开关时，头几秒钟机器似乎什么反应也没有，其实，这时的计算机正在进行加电自检，以断定它的所有元件都在正确地工作。如果某个元件有故障，显示器上就会出现报警提示信息（如果显示器也不能正常工作，则以一串嘟嘟声来报警）。由于大多数计算机工作非常可靠，加电自检报警非常罕见。

磁盘引导：查找装有操作系统的磁盘驱动器。从磁盘加载操作系统的原因有二，一是操作系统升级简单容易，二是使用户拥有选择操作系统的自由。

当加电自检和磁盘引导完成时，自举操作就启动一个读写操作系统文件和将它们复制到随机存储器中的过程，此时的机器才是真正意义上的计算机。计算机的启动可以有冷启动和热启动两种方式 ，它们之间的差别是热启动不进行机器的自检（机器本身配置的检查与测试），当计算机在使用过程中由于某些原因造成死机时，可以对计算机进行热启动处理。

2、守护进程的概念

通过ps axj命令可以查看到守护进程：

参数a表示不仅列当前用户的进程，也列出所有其他用户的进程，参数x表示不仅列有控制终端的进程，也列出所有无控制终端的进程，参数j表示列出与作业控制相关的信息。

代码如下:PPID PID PGID SID TTY TPGID STAT UID TIME COMMAND 0 1 1 1 ? -1 Ss 0 0:01 /sbin/init 0 2 0 0 ? -1 S< 0 0:00 [kthreadd] 2 3 0 0 ? -1 S< 0 0:00 [migration/0] 2 4 0 0 ? -1 S< 0 0:00 [ksoftirqd/0]... 1 2373 2373 2373 ? -1 S<s 0 0:00 /sbin/udevd --daemon... 1 4680 4680 4680 ? -1 Ss 0 0:00 /usr/sbin/acpid -c /etc... 1 4808 4808 4808 ? -1 Ss 102 0:00 /sbin/syslogd -u syslog...

凡是TPGID一栏写着-1的都是没有控制终端的进程，也就是守护进程。在COMMAND一列用[]括起来的名字表示内核线程，这些线程在内核里创建，没有用户空间代码，因此没有程序文件名和命令行，通常采用以k开头的名字，表示Kernel。init进程我们已经很熟悉了，udevd负责维护/dev目录下的设备文件，acpid负责电源管理，syslogd负责维护/var/log下的日志文件，可以看出，守护进程通常采用以d结尾的`名字，表示Daemon。 创建守护进程最关键的一步是调用setsid函数创建一个新的Session，并成为Session Leader。 例子： C/C++ Code复制内容到剪贴板 void daemonize(void) { pid_t pid; printf("into deamonizen"); if (pid=fork() < 0) { perror("fork"); exit(1); } else if (pid !=0) { exit(0); } setsid(); if (chdir("/") < 0) { perror("chdir"); exit(1); } close(0); open("/dev/null", O_RDWR); p2(0, 1); p2(0, 2); printf("out deamonizen"); }

3、编写守护进程 在编写守护进程程序时，需遵循一些基本规则：

（1）首先要做的是调用umask将文件模式创建屏蔽字设置为0。

（2）调用fork，然后使父进程退出。

（3）调用setsid以创建一个新会话。

（4）将当前工作目录更改为根目录。

（5）关闭不再需要的文件描述符。

（6）某些守护进程打开/dev/null使其具有文件描述符0、1和2，任何一个试图读标准输入、写标准输出或标准出错的库例程都不会产生任何效果。 与守护进程有关的一个问题是如何处理出错消息，需要有一个集中的守护进程出错记录设施，这就是syslogd进程。

4、守护进程惯例 为了正常运作，某些守护进程实现为单实例的，有就是在任一时刻只运行该守护进程的一个副本。文件锁和记录锁机制是一种方法的基础，该方法用来保证一个守护进程只有一个副本在运行。

在UNIX系统中，守护进程遵循下列公共惯例：

（1）若守护进程使用锁文件，那么该文件通常存放在/var/run目录中。锁文件的名字通常是name.pid，name是该守护进程或服务的名字。

（2）若守护进程支持配置选项，那么配置文件通常存放在/etc目录中。配置文件的名字通常是name.conf。

（3）守护进程可用命令行启动，但通常它们是由系统初始化脚本启动的。

（4）若一守护进程有一配置文件，那么当该守护进程启动时，它读该文件，但在此之后一般就不会再查看它。

⑻ 在Linux部署进程守护脚本遇到的坑

    昨天在Linux做个进程守护脚本时发生了几个小问题，实属不该。先总结如下，在以后的实践中一个避免这样的问题。同时针对cron，再次深入学习实践。

1、换行符问题

    脚本与运行报错“：badinterpreter:Nosuchfileordirectory”。

    脚本在windows下编辑，有几条命令是直接复制过来使用的，虽然vs code可以在右下角选择行尾序列，但是在实际运行时还是提示无法识别/r，每一行都多了个^M  。

  \r\n： Dos和Windows采用回车+换行（CR+LF）表示下一行，即^M$

\n： 而UNIX/Linux采用换行符（LF）表示下一行

\r： 苹果机(MAC OS系统)则采用回车符（CR）表示下一行 

2、= 赋值问题

    笔者在使用if条件表达式时，知道条件要放在方括号之间，并且要有空格。误以为变量赋值=也要空格，运行时发现变量无法识=识别，后来才知道变量赋值=不能有空格。

3、cron定时任务的环境变量问题

    用户的crontab定时任务不会使用默认的变量， 需要写全路径，包括crontab调用的脚本里面 。而系统cron定时任务是由定义环境变量的。MAILTO是表示例行性命令发生错误时，会将错误讯息邮件传给root，服务器中关闭postfix，导致邮件发送不成功，全部小文件堆积在/var/spool/postfix/maildrop/里面。

4、cron中执行的程序有输出内容，输出内容会以邮件形式发给cron的用户，而sendmail没有启动所以就产生了/var/spool/mail目录下的那些文件，日积月累可能撑破磁盘。在cron中命令后面加上 >/dev/null 2>&1 来不输出。

5、crontab中的指令需要root，配置/etc/sudoers文件来保证sudo可用，其实可用使用系统任务计划，指定root来执行即可。

     最后，笔者专注于使用cron，现在在以前的文章（树莓派上测试）- Linux crontab定时任务详细分解 的基础上，在腾讯云服务器centos上补充以下cron的知识。

用户计划任务 ：

1、crond时cron的守护进程，crond是由多个配置文件和系统范围内的文件控制的，每个用户对应一个配置文件。crond守护进程是cronie软件的一部分。用户的配置文件在/var/spool/cron/username。

2、crontab命令

    crontab -e 编辑当前用户的定时计划

    crontab -l 列出当前用户的定时计划

     crontab -r 删除当前用户的所有定时计划

       crontab filename 删除当前用户的所有定时计划，并从filename中读取作业，如果未指定任何文件，则使用stdin 。

3、格式，另外*/x表示间隔x个周期。 用户计划任务没有user-name字段！

  */7  9-16  *  jul 5 command表示7月的每周五的上午9到下午5点 间，每七分钟执行一次。

系统计划任务：

1、系统cron不是由crontab来执行的，而是在一组配置文件中定义的，配置文件多了一个字段-用户字段，指定作业在那个用户下运行。

2、系统计划任务储存在/etc/crontab、 /etc/cron.d/*  以及/etc/cron.* ，/etc/crontab的语法规则参照上面的图。 /etc/cron.d/时软件产生的一些更新任务，一般不在里面做操作。

3、预定义作业，cron.daily、cron.hourly、cron.monthly、cron.weekly下面储存的是可执行脚本。

    /etc/cron.hourly/*脚本是使用runparts命令从/etc/cron.d/0hourly中定义的，表示每小时的第一分钟将 /etc/cron.hourly/下面的脚本全部执行。

    /etc/cron.daily、 /etc/cron.monthly、 /etc/cron.weekly也是使用runparts命令，但是是从/etc/anacrontab中执行的。

4、/etc/anacrontab语法规则

       START_HOURS_RANGE=3-22，表示Anacron jobs will start between 3am and 10pm.

       RANDOM_DELAY=45，The RANDOM_DELAY variable denotes the maximum number of minutes that will be added to the delay in minutes variable  which  is specified for each job.

     上图中，对于 /etc/cron.daily，那么delay 会是 5 minutes + RANDOM_DELAY  。

    接下来就是4个重要的参数：

      period in days ，delay in minutes ，job-identifier，   command

    The period in days variable表示执行周期，每多少天运行一次该作业。

    delay in minutes：上面提到的执行的延时，启动作业前，crond等待的时间。

    job-identifier：标识作业的唯一名称，用做日志记录。是/var/spool/anacron中文件的名称，检查该作业是否已运行，/etc/anacrontab启动作业时，会更新此文件的时间戳，检查作业上次运行的时间。anacron 会分析现在的时间与时间记录文件所记载的上次执行 anacron 的时间，将两者进行比较，如果两个时间的差值超过 anacron 的指定时间差值（一般是 1 天、7 天和一个月），就说明有定时任务没有执行，这时 anacron 会介入并执行这个漏掉的定时任务，从而保证在关机时没有执行的定时任务不会被漏掉。这也是为什么/etc/cron.{daily，weekly，monthly} 目录中的定时任务只会被 anacron 调用，而 /etc/cron.hourly/被cron调用 。

     command：执行命令可以是普通命令或者脚本。

5、cron的访问控制

    /etc/cron.allow、    /etc/cron.deny ，以决定哪些用户可以使用调度服务。

    如果只有cron.deny文件，而cron.allow文件不存在，则除了黑名单之外的所有用户都可以使用；

    如果只有cron.allow文件存在，而cron.deny文件不存在时，则只有白名单用户才可以使用,，包括root。

    如果两个文件都存在，则忽略cron.allow文件。

    如果两个文件都不存在，每个用户都可以访问。

⑼ Node.js 在Linux下如何进行守护进程

Node.js 有专门的守护进程模块

1、生产环境

pm2 / forever

pm2starta.js
foreverstarta.js

2、猛雹清开发环境

supervisor

supervisora.js

3、Linux传统守护进程

通过nohup，服务化等方式进行守枝前护进肆尘程的创建，这里的话建议仔细读读linux就该这么学的相关教程。

⑽ linux怎么用守护进程和sdl

1、使用sudosupervisorctl进入supervisor管理终端。
2、使用reload重新读取配置文件并重启当前supoervisor管理的所有进程。
3、也可以使用update重新加载配置(默认不重启)，随后使用startgf-app启动指定的应用程序。