Linux 进程

最新推荐文章于 2022-04-07 13:19:12 发布
最新推荐文章于 2022-04-07 13:19:12 发布
阅读量129 收藏
点赞数
分类专栏： Linux 文章标签： linux
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yorickjun/article/details/117266298
版权

一 环境变量

1 常见环境变量

#/home/ypw/bin:/home/ypw/.local/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/games:/usr/local/games:/snap/bin
PATH 
# /home/ypw
HOME 
# /bin/bash
SHELL 
# xterm-256color
TERM 
# en_US.UTF-8
LANG

2 程序获取环境变量

#include<stdio.h>
//导入存放环境变量的数组
extern char** environ;

int main(){
    //NULL作为哨兵结尾
	for(int i=0 ; environ[i]!=NULL ; i++){
		printf("%s\n",environ[i]);
	}
	return 0;
}

3 函数操作环境变量

  • 函数文档
char *getenv(const char *name);
//overwrite不为0重写
int setenv(const char *name, const char *value, int overwrite); 
int unsetenv(const char *name);

#include<stdio.h>
#include<stdlib.h>
// 获取环境变量，添加环境变量，删除环境变量
int main(){
    //获取环境变量
	const char* name = "VAR";
	char* val = getenv(name);
	printf("%s=%s\n",name,val);
	//添加环境变量
	setenv(name,"hello world",1);
	//获取环境变量
	val = getenv(name);
	printf("%s=%s\n",name,val);
	//删除环境变量
	int ret = unsetenv(name);
	printf("%d\n",ret);
	return 0;
}

二 进程控制

1 fork函数

  • 使用fork创建子进程
#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<sys/types.h>
// 使用fork创建子进程，子进程的fork()返回值为0，父进程的fork()返回值为子进程pid
int main(){
	pid_t pid;
	printf("---before fork---\n");
	pid = fork();
	if(pid == -1){
		perror("fork:");
		exit(1);
	}else if(pid == 0){
		printf("child process: pid:%u,ppid:%u\n",getpid(),getppid());
	}else{
        sleep(1);
		printf("parent process: pid:%u,ppid:%u\n",getpid(),getppid());
	}
	printf("---after fork---\n");
	return 0;
}
  • 使用fork循环创建子进程
#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<sys/types.h>
# 使用fork循环创建子进程
int main(){
	pid_t pid;
	printf("--before fork--\n");
	int i;
	for(i=0 ; i<5 ; i++){
		pid = fork();
		if(pid == -1){
			perror("fork: ");
			exit(1);
		}else if(pid == 0){
             // 避免子进程再创建子进程的子进程，需要跳出循环，表示子进程不再fork
			break;
		}
	}
	// 子进程
	if(i<5){
		sleep(i);
		printf("%dth child process ,pid=%u\n",i+1,getpid());
	}else{ // 父进程
		sleep(i);
		printf("parent process,pid=%u\n",getpid());
	}

	return 0;
}

# result
--before fork--
1th child process ,pid=60180
2th child process ,pid=60181
3th child process ,pid=60182
4th child process ,pid=60183
5th child process ,pid=60184
parent process,pid=60179
  • 进程共享

读时共享写时复制

  • gdb调试带有子进程的程序
# 默认跟踪父进程，在fork()函数调用之前设置，可以修改gdb跟踪的进程
set follow-fork-mode child
set follow-fork-mode parent

2 exec函数族

当进程调用一种exec函数时，该进程的用户空间代码和数据完全被新程序替换，从新程序的启动例程开始执行。调用exec不会创建新进程，所有调用exec前后该进程的id未被改变。

exec函数一旦调用成功即立即执行新的程序，不返回。只有失败才返回，错误值为-1。故通常在exec函数调用后直接调用perror()和exit()，无需if判断

/*
	l(list):命令行参数列表
	p(path):搜索file时，使用path变量
	v(vector):使用命令行参数数组
	e(environment):使用环境变量数组
*/
int execl();
int execlp();
int execle();
int execv();
int execvp();
int execve();
  • execlp函数（加载一个进程，借助PATH环境变量）
#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
// 在子进程中执行ls命令
int main(){
	pid_t pid;
    //创建子进程
	pid = fork();
	if(pid == -1){
		perror("fork");
		exit(1);
	}else if(pid == 0){
        //子进程执行execlp函数
		execlp("ls","ls","-l","-a",NULL);
	}else{
		sleep(1);
		printf("parent\n");
	}
	return 0;
}
  • execl函数 （加载一个进程，通过 路径+函数名 加载）
#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
// 在子进程中执行ls命令
int main(){
	pid_t pid;
    //创建子进程
	pid = fork();
	if(pid == -1){
		perror("fork");
		exit(1);
	}else if(pid == 0){
        //子进程执行execl函数，可以执行自定义的程序
		execl("/bin/ls","ls","-l","-a",NULL);
	}else{
		sleep(1);
		printf("parent\n");
	}
	return 0;
}
  • execlp函数实现将当前系统的进程信息打印到文件中
#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<fcntl.h>
//将当前系统的进程信息打印到文件中
int main(){
    //打开文件，只写，没有创建，有则截断
	int fd = open("ps.out",O_WRONLY|O_CREAT|O_TRUNC,0644);
	if(fd == -1){
		perror("open");
		exit(1);
	}
    //将fd的文件描述符复制到标准输出，标准输出写入到fd指向的文件
	dup2(fd,1);
    //执行ps
	execlp("ps","ps","aux",NULL);
	//成功不返回
    perror("ps");
	exit(1);
	//close(fd);
	return 0;
}

三 回收子进程

1 孤儿进程

孤儿进程是表示父进程先于子进程结束，则子进程成为孤儿进程，子进程的父进程成为init进程，称为init进程领养孤儿进程。

由于我使用的环境是带有图形界面的ubuntu系统，所以最终并不是被我们所熟知的init进程收养，而是被一个名为/sbin/upstart的进程所收养。另外还可以观察到，该进程也是其他系统进程的父进程。

#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
//当父进程死亡后，子进程成为孤儿进程，被1685进程收养
int main(){
	pid_t pid;
	pid = fork();
	if(pid == -1){
		perror("fork");
		exit(1);
	}else if(pid == 0){
		while(1){
			sleep(1);
			printf("child process pid=%u,ppid=%u\n",getpid(),getppid());
		}
	}else{
		sleep(3);
		printf("parent process pid=%u,childPid=%u\n",getpid(),pid);
	}
	return 0;
}

2 僵尸进程

僵尸进程表示当进程终止后，父进程尚未回收，子进程残留资源（PCB）存放在内核中，变为僵尸进程。僵尸进程不能使用kill命令清除，因为kill只是用来终止进程的，而僵尸进程已经终止。

#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>

int main(){
	pid_t pid;
	pid = fork();
	if(pid == -1){
		perror("fork");
		exit(1);
	}else if(pid == 0){
			sleep(3);
			printf("child process pid=%u,ppid=%u\n",getpid(),getppid());
	}else{
		while(1){
			sleep(1);
			printf("parent process pid=%u,childPid=%u\n",getpid(),pid);
		}
	}
	return 0;
}

# result
ypw   62275  0.0  0.0   4352   656 pts/2    S+   19:46   0:00 ./zoombie
ypw   62276  0.0  0.0      0     0 pts/2    Z+   19:46   0:00 [zoombie] <defunct>

3 wait 函数

父进程调用wait函数可以回收子进程终止信息。三个功能：

  • 阻塞等待子进程退出
  • 回收子进程残留资源
  • 获取子进程结束状态（退出原因）
#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<sys/types.h>
#include<sys/wait.h>

int main(){
	
	pid_t pid,wpid;
	pid = fork();
	if(pid == -1){
		perror("fork");
		exit(1);
	}else if(pid == 0){
			sleep(3);
			printf("child process pid=%u,ppid=%u\n",getpid(),getppid());
	}else{
		wpid = wait(NULL); //阻塞，等待子进程结束，回收该僵尸进程，成功返回子进程的pid
		if(wpid == -1){
			perror("wait error");
			exit(1);
		}
		while(1){
			sleep(1);
			printf("parent process pid=%u,childPid=%u\n",getpid(),pid);
		}
	}
	return 0;
}

增强版，可以获取进程的状态信息

WIFEXITED(status):非零，进程正常结束
WEXITSTATUS(status):上面的宏为真，则使用该宏可以获取进程退出状态 （exit/return 的状态）
WIFSIGNALED(status):非零，进程异常终止
WTERMSIG(status):取得使进程终止的那个信号的编号 （例：kill -9 pid 获取到编号为9）

#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<sys/types.h>
#include<sys/wait.h>

int main(){
	
	pid_t pid,wpid;
	int status;
	pid = fork();
	if(pid == -1){
		perror("fork");
		exit(1);
	}else if(pid == 0){
			sleep(30);
			printf("child process pid=%u,ppid=%u\n",getpid(),getppid());
			exit(76); // return 100;
	}else{
		wpid = wait(&status);
		if(WIFEXITED(status)){
			printf("return or exit success: %d\n",WEXITSTATUS(status));
		}
		if(WIFSIGNALED(status)){
			printf("kill by the number: %d\n",WTERMSIG(status));
		}
		if(wpid == -1){
			perror("wait error");
			exit(1);
		}
		while(1){
			sleep(1);
			printf("parent process pid=%u,childPid=%u\n",getpid(),pid);
		}
	}
	return 0;
}

4 waitpid 函数

作用同wait，但可以指定清理的pid进程，可以非阻塞

// 参数：pid：>0 回收指定ID的子进程，-1 回收任意子进程（同wait）
// 返回：0,参数3为宏 WNOHANG，表示子进程正在运行
pid_t waitpid(pid_t pid, int *status, int options);

#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<sys/types.h>
#include<sys/wait.h>

int main(){

	pid_t pid,pid_three,wpid;
	int i,n=5;
	for(i=1 ; i<=n ; i++){
		pid = fork();
		if(pid == -1){
			perror("fork");
			exit(1);
		} else if(pid == 0 ){
			break;
		} else{
			if(i==3){ //当fork第三个进程时候，记录进程号
				pid_three = pid;
			}
		}
	}
	
	if(i == n+1){
		sleep(i);
//		pid_three = waitpid(pid_three,NULL,0); //阻塞回收第三个进程
//		printf("waitpid=%d\n",pid_three);
		do{ //循环回收全部进程
			wpid = waitpid(-1,NULL,WNOHANG); //非阻塞式
			if(wpid>0){
				n--;
			}
		}while(n>0);
		printf("wait finish...\n");
		printf("parent id=%d\n",getpid());
		while(1);
	}else{
		sleep(i);
		printf("child%d id=%d\n",i,getpid());
	}
	return 0;
}

四 进程间通信

1 Pipe管道

//功能：使用pipe实现，父子进程通信，父写数据，子读数据
#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<sys/types.h>
#include<sys/wait.h>
#include<string.h>

void sys_err(const char* str,int errno){
	perror(str);
	exit(errno);
}

int main(){

	int fd[2];
	pid_t pid;
	char str[1024] = "Hello World\n";
	char buf[1024];
	int len;

	if(pipe(fd)<0){ //创建管道 fd[0]读端 fd[1]写端
		sys_err("pipe error",1);
	}
	
	pid = fork(); //创建子进程
	if(pid == -1){
		sys_err("fork error",1);
	}else if(pid > 0){ //父进程
		close(fd[0]); //父关闭读
		write(fd[1],str,strlen(str)); //向管道写数据
		wait(NULL); //回收子进程
		close(fd[1]); 
	}else{ //子进程
		close(fd[1]); //子关闭写
		len = read(fd[0],buf,sizeof(buf)); //从管道读数据
		write(STDOUT_FILENO,buf,len); //将数据写到屏幕
		close(fd[0]);				
	}
	return 0;
}

2 fifo有名管道

# 借助fifo实现非血缘进程间通信
mkfifo myfifo

//扮演写的程序
#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<string.h>
#include<sys/types.h>
#include<sys/stat.h>
#include<fcntl.h>

void sys_err(const char* str,int errno){
	perror(str);
	exit(errno);
}

int main(){
	
	int fd;
	char* str = "Hello Fifo";
	fd = open("myfifo",O_WRONLY); //打开fifo管道
	if(fd == -1 ){
		sys_err("open error",1);
	}
	write(fd,str,strlen(str)); //向管道写数据
	close(fd);
	return 0;
}

//扮演读的程序
#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<string.h>
#include<sys/types.h>
#include<sys/stat.h>
#include<fcntl.h>

void sys_err(const char* str,int errno){
	perror(str);
	exit(errno);
}

int main(){
	
	int fd;
	char buf[1024];
	int len;

	fd = open("myfifo",O_RDONLY); //打开fifo管道
	if(fd == -1 ){
		sys_err("open error",1);
	}
	len = read(fd,buf,sizeof(buf)); //读数据
	write(STDOUT_FILENO,buf,len); 
	close(fd);
	return 0;
}

3 mmap内存共享映射

//借助mmap实现非血缘关系进程的通信
//扮演写的程序
#include<stdio.h>
#include<stdlib.h>
#include<sys/types.h>
#include<sys/stat.h>
#include<fcntl.h>
#include<sys/mman.h>
#include<string.h>
#include<unistd.h>

#define MAPLEN 0x1000

struct Stu{ //定义传输的数据格式为结构体
	int id;
	char name[20];
	char sex;
};

void sys_err(const char* str, int errno){
	perror(str);
	exit(errno);
}

int main(int argc,char* argv[]){

	int fd,i=0;
	struct Stu* mm;

	if(argc < 2){
		printf("./a.out filename");
		exit(1);
	}

	fd = open(argv[1],O_RDWR | O_CREAT, 0777); //有则打开无则创建
	if(fd < 0 ){
		sys_err("open error",1);
	}

	if(lseek(fd,MAPLEN-1,SEEK_SET)<0){ //提供4KB大写的空文件
		sys_err("lseek error",2);
	}
	if(write(fd,"\0",1)<0){ //lseek写入空洞字符后，需要再追加写入一个字符
		sys_err("write error",3);
	}
	//内存共享映射
	mm = (struct Stu*)mmap(NULL,MAPLEN,PROT_READ | PROT_WRITE, MAP_SHARED,fd,0);
	if(mm == MAP_FAILED){ //映射失败
		sys_err("mmap error",4);
	}
	close(fd); //可以关闭文件描述符，已经建立映射故不影响

	while(1){ //循环向共享内存中写数据
		mm->id = i;
		sprintf(mm->name,"stu-%d",i);
		if(i%2==0)
			mm->sex = 'm';
		else
			mm->sex = 'w';
		i++;
		sleep(1);
	}
	munmap(mm,MAPLEN); //解绑映射
	return 0;
}


//扮演读的程序
#include<stdio.h>
#include<stdlib.h>
#include<sys/types.h>
#include<sys/stat.h>
#include<fcntl.h>
#include<sys/mman.h>
#include<string.h>
#include<unistd.h>

#define MAPLEN 0x1000

struct Stu{
	int id;
	char name[20];
	char sex;
};

void sys_err(const char* str, int errno){
	perror(str);
	exit(errno);
}

int main(int argc,char* argv[]){

	int fd,i=0;
	struct Stu* mm;

	if(argc < 2){
		printf("./a.out filename");
		exit(1);
	}

	fd = open(argv[1],O_RDONLY); //只读
	if(fd < 0 ){
		sys_err("open error",1);
	}

	mm = (struct Stu*)mmap(NULL,MAPLEN,PROT_READ , MAP_SHARED,fd,0);
	if(mm == MAP_FAILED){
		sys_err("mmap error",4);
	}
	close(fd);

	while(1){ //循环读取映射共享的数据
		printf("id:%d ",mm->id);
		printf("name:%s ",mm->name);
		printf("sex:%c\n",mm->sex);
		sleep(1);
	}
	munmap(mm,MAPLEN);
	return 0;
}

五 信号

1 kill函数

//使用kill函数模拟系统的kill命令，向目标进程pid发送信号
#include<stdio.h>
#include<stdlib.h>
#include<sys/types.h>
#include<signal.h>
int main(int argc,char* argv[]){
	
	int ret;

	if(argc < 3){
		printf("./a.out signalNumber pid");
		exit(1);
	}
	
	ret = kill((pid_t)atoi(argv[2]),atoi(argv[1])); //发送信号，pid，signal
	if(ret < 0 ){
		perror("kill");
		exit(1);
	}
	return 0;
}

2 alarm函数

//定时器，运行规定的时间后自动终止进程
#include<stdio.h>
#include<unistd.h>

int main(){

	int count;

	alarm(1); //定时1s
	for(count = 0 ; 1 ; count++){
		printf("count=%d\n",count);
	}
	return 0;
}

3 信号集处理函数

//通过更改屏蔽字，屏蔽相应的信号
#include<stdio.h>
#include<signal.h>
#include<unistd.h>

void printsigset(const sigset_t* set){ //打印当前未决信号集
	int i;
	for(i=1 ; i<32 ; i++){
		if(sigismember(set,i)==1){ //判断i信号是否在未决信号集上激活
			putchar('1');
		}else{
			putchar('0');
		}
	}
	puts("");
}

int main(){
	
	sigset_t s,p;
	int i=0;	
	sigemptyset(&s); //置零
	sigaddset(&s,SIGINT); //SIGINT信号阻塞置1
	sigaddset(&s,SIGQUIT); //SIGQUIT信号阻塞置1
	sigprocmask(SIG_BLOCK,&s,NULL); //使用s来更改当前进程的信号屏蔽字

	while(1){
		sigpending(&p); //获取未决信号集
		printsigset(&p);
		sleep(1);
		if(i == 10){
			sigdelset(&s,SIGQUIT); //删除阻塞信号集的SIGQUIT信号，置零
			sigprocmask(SIG_UNBLOCK,&s,NULL); //将SIGINT信号置零放行SIGINT未决信号
		}
		i++;
	}	

	return 0;
}

4 信号捕捉

  • 给SIGINT信号设置捕捉函数
#include<stdio.h>
#include<signal.h>
#include<unistd.h>

void do_sig(int num){ //捕捉函数
	printf("I am do_sig function\n");
	printf("num=%d\n",num);
}

int main(){

	struct sigaction act; //定义捕捉的结构体

	act.sa_handler = do_sig; //添加捕捉函数
	sigemptyset(&act.sa_mask); //临时信号屏蔽字
	act.sa_flags = 0; //选定旧版本捕捉函数

	sigaction(SIGINT,&act,NULL); //给SIGINT信号添加捕捉函数

	while(1){
		printf("=============\n");
		sleep(1);
	}

	return 0;
}
  • 验证临时信号屏蔽字
    • 当在执行捕捉函数时，再发送SIGINT信号，则会只改变未决信号集置1，等待捕捉函数执行完毕，临时屏蔽字解除后，会被激活
    • 当在执行捕捉函数时，由于设置了对SIGQUIT信号的屏蔽，故执行阶段无法响应SIGQUIT信号
#include<stdio.h>
#include<signal.h>
#include<unistd.h>

void do_sig(int num){
	int n=5;
	printf("I am do_sig function\n");
	while(n--){ //添加循环，增加捕捉函数的执行时间
		printf("num=%d\n",num);
		sleep(1);
	}
}

int main(){

	struct sigaction act;

	//act.sa_handler = SIG_DFL; //默认
	//act.sa_handler = SIG_IGN; //忽略
	act.sa_handler = do_sig;
	sigemptyset(&act.sa_mask);
	sigaddset(&act.sa_mask,SIGQUIT); //对SIGQUIT信号临时屏蔽
	act.sa_flags = 0;

	sigaction(SIGINT,&act,NULL);

	while(1){
		printf("=============\n");
		sleep(1);
	}

	return 0;
}

5 signal 函数

//捕捉SIGUSR1信号
#include<stdio.h>
#include<signal.h>
#include<unistd.h>

void do_sig(int num){
	printf("num=%d\n",num);
}

int main(){
	
	signal(SIGUSR1,do_sig);
	
	while(1){
		printf("***********\n");
		sleep(1);
	}
	
	return 0;
}

6 可重入函数

//将不可重入函数strtok更改为可重入函数strtok_r，用于对字符串的切割
#include<stdio.h>
#include<string.h>

int main(){
	
	char buf[] = "Hello Tom Jerry Smith";
	char *save = buf, *p;

	while((p = strtok_r(save," ",&save))!=NULL){
		printf("%s\n",p);
	}

	return 0;
}

7 时序京态

//自己实现sleep函数，需要考虑时序静态的发生，在alarm前，需要设置信号屏蔽字来屏蔽SIGALRM信号，之后再解除SIGALRM信号的阻塞，通过sigsuspend函数原子化操作实现信号唤醒挂起
#include<stdio.h>
#include<signal.h>
#include<unistd.h>

void do_sig(int num){
	//nothing to do
}

unsigned int mysleep(unsigned int nsecs){
	struct sigaction act,oldact;
	sigset_t newmask,oldmask,susmask;
	unsigned int unslept;
	//给SIGALRM信号设置捕捉函数
	act.sa_handler = do_sig; 
	sigemptyset(&act.sa_mask);
	act.sa_flags = 0;
	sigaction(SIGALRM,&act,&oldact);
	//设置信号屏蔽字，屏蔽SIGALRM信号
	sigemptyset(&newmask);
	sigaddset(&newmask,SIGALRM);
	sigprocmask(SIG_BLOCK,&newmask,&oldmask);
	//定时器
	alarm(nsecs);
	//解除SIGALRM信号的屏蔽
	susmask = oldmask;
	sigdelset(&susmask,SIGALRM);
	sigsuspend(&susmask); //挂起等待SIGALRM信号幻醒

	unslept = alarm(0);
	sigaction(SIGALRM,&oldact,NULL); //恢复SIGALRM信号默认响应状态
	sigprocmask(SIG_SETMASK,&oldmask,NULL); //恢复信号屏蔽字
	return unslept;
}


int main(){
	while(1){
		mysleep(2);
		printf("Two seconds passed\n");
	}

	return 0;
}

SIGCHLD信号处理

//通过对信号的处理实现清理僵尸进程
#include<stdio.h>
#include<stdlib.h>
#include<signal.h>
#include<sys/types.h>
#include<sys/wait.h>
#include<unistd.h>


void sys_err(const char* str,int errno){
	perror(str);
	exit(errno);
}
//捕捉函数
void do_sig_child(int num){
	int status;
	pid_t pid;
	while((pid = waitpid(0,&status,WNOHANG))>0){ //waitpid 处理一个僵尸进程
		if(WIFEXITED(status)){ //正常退出
			printf("child %d exit %d\n",pid,WEXITSTATUS(status));
		}else if(WIFSIGNALED(status)){ //异常退出
			printf("childe %d cancel signal %d\n",pid,WTERMSIG(status));
		}
	}
}

int main(){

	pid_t pid;
	int i;
	for(i=0 ; i<10 ; i++){ //fork 10个子进程
		pid = fork();
		if(pid < 0) {
			sys_err("fork",1);
		}else if(pid == 0 ){
			break;
		}
	}

	if(pid == 0 ){ //子进程
		int n = 15;
		while(n--){
			sleep(1);
			printf("child pid %d\n",getpid());
		}
		return i; //返回退出的值
	}else if(pid > 0){ //父进程
         //设置捕捉SIGCHLD信号
		struct sigaction act;
		act.sa_handler = do_sig_child;
		sigemptyset(&act.sa_mask);
		act.sa_flags = 0;
		sigaction(SIGCHLD,&act,NULL);
		while(1){
			sleep(1);
			printf("parent pid %d\n",getpid());
		}
	}

	return 0;
}

六 进程间关系

1 进程组

//获取进程组gid的几种方式
#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>

int main(){

	pid_t pid;

	if((pid = fork())<0){
		perror("fork");
		exit(1);
	}else if(pid == 0) {
		printf("child pid:%d\n",getpid());
		printf("child pgid:%d\n",getpgrp()); //获取组id
		printf("child pgid:%d\n",getpgid(0));//获取组id
		printf("child pgid:%d\n",getpgid(getpid()));//获取组id
	}else{	
		sleep(3);
		printf("parent pid:%d\n",getpid());
		printf("parent pgid:%d\n",getpgid(0));//获取组id
	}
	return 0;
}

//改变进程的进程组id
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
int main(void)
{
    pid_t pid;
    if ((pid = fork()) < 0) {
        perror("fork");
        exit(1);
    } else if (pid == 0) {
        printf("child process PID is %d\n",getpid());
        printf("Group ID of child is %d\n",getpgid(0)); // 返回组id
        sleep(5);
        printf("Group ID of child is changed to %d\n",getpgid(0));
        exit(0);
    }
    sleep(1);
    setpgid(pid,pid); // 父进程改变子进程的组id为子进程本身
    sleep(5);
    printf("parent process PID is %d\n",getpid());
    printf("parent of parent process PID is %d\n",getppid());
    printf("Group ID of parent is %d\n",getpgid(0));
    setpgid(getpid(),getppid()); // 改变父进程的组id为父进程的父进程
    printf("Group ID of parent is changed to %d\n",getpgid(0));
    return 0;
}

2 会话设置

//子进程创建独立的会话，关闭当前终端不影响该会话的正常运行
#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>

int main(){

	pid_t pid;

	if((pid = fork())<0){
		perror("fork");
		exit(1);
	}else if(pid == 0 ){
		printf("child pid:%d\n",getpid());
		printf("child pgid:%d\n",getpgid(0));
		printf("child sid:%d\n",getsid(0));
		sleep(10);
		setsid(); //子进程非组长进程，故其成为新会话首进程，且成为组长进程。该进程组id即为会话进程
		printf("Changed\n");
		printf("child pid:%d\n",getpid());
		printf("child pgid:%d\n",getpgid(0));
		printf("child sid:%d\n",getsid(0));
		sleep(20);	
		exit(0);
	}

	return 0;
}

七 线程

1 pthread_create 创建线程

//创建线程，打印一些线程信息
#include<stdio.h>
#include<pthread.h>
#include<stdlib.h>
#include<unistd.h>

void* do_thread_func(void* arg){
	int* p = (int*)arg;
	printf("thread running...\n");
	printf("thread pid:%d\n",getpid());
	printf("thread id:%x\n",(unsigned int)pthread_self());
	printf("thread arg:%d\n",*p);
}

int main(){
	
	pthread_t tid;
	int arg = 233;	
	
	pthread_create(&tid,NULL,do_thread_func,(void *)&arg); //创建线程
	
	printf("main pid:%d\n",getpid());
	printf("main thread id:%x\n",(unsigned int)pthread_self()); //main线程的tid
	printf("main child thread id:%x\n",(unsigned int)tid); //新线程的tid
	sleep(1);	
	return 0;
}

2 pthread_join 回收线程

//回收线程
#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<pthread.h>

void* do_thread_func1(void* arg){
	printf("thread 1 running...\n");
	return (void*)1;
}

void* do_thread_func2(void* arg){
	printf("thread 2 running...\n");
	pthread_exit((void*)2);
}

void* do_thread_func3(void* arg){
	while(1){
		printf("thread 3 writing...\n");
		sleep(1);
	}
}

int main(){

	pthread_t tid;
	void* retval;

	pthread_create(&tid,NULL,do_thread_func1,NULL);
	pthread_join(tid,&retval);
	printf("thread 1 exit code:%d\n",(int*)retval);

	pthread_create(&tid,NULL,do_thread_func2,NULL);
	pthread_join(tid,&retval);	
	printf("thread 2 exit code:%d\n",(int*)retval);
	
	pthread_create(&tid,NULL,do_thread_func3,NULL);
	sleep(3);	
	pthread_cancel(tid);
	pthread_join(tid,&retval);
	printf("thread 3 exit code:%d\n",(int*)retval);

	return 0;
}

3 pthread_detached 分离线程

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<pthread.h>
#include<unistd.h>

void* do_thread_func(void* arg){
	int n=3;
	while(n--){
		printf("thread running...\n");
		sleep(1);
	}
	return (void*)233;
}

int main(){

	pthread_t tid;
	int err;
	void *retval;
		
	pthread_create(&tid,NULL,do_thread_func,NULL);
	pthread_detach(tid); //分离线程，无法使用join回收，无法接收返回的参数
	while(1){
		err = pthread_join(tid,&retval);
		if(err != 0 ){
			printf("thread %s\n",strerror(err));
		}else{
			printf("thread exit code %d\n",(int)retval);
		}
		sleep(1);	
	}

	return 0;
}

4 设置线程属性

#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<pthread.h>
#include<string.h>

#define SIZE 0x100000

void* do_thread_func(void* arg){
	int n = 3;
	while(n--){
//		printf("Hello thread\n");
		sleep(1);
	}
}

int main(){

	pthread_t tid;
	pthread_attr_t attr;
	int err,detachstate,i=1;
	void* stackaddr;
	size_t stacksize;
	
	pthread_attr_init(&attr);

	pthread_attr_getstack(&attr,&stackaddr,&stacksize);
	printf("origin stackaddr:%p\n",stackaddr);
	printf("origin stacksize:%d\n",(int)stacksize);
	
	pthread_attr_getdetachstate(&attr,&detachstate);
	if(detachstate == PTHREAD_CREATE_DETACHED){
		printf("thread detached\n");
	}else if(detachstate == PTHREAD_CREATE_JOINABLE){
		printf("thread joinable\n");
	}
	
	pthread_attr_setdetachstate(&attr,PTHREAD_CREATE_DETACHED);
	while(1){
		stackaddr = malloc(SIZE);
		if(stackaddr == NULL){
			perror("malloc");
			exit(1);
		}
		stacksize = SIZE;
		pthread_attr_setstack(&attr,stackaddr,stacksize);
		err = pthread_create(&tid,&attr,do_thread_func,NULL);
		if(err != 0 ){
			printf("thread:%s\n",strerror(err));
			exit(1);
		}
		printf("%d\n",i++);
	}
	
	pthread_attr_destroy(&attr);
	return 0;
}

八 线程同步

1 互斥量

//通过互斥量mutex实现对临界区资源count的加锁访问，比卖你出现并发问题
#include<stdio.h>
#include<pthread.h>

#define LOOPNUM 5000
int count;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER; //互斥量静态初始化

void* do_thread_func(void* arg){
	int i,val;
	for(i=0 ; i<LOOPNUM ; i++){
		pthread_mutex_lock(&mutex); //加锁访问临界资源
		val = count;
		printf("%x:%d\n",(unsigned int)pthread_self(),val+1);
		count = val+1;
		pthread_mutex_unlock(&mutex); //解锁临界资源
	}
	return NULL;
}

int main(){

	pthread_t tid1,tid2;
	
	pthread_create(&tid1,NULL,do_thread_func,NULL);
	pthread_create(&tid2,NULL,do_thread_func,NULL);

	pthread_join(tid1,NULL);
	pthread_join(tid2,NULL);

	return 0;
}

2 死锁

//线程一拥有A锁，请求获得B锁；线程二拥有B锁，请求获得A锁
#include<stdio.h>
#include<pthread.h>
#include<unistd.h>

char* str = "Hello World";
pthread_mutex_t lock1 = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t lock2 = PTHREAD_MUTEX_INITIALIZER;

void* do_thread_func1(void* arg){
	pthread_mutex_lock(&lock1);
	sleep(1);
	pthread_mutex_lock(&lock2);
	printf("%s\n",str);
	pthread_mutex_unlock(&lock2);
	pthread_mutex_unlock(&lock1);
	return NULL;
}

void* do_thread_func2(void* arg){
	pthread_mutex_lock(&lock2);
	sleep(2);
	pthread_mutex_lock(&lock1);
	printf("%s\n",str);
	pthread_mutex_unlock(&lock1);
	pthread_mutex_unlock(&lock2);
	return NULL;
}

int main(){

	pthread_t tid1,tid2;

	pthread_create(&tid1,NULL,do_thread_func1,NULL);
	pthread_create(&tid2,NULL,do_thread_func2,NULL);

	pthread_join(tid1,NULL);
	pthread_join(tid2,NULL);
	return 0;
}

3 读写锁

//3个线程不定时写同一全局资源，5个线程不定时读同一全局资源
#include<stdio.h>
#include<pthread.h>
#include<unistd.h>

int count;
pthread_rwlock_t lock = PTHREAD_RWLOCK_INITIALIZER;

void* do_write_func(void* arg){
	int t;
	while(1){
		usleep(100);
		pthread_rwlock_wrlock(&lock);
		t = count;
		usleep(100);
		printf("%x write: counter=%d,new counter=%d\n",(unsigned int)pthread_self(),t,++count);
		pthread_rwlock_unlock(&lock);
		usleep(100);
	}
	return NULL;
}

void* do_read_func(void* arg){
	while(1){
		pthread_rwlock_rdlock(&lock);
		printf("%x read: counter=%d\n",(unsigned int)pthread_self(),count);
		pthread_rwlock_unlock(&lock);
		usleep(100);
	}
	return NULL;
}

int main(){
	pthread_t tid[8];
	int i;
	for(i=0 ; i<3 ; i++){
		pthread_create(&tid[i],NULL,do_write_func,NULL);
	}
	for(i=0 ; i<5 ; i++){
		pthread_create(&tid[i+3],NULL,do_read_func,NULL);
	}
	for(i=0 ; i<8 ; i++){
		pthread_join(tid[i],NULL);
	}
	return 0;
}

4 条件变量

//生产者-消费者模型
	//pthread_cond_wait前要先加锁
    //pthread_cond_wait内部会解锁，然后等待条件变量被其它线程激活
    //pthread_cond_wait被激活后会再自动加锁
#include<stdio.h>
#include<stdlib.h>
#include<pthread.h>
#include<unistd.h>

struct msg{
	int num;
	struct msg* next;
};

struct msg* head = NULL;
pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t has_product = PTHREAD_COND_INITIALIZER;

void* producer(void* arg){
	struct msg* mp;
	while(1){
		mp = (struct msg*)malloc(sizeof(struct msg));
		mp->num = rand()%1000 + 1;
		printf("produce %d\n",mp->num);
		pthread_mutex_lock(&lock);
		mp->next = head;
		head = mp;
		pthread_mutex_unlock(&lock);
		pthread_cond_signal(&has_product);
		sleep(rand()%5);
	}
}

void* consumer(void* arg){
	struct msg* mp;
	while(1){
		pthread_mutex_lock(&lock);
		while(head == NULL){
			pthread_cond_wait(&has_product,&lock);
		}
		mp = head;
		head = mp->next;
		pthread_mutex_unlock(&lock);
		printf("consume %d\n",mp->num);
		free(mp);
		sleep(rand()%5);
	}
}

int main(){

	pthread_t ptid,ctid;
	srand(time(NULL));
	pthread_create(&ptid,NULL,producer,NULL);
	pthread_create(&ctid,NULL,consumer,NULL);

	pthread_join(ptid,NULL);
	pthread_join(ctid,NULL);
	return 0;
}

5 信号量

//通过信号量的方式实现生产者和消费者模型
#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<semaphore.h>
#include<pthread.h>

#define NUM 5
sem_t blank_n,product_n; //定义两个信号量
int queue[NUM]; //资源

void* producer(void* arg){
	int p=0;
	while(1){
		sem_wait(&blank_n); //消耗一个blank_n信号量
		queue[p] = rand()%1000 + 1;
		printf("produce %d\n",queue[p]);
		sem_post(&product_n); //归还一个product_n信号量
		p = (p+1)%NUM;
		sleep(rand()%3);
	}
	return NULL;
}

void* consumer(void* arg){
	int p=0;
	while(1){
		sem_wait(&product_n); //消耗一个product_n信号量
		printf("consume %d\n",queue[p]);
		sem_post(&blank_n); //归还一个blank_n信号量
		p = (p+1)%NUM;
		sleep(rand()%3);
	}
	return NULL;
}

int main(){

	srand(time(NULL));
	pthread_t ptid,ctid;
	
	sem_init(&blank_n,0,NUM);
	sem_init(&product_n,0,0);

	pthread_create(&ptid,NULL,producer,NULL);
	pthread_create(&ctid,NULL,consumer,NULL);

	pthread_join(ptid,NULL);
	pthread_join(ctid,NULL);
	
	sem_destroy(&blank_n);
	sem_destroy(&product_n);
	return 0;
}

6 进程间锁-进程间pthread_mutex

#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<sys/types.h>
#include<sys/stat.h>
#include<fcntl.h>
#include<sys/mman.h>
#include<pthread.h>
#include<string.h>
#include<sys/wait.h>

struct mt{ //控制的进程间共享资源
	int num;
	pthread_mutexattr_t attr;
	pthread_mutex_t mutex;
};

int main(){

	int fd,i;
	pid_t pid;
	struct mt* mm;

	fd = open("my_test",O_RDWR|O_CREAT,0777); //进程间共享数据基于的文件
	ftruncate(fd,sizeof(*mm)); //填入空洞值
	mm = (struct mt*) mmap(NULL,sizeof(*mm),PROT_READ|PROT_WRITE,MAP_SHARED,fd,0); //映射
	close(fd);
	memset(mm,0,sizeof(*mm)); //清零
	pthread_mutexattr_init(&mm->attr); //pthread的属性设置，设置为进程锁
	pthread_mutexattr_setpshared(&mm->attr,PTHREAD_PROCESS_SHARED);
	pthread_mutex_init(&mm->mutex,&mm->attr); //lock为进程锁

	pid = fork(); //fork子进程
	if(pid == 0){ //子进程
		for(i=0 ;i<10 ;i++){
			pthread_mutex_lock(&mm->mutex); //上锁访问进程共享资源
			(mm->num)++;
			printf("num++ %d\n",mm->num);
			pthread_mutex_unlock(&mm->mutex);
			sleep(1);
		}
	}else if(pid > 0 ){ //父进程
		for(i=0 ; i<10 ; i++){
			pthread_mutex_lock(&mm->mutex);//上锁访问进程共享资源
			mm->num += 2;
			printf("num+=2 %d\n",mm->num);
			pthread_mutex_unlock(&mm->mutex);
			sleep(1);
		}
		wait(NULL);
	}

	pthread_mutex_destroy(&mm->mutex); //销毁锁
	pthread_mutexattr_destroy(&mm->attr); //销毁属性
	munmap(mm,sizeof(*mm)); //解除映射绑定
	unlink("my_test"); //清除临时文件
	
	return 0;
}

7 进程间锁-文件锁

#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<sys/types.h>
#include<sys/stat.h>
#include<fcntl.h>

int main(int argc,char* argv[]){
	int fd;
	struct flock f_lock;
	if(argc < 2){
		printf("./a.out filename\n");	
		exit(1);
	}

	fd = open(argv[1],O_RDWR);
	f_lock.l_type = F_RDLCK;
	f_lock.l_whence = SEEK_SET;
	f_lock.l_start = 0;
	f_lock.l_len = 0;

	fcntl(fd,F_SETLKW,&f_lock);
	printf("get flock\n");
	sleep(5);
	f_lock.l_type = F_UNLCK;
	fcntl(fd,F_SETLKW,&f_lock);
	printf("un flock\n");
	close(fd);
	return 0;
}
攻城老湿
关注
专栏目录
关于在linux下出现stdio.h文件不存在问题的解决方法
01-09
出现stdio.h文件找不到的问题，使用如下命令： root@chenxiaojian:/etc/apt# apt-get install libc6-dev 这个时候按道理能够成功解决，但是却出现如下错误： root@chenxiaojian:/etc/apt# apt-get install libc6-dev 正在读取软件包列表... 完成 正在分析软件包的依赖关系树 正在读取状态信息... 完成 有一些软件包无法被安装。如果您用的是 unstable 发行版，这也许是 因为系统无法达到您要求的状态造成的。该版本中可能会有一些您需要的软件 包尚未被创建或是它们已被从新到(Incomin
linux C编程随笔
weixin_41884844的博客
03-31 233
设置终端字体 \033[背景颜色号;字体颜色号m字符串\033[0m 1 #include<stdio.h> 2 main(){ 3 printf("\033[30;37mhello world\033[0m"); 4 } 前景色 颜色 代码 黑色前景 30 红色前景 31 绿色前景 32 棕色前景 33 蓝色前景 ...
【Linux】进程详解一：进程概念
_zhy_cq
09-15 7763
【Linux】进程详解（一） 文章目录【Linux】进程详解（一）操作系统如何进行有效管理？初识进程和PCB1.基本概念2.描述进程-进程控制块（PCB）3.1 task_struct3.组织进程4.查看进程5.创建进程-fork()6.进程状态详解6.1 查看进程的状态6.2 不同的进程状态6.3 孤儿进程6.4 僵尸进程6.5 进程状态的转化 前言 在上一讲 认识冯诺依曼体系&&初识LinuxOS 中已经学到了计算机的整体的体系结构和操作系统在计算机中起到的重要作用，今天我们就来学习一下
fork的使用
瞎子my的博客
05-24 923
在牛客做题时遇到了这样一个问题： int main(){fork()||fork();}共创建几个进程：_____ 回想之前一直在这里跌倒从来没有爬起来过的经历，痛定思痛，来好好的思考了一下fork()函数的使用 fork函数初识 在linux中fork函数是非常重要的函数，它从已经存在的进程中创建一个新进程。新进程为子进程，而原进程为父进程。 #include <unistd.h&gt...
进程控制程序设计
weixin_34313182的博客
04-02 126
fork()：创建一个新进程#include <unistd.h>pid_t fork(void)返回值:子进程中返回0,父进程中返回子进程ID,出错返回-1。fork()函数用于从一个已存在进程中创建一个新进程,新进程称为子进程,原进程称为父进程,父子进程分别有各自的返回值,其中父进程的返回值是子进程的进程号,而子进程则返回0。使用fork函数得到的子进程是父进程的一个复制品,它从父...
Linux进程的睡眠和唤醒
07-14
1 Linux进程的睡眠和唤醒 在Linux中，仅等待CPU时间的进程称为就绪进程，它们被放置在一个运行队列中，一个就绪进程的状 态标志位为TASK_RUNNING。一旦一个运行中的进程时间片用完， Linux 内核的调度器会剥夺这个...
东南大学操作系统课程设计——Linux进程管理及其扩展
07-03
此资源包含完整实验报告（加上你的学号姓名即可提交）
Linux进程间通讯视频教程
06-29
本教程通过6个视频，深入浅出地讲解了Linux进程间通信的关键概念和技术。 首先，我们来了解一下什么是进程间通信。在Linux系统中，进程是程序的一次执行实例，每个进程都有自己的独立内存空间，因此它们之间的数据...
Linux进程调度器的设计--Linux进程的管理与调度(十七） - 嵌入式Linux中文站1
08-03
Linux进程调度器的设计是操作系统核心中的重要组成部分，其主要任务是高效、公平地分配CPU时间给系统中的各个进程，以确保系统的响应速度和整体性能。本文将深入探讨Linux进程调度器的基本原理、进程分类及其对应的...
浅谈Linux进程间通信方式及优缺点
01-11
当一个进程创建了一个管道,并调用fork创建自己的一个子进程后,父进程关闭读管道端,子进程关闭写管道端,这样提供了两个进程之间数据流动的一种方式。 有名管道也是一种半双工的通信方式,但是它允许无亲缘关系进程间...
简单掌握Linux系统中fork()函数创建子进程的用法
09-02
fork()函数只能在类Unix系统下使用,因为需要引入unistd头文件,这里我们就来简单掌握Linux系统中fork()函数创建子进程的用法,需要的朋友可以参考下
创建进程-fork函数
yqy_yangqingyu的博客
09-13 314
最近，我在Linux中学到了一个神奇的函数，名为fork()函数，它的作用是创建进程。它的神奇之处在于调用fork()函数时，系统会创建一个与原来进程几乎完全相同的进程，大致的意思就是两个进程可以做完全相同的事，但如果初始参数或者传入的变量不同，两个进程也可以做不同的事  。就相当于是克隆了一个自己。      先来看一个例子             大家一定都很好奇结果是什么？那么结果到
实验一 进程管理
热门推荐
weixin_45788387的博客
10-17 2万+
实验一 进程创建 一、实验目的 加深对进程概念的理解，进一步认识并发执行的实质 掌握Linux操作系统的进程创建和终止操作 掌握在Linux系统中创建子进程后并加载新映像的操作。 二、实验内容 （1）编写一个C程序，使用系统调用fork( )创建一个子进程。要求：①在子进程中分别输出当前进程为子进程的提示、当前进程的PID和父进程的PID、根据用户输入确定当前进程的返回值、退出提示等信息。②在父进程中分别输出：当前进程为父进程的提示、当前进程的PID和子进程的PID、等待子进程退出后获得的返回值、退出提
Linux 文件系统剖析
风之去向
03-06 544
基本的文件系统体系结构Linux 文件系统体系结构是一个对复杂系统进行抽象化的有趣例子。通过使用一组通用的 API 函数，Linux 可以在许多种存储设备上支持许多种文件系统。例如，read 函数调用可以从指定的文件描述符读取一定数量的字节。read 函数不了解文件系统的类型，比如 ext3 或 NFS。它也不了解文件系统所在的存储媒体，比如 AT Attachment Packet Inte
在linux内核编程 不能include <stdio.h>的原因
07-21 4209
不是内核的库。在用户态的，而我们所在内核态。 内核调用的函数是编译进内核的； 应用层调用的是应用层的库； 两者对应的头文件目录不一致，不能搞混了，不然即使函数同名，运行也会出错。 另外，内核一般大小要求，不可能把一个2M的C库给链接在一起。
linux实验三 进程创建
weixin_53257036的博客
04-07 3020
（一）操作实验任务 使用ls命令查看文件的权限 使用chown修改文件的所属权 （实现创建用户，以及Test.txt文件，并用sudo赋予管理员权限，其含意思是test文件的所属给user0用户） 使用chmod 修改文件的访问权限 采用字符设定法，添...
java fork子进程_Linux 创建子进程执行任务
weixin_34718952的博客
02-24 706
Linux 操作系统紧紧依赖进程创建来满足用户的需求。例如，只要用户输入一条命令，shell 进程就创建一个新进程，新进程运行 shell 的另一个拷贝并执行用户输入的命令。Linux 系统中通过 fork/vfork 系统调用来创建新进程。本文将介绍如何使用 fork/vfork 系统调用来创建新进程并使用 exec 族函数在新进程中执行任务。fork 系统调用要创建一个进程，最基本的系统调用是...
GitHub 的 Fork 是什么意思？
十年砍柴的博客
06-22 1万+
相当于你在原项目的主分支上又建立了一个分支，你可以在该分支上任意修改，如果想将你的修改合并到原项目中时，可以pull request，这样原项目的作者就可以将你修改的东西合并到原项目的主分支上去，这样你就为开源项目贡献了代码，开源项目就会在大家共同的努力下不断壮大和完善 作者：李博洋 链接：https://www.zhihu.com/question/20431718/answer/1
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

攻城老湿

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值