标签：
Exec1.c
#include <stdio.h>
#include <unistd.h>
int main()
{
char *arglist[3];
arglist[0] = "ls";
arglist[1] = "-l";
arglist[2] = 0 ;//NULL
printf("* * * About to exec ls -l\n");
execvp( "ls" , arglist );//会从PATH 环境变量所指的目录中查找符合参数file 的文件名，找到后便执行该文件，然后将第二个参数argv传给该欲执行的文件。如果执行成功则函数不会返回，执行失败则直接返回-1，失败原因存于errno中
printf("* * * ls is done. bye");
return 0;
}
Exec2.c
#include <stdio.h>
#include <unistd.h>
int main()
{
char *arglist[3];
arglist[0] = "ls";
arglist[1] = "-l";
arglist[2] = 0 ;
printf("* * * About to exec ls -l\n");
execvp( arglist[0] , arglist );
printf("* * * ls is done. bye\n");
}//exec1传的是ls，exec2直接传的arglist[0]
execlp("ls", "ls", "-l", NULL);//会从PATH 环境变量所指的目录中查找符合参数file的文件名，找到后便执行该文件，然后将第二个以后的参数当做该文件的argv[0]、argv[1]……，最后一个参数必须用空指针(NULL)作结束。如果用常数0来表示一个空指针，则必须将它强制转换为一个字符指针，否则将它解释为整形参数，如果一个整形数的长度与char * 的长度不同，那么exec函数的实际参数就将出错。如果函数调用成功,进程自己的执行代码就会变成加载程序的代码,execlp()后边的代码也就不会执行了.返回值：如果执行成功则函数不会返回，执行失败则直接返回-1，失败原因存于errno 中。
Forkdemo1.c
#include <stdio.h>
#include <sys/types.h>
#include <unistd.h>
int main()
{
int ret_from_fork, mypid;
mypid = getpid();
printf("Before: my pid is %d\n", mypid);
ret_from_fork = fork();
sleep(1);
printf("After: my pid is %d, fork() said %d\n",
getpid(), ret_from_fork);//这个代码先是打印进程pid，然后调用fork函数生成子进程，休眠一秒后再次打印进程id，这时父进程打印子进程pid，子进程返回0.
return 0;
}
Forkdemo2.c
#include <stdio.h>
#include <unistd.h>
int main()
{
printf("before:my pid is %d\n", getpid() );
fork();
fork();//这个代码调用两次fork，一共产生四个子进程，所以会打印四个aftre输出。
printf("aftre:my pid is %d\n", getpid() );
return 0;
}
Forkdemo3.c
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
int main()
{
int fork_rv;
printf("Before: my pid is %d\n", getpid());
fork_rv = fork(); /* create new process */
if ( fork_rv == -1 ) /* check for error */
perror("fork");
else if ( fork_rv == 0 ){
printf("I am the child. my pid=%d\n", getpid());
exit(0);
}
else{
printf("I am the parent. my child is %d\n", fork_rv);//fork产生子进程，父进程返回子进程pid，不为0，所以输出父进程的那句话，子进程返回0，所以会输出子进程那句话。
exit(0);
}
return 0;
}
Forkdemo4.c
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
int main()
{
int fork_rv;
printf("Before: my pid is %d\n", getpid());
fork_rv = fork(); /* create new process */
if ( fork_rv == -1 ) /* check for error */
perror("fork");
else if ( fork_rv == 0 ){
printf("I am the child. my pid=%d\n", getpid());
printf("parent pid= %d, my pid=%d\n", getppid(), getpid());
exit(0);
}
else{
printf("I am the parent. my child is %d\n", fork_rv);//先打印进程pid，然后fork创建子进程，父进程返回子进程pid，所以输出parent一句，休眠十秒；子进程返回0，所以输出child与之后一句。
sleep(10);
exit(0);
}
return 0;
}
Forkgdb.c
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
int gi=0;
int main()
{
int li=0;
static int si=0;
int i=0;
pid_t pid = fork();
if(pid == -1){
exit(-1);
}
else if(pid == 0){
for(i=0; i<5; i++){
printf("child li:%d\n", li++);
sleep(1);
printf("child gi:%d\n", gi++);
printf("child si:%d\n", si++);
}
exit(0);
}
else{
for(i=0; i<5; i++){
printf("parent li:%d\n", li++);
printf("parent gi:%d\n", gi++);
sleep(1);
printf("parent si:%d\n", si++);
}
//这个的主要区别是在，父进程打印是先打印两句，然后休眠一秒，然后打印一句，子进程先打印一句，然后休眠一秒，然后打印两句。并且这两个线程是并发的，所以可以看到在一个线程休眠的那一秒，另一个线程在执行，并且线程之间相互独立互不干扰。
exit(0);
}
return 0;
}
testbuf.c
#include <stdio.h>
#include <stdlib.h>
int main()
{
printf("hello");//输出hello，然后换行。
fflush(stdout);
while(1);
}
Testbuf3.c
#include <stdio.h>
int main()
{
fprintf(stdout, "1234", 5);//将内容格式化输出到标准错误、输出流中
fprintf(stderr, "abcd", 4);
}
testpid.c
#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
int main()
{
printf("my pid: %d \n", getpid());
printf("my parent‘s pid: %d \n", getppid());//输出当前进程pid和父进程pid
return 0;
}
Testsystem.c
#include <stdlib.h>
int main ( int argc, char *argv[] )
{
system(argv[1]);//执行shell命令,向dos发送指令.
system(argv[2]);
return EXIT_SUCCESS;
} /* ---------- end of function main ---------- */
Waitedemo1.c
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <unistd.h>
#define DELAY 4
void child_code(int delay)
{
printf("child %d here. will sleep for %d seconds\n", getpid(), delay);
sleep(delay);
printf("child done. about to exit\n");
exit(17);
}
void parent_code(int childpid)
{
int wait_rv=0; /* return value from wait() */
wait_rv = wait(NULL);
printf("done waiting for %d. Wait returned: %d\n",
childpid, wait_rv);
}
int main()
{
int newpid;
printf("before: mypid is %d\n", getpid());
if ( (newpid = fork()) == -1 )
perror("fork");
else if ( newpid == 0 )
child_code(DELAY);
else
parent_code(newpid);
//如果有子进程，则终止子进程，成功返回子进程pid
return 0;
}
#include <stdio.h>
#include <stdlib.h>
Waitdemo2.c
#include <sys/types.h>
#include <sys/wait.h>
#include <unistd.h>
#define DELAY 10
void child_code(int delay)
{
printf("child %d here. will sleep for %d seconds\n", getpid(), delay);
sleep(delay);
printf("child done. about to exit\n");
exit(27);
}
void parent_code(int childpid)
{
int wait_rv;
int child_status;
int high_8, low_7, bit_7;
wait_rv = wait(&child_status);
printf("done waiting for %d. Wait returned: %d\n", childpid, wait_rv);
high_8 = child_status >> 8; /* 1111 1111 0000 0000 */
low_7 = child_status & 0x7F; /* 0000 0000 0111 1111 */
bit_7 = child_status & 0x80; /* 0000 0000 1000 0000 */
printf("status: exit=%d, sig=%d, core=%d\n", high_8, low_7, bit_7);
}
int main()
{
int newpid;
printf("before: mypid is %d\n", getpid());
if ( (newpid = fork()) == -1 )
perror("fork");
else if ( newpid == 0 )
child_code(DELAY);
else
parent_code(newpid);
}//这个比起1来就是多了一个子进程的状态区分，把状态拆分成三块，exit，sig和core
参考：闫佳欣同学的博客
心得：研究了同学解释函数的作用，并且运行了代码，了解运行过程，学习了。
标签：
原文地址：http://www.cnblogs.com/java44/p/5005702.html
