linuxc语言创建进程

Ⅰ 如何用c语言模拟实现进程创建、进程撤销、进程阻塞、进程挂起等进程运行过程

linux中有具体的函数，不用模拟，当然如果这只是一个课业，用来理解进程的一系列创建，撤销，等等的话，就另当别论了。那么切入正题，在这些操作中涉及一个控制权转移的问题，这时你要有一个system对象来管理和调度进程，system对象调度进程时，为进程实体添加一些方法，以便控制权返还给它，那么这时其它的问题都迎丸而解了，

Ⅱ linux C语言进程

1、fork 是用来创建子进程的, 而不是线程( 线程创建需要用到 pthread_create )。
需要根据 fork() 的返回值来判断下面的代码是在父进程(返回pid>0)中还是子进程(返回0)中. 像上面的代码中 if 中的代码被在子进程中执行, else 中的代码在父进程中执行。
2、例程：
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
int main()
{
pid_t id; //定义一个进程号变量
int i=0;
printf("start fork/n");
id = fork(); //调用fork函数新建一个进程
i ++;
printf("end fork/n");
//判断当前进程
if(id < 0){ //出错
perror("fork failed/n");
exit(1);
}
else if(id == 0){ //子进程
printf("In child/n");
printf("i = %d/n", i++);
exit(0);
}
else{ //父进程
printf("In father/n");
printf("i = %d/n", i++);
exit(0);
}
return 0;
}
}
else if(WIFEXITED(status))
{
printf(");
while(((child=wait(&status))==-1)&(errno==EINTR));
exit(1).h>;Fork Error,strerror(errno));;*请解释一下*/
if((child=fork())==-1)
{
printf("
#include<I am the child;
int main(int argc;n"n".h>:%d\,strerror(errno)).h>
printf(",getpid());1000000!status)
{
printf("n".h>
int status.h>;sys/;;errno;
exit(i);n"wait;,WEXITSTATUS(status)),child);
#include<*请解释一下*/
if(child==-1)
{
printf("Child %d terminated normally return status is %d\
}
else if(;i<:%s\n"
i=5.h>,child;n"Child %d terminated e to signal %d znot caught\
printf("sys/I exit with%d\math;stdio;
#include<
printf("n"
#include<
}
else if(child==0)
{
int i=0;
}
/
}
else if(WIFSIGNALED(status))
{
printf("types:%s";unistd,i),char **argv)
{
pid_t child;
/Child %d terminated normally return status is zero\Wait Error;This will demostrate how to get the child status\
for(i=0;i++);
#include<,WTERMSIG(status));
}
return 0能不能帮忙解释一下这段代码中的一部分
#include<,child

Ⅲ linux下c语言创建一个进程加载指定程序！

这跟execvp函数的实现方式有关：
int execvp(const char *file ,char * const argv []);

execvp()会从PATH 环境变量所指的目录中查找符合参数file的文件名，找到后便执行该文件，然后将第二个参数argv传给该欲执行的文件。如果执行成功则函数不会返回，执行失败则直接返回-1，失败原因存于errno中。

之所以显示“fail to exec”，是因为在PATH环境变量所指的目录中没有名为“hello”的程序。建议进行如下操作：
1、运行“echo $PATH”，查看一下PATH环境变量指向那些目录
2、编写一个输出“hello world”的程序，并命名为hello，即执行命令：
gcc -o hello hello.c
3、把名为”hello“的程序拷贝到PATH变量所指的其中一个目录中

Ⅳ 如何在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下用c语言创建进程树

有问题Q我吧，QQ: 402892954
#include <stdio.h>
#include <stdlib.h>
int main(void) {
int p,p11,p12,p13,p21,p22;
while ((p=fork())==-1);
if (!p) {
printf("Parent with pid %d, parent pid %d.\n",getpid(),getppid());
while ((p11=fork())==-1);
if (!p11) {
printf("child11 with pid %d, parent pid %d.\n",getpid(),getppid());
while ((p21=fork())==-1);
if (!p21) {
printf("child21 with pid %d, parent pid %d.\n",getpid(),getppid());
exit(0);
}
else
wait(0);
while ((p22=fork())==-1);
if (!p22) {
printf("child22 with pid %d, parent pid %d.\n",getpid(),getppid());
exit(0);
}
else
wait(0);
exit(0);
}
else
wait(0);
while ((p12=fork())==-1);
if (!p12) {
printf("child12 with pid %d, parent pid %d.\n",getpid(),getppid());
exit(0);
}
else
wait(0);
while ((p13=fork())==-1);
if (!p13) {
printf("child13 with pid %d, parent pid %d.\n",getpid(),getppid());
exit(0);
}
else
wait(0);
exit(0);
}
else
wait(0);
return 0;
}

Ⅵ Linux下C语言 编写程序创建3个进程，三个进程分别完成不同的事情

两次建立子进程就行了啊~~
父子孙：
pid_tpid;
pid=fork();
//进程地址空间独立	
if(pid<0){	
}	
if(pid==0){		
pid=fork();
if(pid<0){		
}	
if(pid==0){
printf("789");//孙
}	
if(pid>0){	
printf("456");//子
}	
}
if(pid>0){
printf("123");//父
}
发散思维即可

Ⅶ C语言如何创建并发进程

1. WIN32API函数CreateProcess用来创建一个新的进程和它的主线程，这个新进程运行指定的可执行文件。

   函数原型：
   

   
   

   BOOL CreateProcess
   (
   LPCTSTR lpApplicationName,
   LPTSTR lpCommandLine,
   LPSECURITY_ATTRIBUTES lpProcessAttributes。
   LPSECURITY_ATTRIBUTES lpThreadAttributes,
   BOOL bInheritHandles,
   DWORD dwCreationFlags,
   LPVOID lpEnvironment,
   LPCTSTR lpCurrentDirectory,
   LPSTARTUPINFO lpStartupInfo,
   LPPROCESS_
   );

   参数：

   lpApplicationName
   指向一个NULL结尾的、用来指定可执行模块的字符串。
   这个字符串可以是可执行模块的绝对路径，也可以是相对路径，在后一种情况下，函数使用当前驱动器和目录建立可执行模块的路径。
   这个参数可以被设为NULL，在这种情况下，可执行模块的名字必须处于 lpCommandLine 参数最前面并由空格符与后面的字符分开。
   lpCommandLine
   指向一个以NULL结尾的字符串，该字符串指定要执行的命令行。
   这个参数可以为空，那么函数将使用lpApplicationName参数指定的字符串当做要运行的程序的命令行。
   如果lpApplicationName和lpCommandLine参数都不为空，那么lpApplicationName参数指定将要被运行的模块，lpCommandLine参数指定将被运行的模块的命令行。新运行的进程可以使用GetCommandLine函数获得整个命令行。C语言程序可以使用argc和argv参数。
   lpProcessAttributes
   指向一个SECURITY_ATTRIBUTES结构体，这个结构体决定是否返回的句柄可以被子进程继承。如果lpProcessAttributes参数为空（NULL），那么句柄不能被继承。
   在Windows NT中：SECURITY_ATTRIBUTES结构的lpSecurityDescriptor成员指定了新进程的安全描述符，如果参数为空，新进程使用默认的安全描述符。
   lpThreadAttributes
   同lpProcessAttribute,不过这个参数决定的是线程是否被继承.通常置为NULL.
   bInheritHandles
   指示新进程是否从调用进程处继承了句柄。
   如果参数的值为真，调用进程中的每一个可继承的打开句柄都将被子进程继承。被继承的句柄与原进程拥有完全相同的值和访问权限。
   dwCreationFlags
   指定附加的、用来控制优先类和进程的创建的标志。以下的创建标志可以以除下面列出的方式外的任何方式组合后指定。
   ⑴值：CREATE_DEFAULT_ERROR_MODE
   含义：新的进程不继承调用进程的错误模式。CreateProcess函数赋予新进程当前的默认错误模式作为替代。应用程序可以调用SetErrorMode函数设置当前的默认错误模式。
   这个标志对于那些运行在没有硬件错误环境下的多线程外壳程序是十分有用的。
   对于CreateProcess函数，默认的行为是为新进程继承调用者的错误模式。设置这个标志以改变默认的处理方式。
   ⑵值：CREATE_NEW_CONSOLE
   含义：新的进程将使用一个新的控制台，而不是继承父进程的控制台。这个标志不能与DETACHED_PROCESS标志一起使用。
   ⑶值：CREATE_NEW_PROCESS_GROUP
   含义：新进程将是一个进程树的根进程。进程树中的全部进程都是根进程的子进程。新进程树的用户标识符与这个进程的标识符是相同的，由lpProcessInformation参数返回。进程树经常使用GenerateConsoleCtrlEvent函数允许发送CTRL+C或CTRL+BREAK信号到一组控制台进程。
   ⑷值：CREATE_SEPARATE_WOW_VDM
   如果被设置，新进程将会在一个私有的虚拟DOS机（VDM）中运行。另外，默认情况下所有的16位Windows应用程序都会在同一个共享的VDM中以线程的方式运行。单独运行一个16位程序的优点是一个应用程序的崩溃只会结束这一个VDM的运行；其他那些在不同VDM中运行的程序会继续正常的运行。同样的，在不同VDM中运行的16位Windows应用程序拥有不同的输入队列，这意味着如果一个程序暂时失去响应，在独立的VDM中的应用程序能够继续获得输入。
   ⑸值：CREATE_SHARED_WOW_VDM
   如果WIN.INI中的Windows段的DefaultSeparateVDM选项被设置为真，这个标识使得CreateProcess函数越过这个选项并在共享的虚拟DOS机中运行新进程。
   ⑹值：CREATE_SUSPENDED
   含义：新进程的主线程会以暂停的状态被创建，直到调用ResumeThread函数被调用时才运行。
   ⑺值：CREATE_UNICODE_ENVIRONMENT
   含义：如果被设置，由lpEnvironment参数指定的环境块使用Unicode字符，如果为空，环境块使用ANSI字符。
   ⑻值：DEBUG_PROCESS
   含义：如果这个标志被设置，调用进程将被当做一个调试程序，并且新进程会被当做被调试的进程。系统把被调试程序发生的所有调试事件通知给调试器。
   如果你使用这个标志创建进程，只有调用进程（调用CreateProcess函数的进程）可以调用WaitForDebugEvent函数。
   ⑼值：DEBUG_ONLY_THIS_PROCESS
   含义：如果此标志没有被设置且调用进程正在被调试，新进程将成为调试调用进程的调试器的另一个调试对象。如果调用进程没有被调试，有关调试的行为就不会产生。
   ⑽值：DETACHED_PROCESS
   含义：对于控制台进程，新进程没有访问父进程控制台的权限。新进程可以通过AllocConsole函数自己创建一个新的控制台。这个标志不可以与CREATE_NEW_CONSOLE标志一起使用。
   〔11〕值：CREATE_NO_WINDOW
   含义：系统不为新进程创建CUI窗口，使用该标志可以创建不含窗口的CUI程序。
   dwCreationFlags参数
   还用来控制新进程的优先类，优先类用来决定此进程的线程调度的优先级。如果下面的优先级类标志都没有被指定，那么默认的优先类是NORMAL_PRIORITY_CLASS，除非被创建的进程是IDLE_PRIORITY_CLASS。在这种情况下子进程的默认优先类是IDLE_PRIORITY_CLASS。
   可以选择下面的标志中的一个：
   优先级：HIGH_PRIORITY_CLASS
   含义：指示这个进程将执行时间临界的任务，所以它必须被立即运行以保证正确。这个优先级的程序优先于正常优先级或空闲优先级的程序。一个例子是Windows任务列表，为了保证当用户调用时可以立刻响应，放弃了对系统负荷的考虑。确保在使用高优先级时应该足够谨慎，因为一个高优先级的CPU关联应用程序可以占用几乎全部的CPU可用时间。
   优先级：IDLE_PRIORITY_CLASS
   含义：指示这个进程的线程只有在系统空闲时才会运行并且可以被任何高优先级的任务打断。例如屏幕保护程序。空闲优先级会被子进程继承。
   优先级：NORMAL_PRIORITY_CLASS
   含义：指示这个进程没有特殊的任务调度要求。
   优先级：REALTIME_PRIORITY_CLASS
   含义：指示这个进程拥有可用的最高优先级。一个拥有实时优先级的进程的线程可以打断所有其他进程线程的执行，包括正在执行重要任务的系统进程。例如，一个执行时间稍长一点的实时进程可能导致磁盘缓存不足或鼠标反映迟钝。
   lpEnvironment
   指向一个新进程的环境块。如果此参数为空，新进程使用调用进程的环境。
   一个环境块存在于一个由以NULL结尾的字符串组成的块中，这个块也是以NULL结尾的。每个字符串都是name=value的形式。
   因为相等标志被当做分隔符，所以它不能被环境变量当做变量名。
   与其使用应用程序提供的环境块，不如直接把这个参数设为空，系统驱动器上的当前目录信息不会被自动传递给新创建的进程。对于这个情况的探讨和如何处理，请参见注释一节。
   环境块可以包含Unicode或ANSI字符。如果lpEnvironment指向的环境块包含Unicode字符，那么dwCreationFlags字段的CREATE_UNICODE_ENⅥRONMENT标志将被设置。如果块包含ANSI字符，该标志将被清空。
   请注意一个ANSI环境块是由两个零字节结束的：一个是字符串的结尾，另一个用来结束这个快。一个Unicode环境块是由四个零字节结束的：两个代表字符串结束，另两个用来结束块。
   lpCurrentDirectory
   指向一个以NULL结尾的字符串，这个字符串用来指定子进程的工作路径。这个字符串必须是一个包含驱动器名的绝对路径。如果这个参数为空，新进程将使用与调用进程相同的驱动器和目录。这个选项是一个需要启动应用程序并指定它们的驱动器和工作目录的外壳程序的主要条件。
   lpStartupInfo
   指向一个用于决定新进程的主窗体如何显示的STARTUPINFO结构体。
   lpProcessInformation
   指向一个用来接收新进程的识别信息的PROCESS_INFORMATION结构体。

   返回值：

   如果函数执行成功，返回非零值。
   如果函数执行失败，返回零，可以使用GetLastError函数获得错误的附加信息。

2. 进程的查看、创建和撤销（C语言）

   例程:

#include<stdio.h>
#include<windows.h>
#include<tlhelp32.h>
intshowallproc()
{
PROCESSENTRY32pe32;//用来存储进程信息的结构体
pe32.dwSize=sizeof(pe32);
HANDLEhProcessSnap=CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS,0);//获取进程快照
if(hProcessSnap==INVALID_HANDLE_VALUE)
{
printf("调用失败
");
return1;
}
BOOLbProc=Process32First(hProcessSnap,&pe32);
while(bProc)
{
printf("%5d%s
",pe32.th32ProcessID,pe32.szExeFile);//输出进程ID和进程名
bProc=Process32Next(hProcessSnap,&pe32);
}
CloseHandle(hProcessSnap);
return0;
}
intcreatproc()
{
charstr[256]={0};
printf("请输入可执行文件路径(*.exe):
");
scanf("%s",str);
STARTUPINFOsi={0};
si.cb=sizeof(STARTUPINFO);
si.dwFlags=STARTF_USESHOWWINDOW;
si.wShowWindow=SW_SHOW;
PROCESS_INFORMATIONpi;
if(!CreateProcess(NULL,str,NULL,NULL,FALSE,0,NULL,NULL,&si,&pi))
{
printf("创建失败
");
return-1;
}
else
{
printf("创建成功
");
printf("进程号:%d
",pi.dwProcessId);
}
return0;
}
intstopproc()
{
DWORDProcessID;
printf("请输入想要终止的进程ID
");
scanf("%d",&ProcessID);
HANDLEhProcess=OpenProcess(PROCESS_TERMINATE,FALSE,ProcessID);//打开对应进程句柄
if(hProcess==NULL)
{
printf("失败
");
return-1;
}
if(!TerminateProcess(hProcess,0))//关闭进程
{
printf("关闭失败
");
}
else
{
printf("关闭成功
");
}
CloseHandle(hProcess);

return0;
}
intmain()
{
intn=0;
while(n!=4)
{
printf("1查看进程
");
printf("2创建进程
");
printf("3终止进程
");
printf("4结束
");
printf("请选择:");
scanf("%d",&n);
switch(n)
{
case1:
showallproc();
break;
case2:
creatproc();
break;
case3:
stopproc();
break;
case4:
break;
default:
printf("输入有误!
");
break;
}
}
return0;
}

Ⅷ linux中C语言关于进程的创建

/*请解释一下*/
while(((child=wait(&status))==-1)&(errno==EINTR));

这种的目的是父亲进程等待子进程结束，并回收子进程的资源，将子进程的退出状态存储在status中，同时，返回该子进程的pid。
如果wait函数返回-1表示wait函数被其它情况打断返回，并没有等待到子进程结束，而同时判断errno的值是不是EINTR（意思是让你try again），那么，让进程继续等待。因为这个错误并不是真正wait错误，而是被timeout时间等造成的，因此重新等待。而如果是其它情况，显然是wait函数调用错误，即下面的if(child==-1)，需要打印错误信息。‘

//但你这句应该写错了。应该是逻辑与而不是位与操作。即
while(((child=wait(&status))==-1)&&(errno==EINTR));
/*请解释一下*/
if(child==-1)

你对信号处理部分还需要努力。
另外介绍一本书《Linux高级程序设计 第3版》 上面讲得很清楚。
有问题我们继续交流，一起学习。

更多技术文章可以关注我的微博，名字：成都睿尔科技 。

Ⅸ 在linux里用C语言编写创建进程、撤销进程，我是新手，求帮助，最好是有注释的简单易懂的。谢谢！

前面两人说的明显是线程的创建好不好?
用 pid_t fork(void);创建一个子进程

共享数据段和代码段,所以感觉上是会执行两次.

可以在父进程中添加一个wait函数,以便于子进程先退出,再父进程退出.
或者 pid_t vfork(void) 这也是创建一个进程,和前者区别不讲了.
撤销进程的话,在程序里面可以自己从代码角度去退出,也可以在两个进程运行时,通过命令 ps
来查看进程ID,,,在程序里面也可以获取进程的pid,ppid,可以直接在函数里面使用kill(),来终止进程.