进程与线程

已于 2024-03-25 09:49:52 修改
阅读量893 收藏 23
点赞数 21
分类专栏： 进程与线程 文章标签： linux
于 2024-03-14 21:52:28 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_79561199/article/details/134168498
版权

目   录

一、进程的定义

（1）Tip:进程和程序的区别：

（2）进程是程序执行和资源(内存)管理的最小单位

二、进程的类型

三、进程运行的状态

​四、进程的执行模式

五、进程相关的操作（系统调用）

（1）创建进程

​案例1：

案例2：

案例3：

（2）两种异常进程

1、孤儿进程

2、僵尸进程

（3）进程退出

（4）进程阻塞（回收子进程，可以避免僵尸进程）

六、进程的分类之-守护进程

守护进程创建步骤：

七、进程间通信

通信方式

通信的三种模式

（一）无名管道

1.无名管道的相关信息

2.案例：

（二）有名管道

1.有名管道的相关概念

2.有名管道的创建

案例1：

（三）信号

（四）IPC对象

（五）共享内存

（六）消息队列

（七）信号灯

二、线程

* 同一时刻有且只能有一个进程在运行！（针对于单核处理机环境下）

* 双核环境下可以同时有两个进程处于运行态！

一、进程的定义

进程是程序的一次 动态 执行过程

（1）Tip:进程和程序的区别：

程序是 静态的， 它是一些保存在磁盘上的指令的有序集合，没有任何执行的概念
进程是 动态的， 它是程序执行的过程，包括 创建、调度和消亡

（2）进程是程序执行和资源(内存)管理的最小单位

原因：因为每一个进程都有一个0~4G的虚拟内存

二、进程的类型

三、进程运行的状态

进程的运行状态
 
进程的状态之间的转化
 
关于taskstruct结构体：（即进程的相关信息的结构体）

四、进程的执行模式

五、进程相关的操作（系统调用）

同一时刻有且只能有一个进程在运行！（针对于单核处理机环境下）

双核环境下可以同时有两个进程处于运行态！

（1）创建进程

案例1：

#include<stdio.h>
#include<unistd.h>
int main(int argc, const char *argv[])
{
	pid_t pid =fork();
	//报错
	if(pid<0)
	{
		perror("fork error");
	}
	//父进程
	else if(pid>0)
	{
		while(1)
		{
			printf("i am parent\n");
			sleep(1);
		}
	}
	//子进程
	else
	{
		while(1)
		{
			printf("i am child\n");
			sleep(0.5);
		}
	}
	return 0;
}

运行结果 ：

* fork创建子进程后，会出现子进程和父进程争夺资源的情况，谁先运行是不确定的

案例2：

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

int main(int argc, const char *argv[])
{
	//创建子进程
	printf("111111");
	pid_t pid =fork();
	if(pid<0)
	{
		perror("fork error");
	}
	else if(pid>0)
	{
		//父进程
		while(1)
		{
			printf("i am parent\n");
			sleep(1);
		}
	}
	else 
	{
		while(1)
		{
			printf("i am child\n");
			sleep(1);
		}
	}
	return 0;
}

运行结果：

linux@ubuntu:~/jincheng$ ./a.out
111111i am parent
111111i am child
i am parent
i am child
i am parent
i am child
i am parent
i am child
i am parent
i am child
i am parent

解释：出现两次111111的原因：

  • printf（“1111111”）没有换行符，首先存储在缓冲区；
  • 父进程和子进程中的printf有换行符，缓冲区遇到换行符会打印出来；fork之后，子进程会连同父进程的缓冲区一块拷贝过来，所以出现两次打印

案例3：

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

int main(int argc, const char *argv[])
{
	//创建子进程
	pid_t pid =fork();
	if(pid<0)
	{
		perror("fork error");
	}
	else if(pid>0)
	{
		//父进程
		
		{
			printf("i am parent\n");
		}
	}
	else 
	{
		sleep(3);
		{
			printf("i am child\n");
			sleep(1);
		}
	}
	printf("222222222\n");
	while(1);	
	return 0;
}

运行结果：

linux@ubuntu:~/jincheng$ ./a.out
i am parent
222222222
i am child
222222222

结论：同一时刻只能有一个进程。所以parent打印完到打印22222；接着child打印完到22222

（2）两种异常进程

1、孤儿进程

概念：

父进程先于子进程退出，子进程会被systemd收养(ubuntu16.04之前init收养)，变为后台进程

案例：

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

int main(int argc, const char *argv[])
{
	//创建子进程
	pid_t pid =fork();
	if(pid<0)
	{
		perror("fork error");
	}
	else if(pid>0)
	{
		//父进程
		
		{
			printf("i am parent\n");
		}
	}
	else 
	{
		sleep(3);
		printf("i am child\n");
		while(1);
		
	}
	return 0;
}

运行结果：

./a.out

linux@ubuntu:~/jincheng$ ./a.out
i am parent

ps -axj

2、僵尸进程

概念：子进程先退出，父进程没有回收子进程的资源（task_struct结构体）,子进程就变成僵尸进程

注意：父进程没有退出，子进程就会一直保持僵死状态，直到父进程退出，子进程会被systemd回收

案例：

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

int main(int argc, const char *argv[])
{
	//创建子进程
	pid_t pid =fork();
	if(pid<0)
	{
		perror("fork error");
	}
	else if(pid>0)
	{
		//父进程
		
		{
			sleep(1);
			printf("i am parent\n");
			while(1);
		}
	}
	else 
	{
		printf("i am child\n");
	}
	return 0;
}

运行结果：

linux@ubuntu:~/jincheng$ ./a.out
i am child
i am parent

tip:

图1-孤儿进程

图2-僵尸进程

（3）进程退出

案例：

#include<sys/types.h>
#include<unistd.h>
#include<stdio.h>
#include<stdlib.h>
int main(int argc, const char *argv[])
{
	//创建子进程
	pid_t pid =fork();
	if(pid<0)
	{
		perror("fork error");
	}
		//父进程
	else if(pid>0)
	{
		int i=0;
		while(1)
		{
			if(i>3)
			{
				printf("111111");
				exit(0);//刷新缓冲区
			}
			i++;
			printf("i am parent\n");
			sleep(1);
		}
	}
	else 
	{
		while(1)
		{
		
			printf("i am child\n");
			sleep(1);
		}
	}
	return 0;
}

运行结果：

linux@ubuntu:~/jincheng$ i am child
i am child
i am child
i am child
i am child
i am child
i am child
i am child
i am child
i am child
i am child
Li am child
i am child
i am child
i am child
i am child
……

该进程为后台进程，kill  -9 PID可将其杀死

（4）进程阻塞（回收子进程，可以避免僵尸进程）

参数中的*status是一个整形指针，用来表示子进程退出时的状态

  • status为空，表示忽略子进程的退出状态
  • status为其他值，表示保存子进程的退出状态

六、进程的分类之-守护进程

守护进程创建步骤：

案例：

#include <stdio.h>
#include <sys/types.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/stat.h>
#include <fcntl.h>
int main(void)
{
//(1)创建子进程，让父进程退出
pid_t pid = fork();
if(pid < 0)
{
perror("fork error");
return -1;
}
else if(pid > 0)
{
//退出
exit(0);
}
//(2)创建新的会话
int ret = setsid();
if(ret < 0)
{
perror("setsid error");
return -1;
}
//修改当前目录为根目录
chdir("/");
//修改文件权限掩码
umask(0);
//关闭文件描述符
int i;
for(i = 0; i < getdtablesize(); i++)
{
close(i);
}
3、通信相关概念
3.1 通信的模式
//写日志
//打开文件
int fw = open("daemon.log",O_WRONLY | O_CREAT,0777);
if(fw < 0)
{
perror("open error");
return -1;
}
//操作文件
while(1)
{
ret = write(fw,"hello",5);
if(ret > 0)
{
printf("write ok!\n");
}
sleep(1);
}
return 0;
}

运行：

sudo ./a.out

结果：TTY变成？控制终端变成守护进程

TTY：终端的次要装置号码，示例中的TTY列都是“？”，是表示这些进程不属于任何TTY，因为它们是由系统启动的，tty1-tty6 是本机上面的登入者程序，若为 pts/0 等等的，则表示为由网络连接进主机的程序。

七、进程间通信

  • 通信方式

通信的方式

  • 通信的三种模式

通信的三种模式

（一）无名管道

1.无名管道的相关信息

2.案例：

（1）关闭无名管道的 写端，读管道不会阻塞，返回0

#include <stdio.h>
#include <sys/types.h>
#include<unistd.h>
int main()
{
	int fd[2];
	//创建无名管道
	int ret =pipe(fd);
	if(ret<0)
	{
		perror("pipe error");
		return -1;
	}
	//管道的写端
	close(fd[1]);
	//读管道
	char buf[128]={0};
	ret=read(fd[0],buf,sizeof(buf));
	if(ret<0)
	{
		perror("read error");
		return -1;
	}
	else if(ret ==0)
	{
		printf("read return 0\n");
		close(fd[0]);
		return 0;
	}
	else
	{
		printf("ret=%d,buf=%s\n",ret,buf);
	}
	close(fd[0]);
	return 0;

}

（2）向无名管道写入数据，读取数据

#include <stdio.h>
#include <sys/types.h>
#include <unistd.h>
#include <string.h>
int main()
{
	int fd[2];
	//创建无名管道
	int ret =pipe(fd);
	if(ret<0)
	{
		perror("pipe error");
		return -1;
	}
	//向管道写入数据
	char buf[100]="hello world";
	write(fd[1],buf,strlen(buf));
	close(fd[1]);
	//读管道
//	char buf1[100]={0};
//	ret=read(fd[0],buf1,strlen(buf));
	ret=read(fd[0],buf,strlen(buf));
	if(ret<0)
	{
		perror("read error");
		close(fd[0]);
		return -1;
	}
	else if(ret ==0)
	{
		printf("read return 0\n");
		close(fd[0]);
		return 0;
	}
	else
	{
		printf("ret=%d,buf=%s\n",ret,buf);
	}
	close(fd[0]);
	return 0;

（3）测试管道破裂

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

int main()
{
//创建无名管道
	int fd[2]={-1,-1};
	int ret =  pipe(fd);
	if(ret <0)
	{
		perror("pipe error");
		return -1;
	}
	//关闭读段
	close(fd[0]);
	//创建子进程
	pid_t pid =fork();
	if(pid < 0)
	{
		perror("fork error");
		return -1;
	}	
	//父进程
	else if(pid > 0)
	{
		int status = 0;
		ret = wait(&status);
		if(ret > 0)
		{
			if(WIFEXITED(status))
			{
				printf("terminated normally %d\n",WEXITSTATUS(status));
			}
			else if(WIFSIGNALED(status))
			{
				printf("terminated by signal%d\n",WTERMSIG(status));
			}

		}
	}
	else
	{
		//子进程
		char buf[100]={0};
		printf("w:");
		fgets(buf,sizeof(buf),stdin);
		write(fd[1],buf,sizeof(buf));
		exit(3);
	}

	return 0;
}
*为什么无名管道只能用于具有亲缘关系间的通信？
子进程会继承父进程的文件描述符， 得到同一个文件描述符 之后就可以通信了

（二）有名管道

1.有名管道的相关概念

2.有名管道的创建

案例1：
#include<unistd.h>
#include<fcntl.h>
#include<sys/types.h>
#include<stdio.h>
#include<errno.h>

int main()
{
	char buf[100]={0};
	//创建有名管道
	int ret = mkfifo("test.fifo",0644);
	if(ret < 0 && EEXIST != errno)
	{
		perror("mkfifo error");
		return -1;
	}
	//打开文件
	int fw = open("test.fifo",O_WRONLY);
	if(fw < 0)
	{
		perror("open error");
		return -1;
	}
	//操作文件
	printf("w:");
	fgets(buf,sizeof(buf),stdin);
	write(fw,buf,sizeof(buf));
	//关闭文件
	close(fw);
	return 0;
}

只有读端或者写端存在时，系统会阻塞，直到下一个程序的到来会打破这种阻塞

（三）信号

（四）IPC对象

（五）共享内存

       查看共享内存命令：ipcs

（六）消息队列

（七）信号灯

二、线程

我不是码农 嘤嘤嘤
关注
专栏目录
进程与线程详解
ashfiqa的博客
11-22 1万+
本文章是对线程进程的一些总结，同时对多线程也有一个初步的认识，欢迎大家前来一起学习。
两篇文章了解进程与线程（ 基础篇 ）
12-21
一、进程： 1. 进程概念： ...线程实际上是在进程的基础之上的进一步划分，一个进程启动后，里面的若干个程序由可以划分成若干个线程。线程：是进程的一个执行路径，共享一个内存空间，线程之间可以自由切换
执行程序的三种模式
zhangqi415的博客
12-24 849
中断号是标志，中断号从何而来，是通过计算机中的服务等吧，通过中断号去执行这个中断代表的含义，是软件部分的代码执行，中断是硬件和软件的交流方式，也是软件中进程与进程的交流方式，详见文末符表，列出几个中断号代表的含义），计算出中断向量中的条目，进而装载。看下原文：影子寄存器是靠硬件来操作的，对系统程序员不可见，是硬件为了减少性能损耗而设计的一个段描述符的高速缓存，不然每次内存访问都要去内存中查表，那性能损失是巨大的，影子寄存器也正好是。再分析模式的 共同的作用，就是通过数据来运行程序，程序也就是进程了。
linux进程的执行模式,Linux 程序后台运行的方式
weixin_33362939的博客
04-28 261
问题描述wget http://www.example.com/test.zip &这个下载命令会放到当前shell进程后台任务队列运行, 任务队列可以通过jobs命令查看.通过此方式运行的程序的父进程都是当前shell的进程ID当shell关闭时, 任务队列中的子进程会收到 hangup的终止信号退出. 所以以上命令当你的shell退出的时候,下载命令也就终止了.后台运行的方式解决办法...
进程执行模式与进程间通讯
web
12-09 315
执行模式 指令分为特权指令（只能由操作系统内核使用的指令）和非特权指令（只能由用户程序使用的指令），因为指令有特权和非特权之分，所以 CPU 也分为 2 种执行模式：系统态（可以执行所有指令，使用所有资源以及改变 CPU 状态）和用户态（只能执行非特权指令）。 CPU 的系统态和用户态之间的切换。 进程间通讯 当进程之间需要数据传输、共享数据时，进程间就需要互相通讯，通讯方式有如下几种...
【Linux基础】进程模式
u010926630的专栏
06-13 1357
在Linux系统中，进程的执行模式划分为用户模式和内核模式。如果当前运行的是用户程序、应用程序或内核之外的系统程序，那么对应进程就在用户模式下运行：如果在用户程序执行过程中出现系统调用或发生中断事件，那么就要运行操作系统程序，进程模式就变成内核模式。 用户进程既可以在用户模式下运行，也可以在内核模式下运行。如下图所示： 01.jpg (22.44 KB, 下载次数: 0)
进程的运行模式
dodobibibi的博客
10-10 2780
1.1.1操作系统的内核 1.CPU的执行模式 CPU的基本功能就是执行指令。通常，CPU指令集的指令可以划分为两类：特权指令和非特权指令。特权指令是指具有特色权限的指令，可以访问系统中所有的寄存器和内存单元，修改系统的关键设置。如清理内存、设置时钟、执行I/O操作等都是由特权指令完成的。而非特权指令是那些用于一般性的运算和处理的指令。这些指令只能访问用户程序自己的内存地址空间。 特权指令的权限高...
进程与线程概念
weixin_57763462的博客
05-05 2545
一、进程与线程 进程：是代码在数据集合上的一次运行活动，是系统进行资源分配和调度的基本单位。 线程：是进程的一个执行路径，一个进程中至少有一个线程，进程中的多个线程共享进程的 资源。 虽然系统是把资源分给进程，但是CPU很特殊，是被分配到线程的，所以线程是CPU分配的基本单位。 二者关系： 一个进程中有多个线程，多个线程共享进程的堆和方法区资源，但是每个线程有自己的程序计数器和栈区域。 程序计数器：是一块内存区域，用来记录线程当前要执...
进程与线程的关系
Lce的专栏
06-19 1万+
共享内存允许两个或多个进程共享一个给定的存储区，这一段存储区可以被两个或两个以上的进程映射至自身的地址空间中，一个进程写入共享内存的信息，可以被其他使用这个共享内存的进程，通过一个简单的内存读取错做读出，从而实现了进程间的通信。线程共享的环境包括：进程代码段、进程的公有数据(利用这些共享的数据，线程很容易的实现相互之间的通讯)、进程打开的文件描述符、信号的处理器、进程的当前目录和进程用户ID与进程组ID。2.线程是进程的一部分，一个线程只能属于一个进程，一个进程可以有多个线程，但至少有一个线程。
进程和线程的区别(超详细)
热门推荐
ThinkWon的博客
10-03 41万+
进程和线程 进程 一个在内存中运行的应用程序。每个进程都有自己独立的一块内存空间，一个进程可以有多个线程，比如在Windows系统中，一个运行的xx.exe就是一个进程。 线程 进程中的一个执行任务（控制单元），负责当前进程中程序的执行。一个进程至少有一个线程，一个进程可以运行多个线程，多个线程可共享数据。 与进程不同的是同类的多个线程共享进程的堆和方法区资源，但每个线程有自己的程序计数器、虚拟...
进程与线程的生动形象理解
12-29
4. **线程与工人**：在一个车间里，有许多工人协同完成任务，这里的工人可以对应于进程中的线程。一个进程可以包含多个线程，它们共同完成同一项任务的不同部分。 5. **共享资源**：车间的空间（例如工具间、仓库等...
进程线程结束暂停源码_进程与线程
09-25
综上所述，理解和掌握进程线程的创建、结束、暂停与恢复、同步与通信等知识对于编写高并发、高效能的多线程程序至关重要。在实际编程中，需要根据系统特性选择合适的线程管理机制，并遵循最佳实践以保证程序的稳定性...
easx.rar_进程与线程
09-23
"easx.rar_进程与线程"这个压缩包文件显然包含了与易语言（EasyLanguage）相关的幼儿算术程序源码，这为易语言爱好者提供了一个学习和研究进程与线程如何在实际应用中运作的机会。 易语言是一种面向对象、简单易学...
Linux下的systemd/service
最新发布
zxz_Fine的博客
11-05 284
开机自启任务
Linux：网络协议socket
Au_ust的博客
11-05 740
我们之前学的通信是本地进程间通信，如果我们想在网络间通信的话，就需要用到二者的ip地址，分别被称为源IP地址和目的IP地址，被存入ip数据包中，其次我们还需要遵循一些通信协议。TCP协议：传输层协议，有连接，可靠传输，面向字节流（无明确边界的字节序列），难UDP协议：传输层协议，无连接，不可靠传输，面向数据流（以数据包为单位），简单网络通信的本质也是进程间通信，你怎么知道你要和哪个进程通信？
Linux初阶——线程（Part3）：POSIX 信号量 & CP 模型变体
m0_73093743的博客
11-02 447
只能建立一个对象的设计模式。
[linux 驱动]PWM子系统详解
weixin_49406449的博客
11-04 690
搜索“rockchip,rk3328-pwm”，发现在./drivers/pwm/pwm-rockchip.c 出现，所以 pwm6 的驱动是pwm-rockchip。任何 PWM 设备实例都可以被注册到 pwm_class 下，用户空间应用可以通过 /sys/class/pwm 访问这些设备，实现对 PWM 功能的控制。struct pwm_device *pwm: 这是指向 PWM 设备结构体的指针，该结构体是在调用 pwm_request 函数时获取的。这是指向该控制器的 PWM 通道的数组或链表。
Linux——Linux基础指令
辰多代码的博客
11-05 464
比 more 更强大的分页器，支持前后翻页和搜索。1：移动文件或目录（前提是目标文件或目录不存在）。：重命名文件或目录（前提是目标文件或目录存在）。:：显示系统上当前登录的用户及其相关信息。：显示网络连接、路由表和网络接口统计信息。：统计文件的行数、字数和字节数。：显示当前工作目录的完整路径。：列出目录中的文件和子目录。：显示或设置系统日期和时间。：在目录层次结构中搜索文件。：显示系统中正在运行的进程。：配置或显示网络接口信息。：显示当前用户的用户名。：更新现有文件的时间戳。：查找可执行文件的位置。
深入理解Android进程与线程
"深入理解Android进程与线程" 在Android系统中，进程和线程是运行应用程序的基础。Android的每一个应用程序都被赋予了一个独立的Linux用户ID，确保了不同应用之间的数据和资源隔离，增强了系统的安全性。当一个...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值