进程与线程（四）

最新推荐文章于 2024-10-06 20:16:20 发布
最新推荐文章于 2024-10-06 20:16:20 发布
阅读量1.1k 收藏 20
点赞数 12
分类专栏： 网络 文章标签： java redis jvm
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xuezhe_____/article/details/139381132
版权

进程与线程（四）

基于System V IPC对象的进程间通信机制

IPC对象和文件一样,必须先创建,每个IPC对象都有特定Key值,ID值,拥有者,权限和使用大小等，但其读写操作不能使用普通文件的read/write方式。

SystemV IPC引入

1、在传统的UNIX通信机制上进行了优化，形成一种更新的进程间通信机制
2、基于System V IPC相关的通信方式，全部使用ID来访问内存空间（数据存储的空
间）
2-1：ID的来源：创建或者打开内存空间时，内核给用户返回的
思考：毫无关系的两个进程如何得知同一片内存空间的ID？
—》空间谁创建的？
用户进程自己！（哪个用户来创建不限制）
办法：
创建者按照key值来创建并打开内核中的内存空间，最后拿到ID
使用者也按照同一个key值来打开内存空间，最后也能拿到同样的ID
2-2：Key值的来源：
key的来源1：key值是被创建出来的，通信双方只要使用同样的方式，即可获取到同一个Key
key的来源2：直接传入IPC_PRIVATE(死值)–》适合具有亲缘关系的进程间通信

查看Linux系统中IPC工具的方式

查看所有IPC工具

命令：ipcs

在这里插入图片描述

查看指定的IPC工具

查看消息队列：
ipcs -q
删除消息队列：
ipcrm -q msgid(ID值)
查看共享内存：
ipcs -m
删除共享内存：
ipcrm -m shmid
查看信号灯集：
ipcs -s
删除信号灯集：
ipcrm -s semid

在这里插入图片描述

key值获取方法：ftok()函数

在这里插入图片描述

消息队列

消息队列的特征：

1、消息队列是IPC对象的一种，实现两个进程间少量的收据传输,使用率最高
2、消息队列由消息队列ID来唯一标识
3、消息队列就是一个消息的列表（特殊的链式队列）。用户可以在消息队列中添加消息、读取消息等。
4、消息队列可以按照类型来发送/接收消息，先入先出(同一类型),不同类型的消息可以随机存取。
5、数据存放在内核当中

在这里插入图片描述
在这里插入图片描述

消息队列的操作

打开或者创建消息队列

在这里插入图片描述

添加消息

在这里插入图片描述

读取消息

在这里插入图片描述

控制消息队列（删除消息队列）

在这里插入图片描述
案例：创建消息队列收发消息
消息队列添加消息代码：

#include <stdio.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <string.h>
#include <errno.h>
#define N 100
//消息结构
typedef struct msgbuf
{
	long mtype; //消息类型
	char mtext[N]; //消息正文
}MSG;
int main(int argc, const char *argv[])
{
	//1，获取key值
	key_t key = ftok("./", 88);
	if(key < 0)
	{
		perror("ftok error");
		return -1;
	}
	printf("ftok ok! key = %d\n",key);
	//2，打开或者创建消息队列，获得ID值
	int msgid = msgget(key, IPC_CREAT | 0664);
	if(msgid < 0)
	{
		perror("msgget error");
		return -1;
	}
	printf("msgget ok! msgid = %d\n",msgid);
	//3，发送消息
	//构造消息
	//给消息类型赋值
	MSG m1;
	bzero(&m1, sizeof(m1));
	m1.mtype = 100;
	printf("请输入发送的第1个消息:\n");
	fgets(m1.mtext, sizeof(m1.mtext), stdin);
	MSG m2;
	bzero(&m2, sizeof(m2));
	//给消息类型赋值
	m2.mtype = 100;
	printf("请输入发送的第2个消息:\n");
	fgets(m2.mtext, sizeof(m2.mtext), stdin);
	MSG m3;
	bzero(&m3, sizeof(m3));
	//给消息类型赋值
	m3.mtype = 300;
	printf("请输入发送的第3个消息:\n");
	fgets(m3.mtext, sizeof(m3.mtext), stdin);
	//发送消息
	msgsnd(msgid, &m2, strlen(m2.mtext), 0);
	msgsnd(msgid, &m1, strlen(m1.mtext), 0);
	msgsnd(msgid, &m3, strlen(m3.mtext), 0);
	//删除消息队列
	//msgctl(msgid, IPC_RMID, NULL);
	return 0;
}

消息队列读取消息代码：

#include <stdio.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <strings.h>
#include <errno.h>
#define N 100
//消息结构
typedef struct msgbuf
{
	long mtype; //消息类型
	char mtext[N]; //消息正文
}MSG;
int main(int argc, const char *argv[])
{
	//1，获取key值
	key_t key = ftok("./", 88);
	if(key < 0)
	{
		perror("ftok error");
		return -1;
	}
	printf("ftok ok! key = %d\n", key);
	//2，打开或者创建消息队列，获得ID值
	int msgid = msgget(key, IPC_CREAT | 0664);
	if(msgid < 0)
	{
		perror("msgget error");
		return -1;
	}
	printf("msgget ok! msgid = %d\n", msgid);
	//3，读取消息
	MSG readMsg;
	bzero(&readMsg, sizeof(readMsg));
	msgrcv(msgid, &readMsg, sizeof(readMsg.mtext), 0, 0);//参数3为0 默认读取第
	一条消息
	//打印读取的消息
	printf("读取的队列中第一条消息为:%s\n", readMsg.mtext);
	//删除消息队列
	//msgctl(msgid, IPC_RMID, NULL);
	return 0;
}

在这里插入图片描述
注意：消息队列中的消息是读取一条则少一条，添加一条则多一条！

共享内存

共享内存的特征

1、共享内存是一种最为高效的进程间通信方式，进程可以直接读写内存（映射之后的内存空间），而不需要任何数据的拷贝
2、为了在多个进程间交换信息，内核专门留出了一块内存区，可以由需要访问的进程将其映射到自己的私有地址空间
3、进程就可以直接读写这一内存区而不需要进行数据的拷贝，从而大大提高的效率。
4、由于多个进程共享一段内存，因此也需要依靠某种同步机制，如互斥锁和信号量等

命令管道和消息队列就存在数据拷贝的过程：如下图
在这里插入图片描述

而共享内存之所以高效的图解：如下：
在这里插入图片描述
注意：内核空间只有一份，所有进程的内核空间都是共享的。

共享内存的操作

打开或者创建共享内存

在这里插入图片描述

映射共享内存到用户的私有空间

在这里插入图片描述

取消映射

在这里插入图片描述

删除共享内存

在这里插入图片描述
案例：共享内存实现数据的交互
共享内存写端代码：

#include <stdio.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <sys/types.h>
int main(int argc, const char *argv[])
{
	//完成key值的获取
	key_t key = ftok("./", 22);
	if(key < 0)
		return -1;
	printf("ftok ok!\n");
	//共享内存区域申请
	int shmid = shmget(key, 1024, IPC_CREAT | 0664);
	if(shmid < 0)
		return -1;
	printf("shmget ok!\n");
	//映射共享内存到用户私有空间
	char *p = (char *)shmat(shmid, NULL, 0);//0代表共享内存此时可读可写
	if(p == (char *)-1)
		return -1;
	printf("shmat ok!\n");
	//操作
	printf("请输入写入到共享内存的信息:\n");
	fgets(p, 1024, stdin);
	//取消映射
	if(shmdt(p) < 0)
	{
		perror("shmdt error");
		return -1;
	}
	printf("shmdt ok!\n");
	//删除共享内存
	/*
	if(shmctl(shmid, IPC_RMID, NULL) < 0)
	return -1;
	printf("shmctl ok!\n");
	*/
	return 0;
}

共享内存读端代码：

#include <stdio.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <sys/types.h>
int main(int argc, const char *argv[])
{
	//完成key值的获取
	key_t key = ftok("./", 22);
	if(key < 0)
		return -1;
	printf("ftok ok!\n");
	//共享内存区域申请
	int shmid = shmget(key, 1024, IPC_CREAT | 0664);
	if(shmid < 0)
		return -1;
	printf("shmget ok!\n");
	//映射共享内存到用户私有空间
	char *p = (char *)shmat(shmid, NULL, 0);//0代表共享内存此时可读可写
	if(p == (char *)-1)
		return -1;
	printf("shmat ok!\n");
	//操作
	//读取共享内存中的消息
	printf("读取的结果为:");
	fputs(p, stdout);
	//取消映射
	if(shmdt(p) < 0)
		return -1;
	printf("shmdt ok!\n");
	//删除共享内存
	/*
	if(shmctl(shmid, IPC_RMID, NULL) < 0)
	return -1;
	printf("shmctl ok!\n");
	*/
	return 0;
}

在这里插入图片描述
思考：要是./r此时先运行，则会出现什么情况？
在这里插入图片描述
注意：要是想要让该两个进程之间形成一种同步关系，比如：先输入，再输出！如何实现？？？
—》进程间通信时，要同步可以使用有名信号量！！！
优化：使用有名信号量将上述共享内存的代码优化为同步（先输入， 再输出）
共享内存的写端代码：

#include <stdio.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <sys/types.h>
#include <fcntl.h> /* For O_* constants */
#include <sys/stat.h> /* For mode constants */
#include <semaphore.h>
#include <signal.h>
#include <stdlib.h>
sem_t *pFgets,*pFputs;
//信号处理函数
void func(int sig)
{
	//关闭有名信号量
	sem_close(pFgets);
	sem_close(pFputs);
	//删除有名信号量
	sem_unlink("SEM_FEGTS");
	sem_unlink("SEM_FPUTS");
	exit(0);
}
int main(int argc, const char *argv[])
{
	//注册一个信号和处理函数
	signal(SIGINT, func);
	//创建2个有名信号量
	pFgets = sem_open("SEM_FEGTS", O_RDWR | O_CREAT, 0664, 1);
	if(pFgets == SEM_FAILED)
	{
		printf("sem_open error");
		return -1;
	}
	printf("sem_open_fgets ok!");
	pFputs = sem_open("SEM_FPUTS", O_RDWR | O_CREAT, 0664, 0);
	if(pFputs == SEM_FAILED)
	{
		printf("sem_open error");
		return -1;
	}
	printf("sem_open_fputs ok!");
	//完成key值的获取
	key_t key = ftok("./", 22);
	if(key < 0)
		return -1;
	printf("ftok ok!\n");
	//共享内存区域申请
	int shmid = shmget(key, 1024, IPC_CREAT | 0664);
	if(shmid < 0)
		return -1;
	printf("shmget ok!\n");
	//映射共享内存到用户私有空间
	char *p = (char *)shmat(shmid, NULL, 0);//0代表共享内存此时可读可写
	if(p == (char *)-1)
		return -1;
	printf("shmat ok!\n");
	//操作
	while(1)
	{
		//申请资源（P操作）
		sem_wait(pFgets);
		printf("请输入写入到共享内存的信息:\n");
		fgets(p, 1024, stdin);
		//释放资源（V操作）
		sem_post(pFputs);
	}
	//取消映射
	if(shmdt(p) < 0)
	{
		perror("shmdt error");
		return -1;
	}
	printf("shmdt ok!\n");
	//删除共享内存
	/*
	if(shmctl(shmid, IPC_RMID, NULL) < 0)
	return -1;
	printf("shmctl ok!\n");
	*/
	return 0;
}

共享内存的读端代码：

#include <stdio.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <sys/types.h>
#include <fcntl.h> /* For O_* constants */
#include <sys/stat.h> /* For mode constants */
#include <semaphore.h>
#include <signal.h>
#include <stdlib.h>
sem_t *pFgets,*pFputs;
void func(int sig)
{
	//关闭有名信号量
	sem_close(pFgets);
	sem_close(pFputs);
	//删除有名信号量
	sem_unlink("SEM_FEGTS");
	sem_unlink("SEM_FPUTS");
	exit(0);
}
int main(int argc, const char *argv[])
{
	//安装信号和处理函数
	signal(SIGINT, func);
	pFgets = sem_open("SEM_FEGTS", O_RDWR | O_CREAT, 0664, 1);
	if(pFgets == SEM_FAILED)
	{
		printf("sem_open error");
		return -1;
	}
	printf("sem_open_fgets ok!");
	pFputs = sem_open("SEM_FPUTS", O_RDWR | O_CREAT, 0664, 0);
	if(pFputs == SEM_FAILED)
	{
		printf("sem_open error");
		return -1;
	}
	printf("sem_open_fputs ok!");
	//完成key值的获取
	key_t key = ftok("./", 22);
	if(key < 0)
		return -1;
	printf("ftok ok!\n");
	//共享内存区域申请
	int shmid = shmget(key, 1024, IPC_CREAT | 0664);
	if(shmid < 0)
		return -1;
	printf("shmget ok!\n");
	//映射共享内存到用户私有空间
	char *p = (char *)shmat(shmid, NULL, 0);//0代表共享内存此时可读可写
	if(p == (char *)-1)
		return -1;
	printf("shmat ok!\n");
	//操作
	while(1)
	{
		//申请资源（P操作）
		sem_wait(pFputs);
		//读取共享内存中的消息
		printf("读取的结果为:");
		fputs(p, stdout);
		//释放资源（V操作）
		sem_post(pFgets);
	}
	//取消映射
	if(shmdt(p) < 0)
		return -1;
	printf("shmdt ok!\n");
	//删除共享内存
	/*
	if(shmctl(shmid, IPC_RMID, NULL) < 0)
	return -1;
	printf("shmctl ok!\n");
	*/
	return 0;
}

在这里插入图片描述
当用户在键入输入ctrl c 之后，因为安装了信号处理函数，因此将有名信号量进行了删除，演示如下：
在这里插入图片描述

信号量

无名信号量

线程之间需要同步！

有名信号量 （有名信号量的位置：/dev/shm/）

进程之间需要同步！

创建有名信号量

#include <fcntl.h> /* For O_* constants /
#include <sys/stat.h> / For mode constants */
#include <semaphore.h>
sem_t *sem_open(const char *name, int oflag,
mode_t mode, unsigned int value);
参数1：有名信号量的名字（自己起）
参数2：打开方式：O_RDWR O_RDONLY O_WRONLY O_CREAT
参数3：有名信号量的权限：0664
参数4：给有名信号量的初始值（功能类似于无名信号量的初始化数值的函数sem_init（））
Link with -pthread. //编译要连接pthread库！！！
返回值：成功返回指向有名信号量的指针 失败返回SEM_FAILED

申请资源（p操作）

#include <semaphore.h>
int sem_wait(sem_t *sem);

释放资源（V操作）

#include <semaphore.h>
int sem_post(sem_t *sem);

关闭有名信号量

#include <semaphore.h>
int sem_close(sem_t *sem);

删除有名信号量

#include <semaphore.h>
int sem_unlink(const char *name);
参数：有名信号量的名字

案例：使用有名信号量实现进程1先打印hello 进程2再打印world
进程1代码：

#include <stdio.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <sys/types.h>
#include <unistd.h>
#include <fcntl.h> /* For O_* constants */
#include <sys/stat.h> /* For mode constants */
#include <semaphore.h>
int main(int argc, const char *argv[])
{
	//创建2个有名信号量
	sem_t *pSem1 = sem_open("SEM_1", O_RDWR | O_CREAT, 0664, 1);
	if(SEM_FAILED == pSem1)
	{
		perror("sem_open error");
		return -1;
	}
	printf("sem_open SEM_1 ok!\n");
	sem_t *pSem2 = sem_open("SEM_2", O_RDWR | O_CREAT, 0664, 0);
	if(SEM_FAILED == pSem2)
	{
		perror("sem_open error");
		return -1;
	}
	printf("sem_open SEM_2 ok!\n");
	while(1)
	{
		//申请资源
		sem_wait(pSem1);
		printf("hello\n");
		sleep(1);
		//释放资源
		sem_post(pSem2);
	}
	//关闭有名信号量
	sem_close(pSem1);
	sem_close(pSem2);
	//删除有名信号量
	sem_unlink("SEM_1");
	sem_unlink("SEM_2");
	return 0;
}

进程2代码：

#include <stdio.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <sys/types.h>
#include <unistd.h>
#include <fcntl.h> /* For O_* constants */
#include <sys/stat.h> /* For mode constants */
#include <semaphore.h>
int main(int argc, const char *argv[])
{
	//创建2个有名信号量
	sem_t *pSem1 = sem_open("SEM_1", O_RDWR | O_CREAT, 0664, 1);
	if(SEM_FAILED == pSem1)
	{
		perror("sem_open error");
		return -1;
	}
	printf("sem_open SEM_1 ok!\n");
	sem_t *pSem2 = sem_open("SEM_2", O_RDWR | O_CREAT, 0664, 0);
	if(SEM_FAILED == pSem2)
	{
		perror("sem_open error");
		return -1;
	}
	printf("sem_open SEM_2 ok!\n");
	while(1)
	{
		//申请资源
		sem_wait(pSem2);
		printf("world\n");
		sleep(1);
		//释放资源
		sem_post(pSem1);
	}
	//关闭有名信号量
	sem_close(pSem1);
	sem_close(pSem2);
	//删除有名信号量
	sem_unlink("SEM_1");
	sem_unlink("SEM_2");
	return 0;
}

在这里插入图片描述
使用有名管道实现循环聊天
思路：
1、创建两个有名管道，搭配两个子线程，双方对于其中某一个进行你发我收，另一个我发你收即可。
2、双方的收发各自使用线程处理函数解决

eg:clien1.c
#include <stdio.h>
//发送消息
void * send_func(void *arg)
{
	//write :fd, buf, strlen()/sizeof()
	mkfifo("com1.txt", 0664);
	int fw = open("com1.txt", O_WRONLY);
	while(1)
	{
		write(fw, buf, strlen(buf));
	}
}
//接收消息
void * recv_func(void *arg)
{
	mkfifo("com2.txt", 0664);
	int fr = open("com2.txt", O_RDONLY);
	while(1)
	{
		read(fr, buf, sizeof(buf));
	}
}
int main()
{
	//创建两个子进程
	//定义保存线程ID的变量
	pthread_t sendTHID;//保存发送子线程的ID号
	pthread_t recvTHID;//保存结束子线程的ID号
	pthread_create(&sendTHID, NULL, &send_func, NULL);
	pthread_create(&recvTHID, NULL, &recv_func, NULL);
	//线程分离 ---》当子线程结束时，自动释放其资源
	pthread_detach(sendTHID);
	pthread_detach(recvTHID);
	return 0;
}

eg:clien2.c
#include <stdio.h>
//发送消息
void * send_func(void *arg)
{
	//write :fd, buf, strlen()/sizeof()
	mkfifo("com2.txt", 0664);
	int fw = open("com2.txt", O_WRONLY);
	while(1)
	{
		write(fw, buf, strlen(buf));
	}
}
//接收消息
void * recv_func(void *arg)
{
	mkfifo("com1.txt", 0664);
	int fr = open("com1.txt", O_RDONLY);
	while(1)
	{
		read(fr, buf, sizeof(buf));
	}
}
int main()
{
	//创建两个子进程
	//定义保存线程ID的变量
	pthread_t sendTHID;//保存发送子线程的ID号
	pthread_t recvTHID;//保存结束子线程的ID号
	pthread_create(&sendTHID, NULL, &send_func, NULL);
	pthread_create(&recvTHID, NULL, &recv_func, NULL);
	//线程分离 ---》当子线程结束时，自动释放其资源
	pthread_detach(sendTHID);
	pthread_detach(recvTHID);
	return 0;
}

安装SIGCHLD信号，回收子进程的退出资源（僵尸进程的资源处理）

#include <stdio.h>
//使用信号处理函数让父进程回收子进程的退出资源
void reclamation_func(int signum)
{
	//回收资源
	/*
	//注意：while()循环只是起到可以进入处理函数内部时，一次性回收好几个子进程的退出资源
	思考：如果不加while()循环，则好几个子进程的退出资源需要好几次进入处理函数内部
	去回收
	while(waitpid(-1, NULL, WNOHANG) < 0)
	{
	;
	}
	*/
	int ret = waitpid(-1, NULL, WNOHANG);
	if(ret < 0)
	{
		perror("waitpid error");
	}
	else if(0 == waitpid)
	{
		printf("还未结束...\n");
	}
	else
	{
		printf("回收子进程OK 其PID = %d\n",ret);
	}
}
int main()
{
	//安装信号：绑定SIGCHLD信号 和一个回收子进程退出资源的信号处理函数
	signal(SIGCHLD, reclamation_func);
	pid_t pid = fork();
	if(pid < 0)
	exit(-1);
	else if (0 == pid)
	{
		//子进程
		printf("I am child Process!\n");
	}
	else
	{
		//父进程
		printf("I am Parent Process!\n");
		while(1);
	}
}
little Y
关注
专栏目录
进程与线程的生动形象理解
12-29
4. **线程与工人**：在一个车间里，有许多工人协同完成任务，这里的工人可以对应于进程中的线程。一个进程可以包含多个线程，它们共同完成同一项任务的不同部分。 5. **共享资源**：车间的空间（例如工具间、仓库等...
c语言多进程多线程编程
07-21
3. **线程通信与同步**：线程间的通信通常通过共享内存实现，因为它们本就属于同一个进程。线程同步可以使用`pthread_mutex_lock()`和`pthread_mutex_unlock()`进行互斥锁操作，或者使用条件变量（`pthread_cond_t`...
线程与进程，你真得理解了吗
热门推荐
云深不知处
05-07 13万+
相信大家面试时一定没少被一个问题刁难，那就是进程和线程的区别是什么？这个问题延申开来并不像表面那么简单，今天就来深入一探。 开始前先看一组非常传神的图例，相信可以帮助你更好理解进程与线程的概念： 1 进程与线程的关系和区别 什么是进程 进程可以说是一个“执行中的程序”。程序是指令、数据及其组织形式的描述，是一个没有生命的实体，只有处理器赋予程序生命时（操作系统执行之），它才能成为一个活动的实体，我们称其为进程。 进程有哪些特征？ 进程依赖于程序运行而存在，进程是动态的，程序是静态的； 进程是操作系统进行
进程与线程的区别
记录各种Bug解决案例及日常学习内容
07-21 9329
线程是进程中执行运算的最小单位，是进程中的一个实体，是被系统独立调度和分派的基本单位，线程自己不拥有系统资源，只拥有一点在运行中必不可少的资源，但它可与同属一个进程的其它线程共享进程所拥有的全部资源。一个线程可以创建和撤消另一个线程，同一进程中的多个线程之间可以并发执行。好处（1）易于调度。（2）提高并发性。通过线程可方便有效地实现并发性。进程可创建多个线程来执行同一程序的不同部分。（3）开销少。创建线程比创建进程要快，所需开销很少。（4）利于充分发挥多处理器的功能。...
进程与线程
程序媛泡泡的博客
03-18 8万+
进程与线程 1 进程 1.1 进程的概念 进程就是正在运行的程序,它代表了程序所占用的内存区域 1.2 进程的特点 独立性 进程是系统中独立存在的实体,它可以拥有自己独立的资源,每个进程都拥有自己私有的地址空间,在没有经过进程本身允许的情况下,一个用户进程不可以直接访问其他进程的地址空间 动态性 进程与程序的区别在于,程序只是一个静态的指令集合,而进程是一个正在系统中活动的指令集合,程序加入了时间的概念以后,称为进程,具有自己的生命周期和各种不同的状态,这些概念都是程序所不具备的. 并发性 多个进程可以在
python进程与线程
qq_33163046的博客
11-02 5341
总结了python中如何创建并使用多进程和多线程的主要方法，所有代码都自测成功，用于以后编写代码时复制修改。这是我总结的python代码编写常的有关进程线程的代码。基本功能应该不外呼这10组代码。
进程、线程与CPU
NSJim的博客
02-21 4303
关于进程、线程及串行、并行等概念，我们很有可能感到混淆难辨，因此将一些相关概念记录在此，以备不时之需。本篇博客包含CPU调度、单核与多核、进程与线程、串行并行与并发、同步与异步、Python的多线程与多进程、等内容。
进程、线程、协程
Pinker_Q
08-28 1万+
进程、线程、协程 一、概念与区分 1、进程 进程是程序一次动态执行的过程，是程序运行的基本单位。 每个进程都有自己的独立内存空间，不同进程通过进程间通信来通信。 进程占据独立的内存，所以上下文进程间的切换开销（栈、寄存器、页表、文件句柄等）比较大，但相对比较稳定安全。协程切换和协程切换 2、线程 线程又叫做轻量级进程，是CPU调度的最小单位。 线程从属于进程，是程序的实际执行者。一个进程至少包含一个主线程，也可以有更多的子线程。 多个线程共享所属进程的资源，同时线程也拥有自己的专属资源。
进程与线程的关系
Lce的专栏
06-19 1万+
共享内存允许两个或多个进程共享一个给定的存储区，这一段存储区可以被两个或两个以上的进程映射至自身的地址空间中，一个进程写入共享内存的信息，可以被其他使用这个共享内存的进程，通过一个简单的内存读取错做读出，从而实现了进程间的通信。线程共享的环境包括：进程代码段、进程的公有数据(利用这些共享的数据，线程很容易的实现相互之间的通讯)、进程打开的文件描述符、信号的处理器、进程的当前目录和进程用户ID与进程组ID。2.线程是进程的一部分，一个线程只能属于一个进程，一个进程可以有多个线程，但至少有一个线程。
python多进程与多线程
内心不种满鲜花就会长满杂草
08-03 3298
进程程(Process)是资源分配的最小单位，它是操作系统进行资源分配和调度运行的基本单位，通俗理解：一个正在运行的程序就是一个进程。例如：正在运行的qq，微信等他们都是一个进程
简述进程与线程的关系
张胜楠的博客
03-20 6045
一. 定义        进程：进程是能在系统中独立运行并作为资源分配的基本单位，是CPU分配资源的最小单位，它包括独立的地址空间，资源以及一至多个线程。        线程：线程是进程中的一个实体，是CPU调度的最小单位。二. 两者关系            其实线程和进程可以理解成父级与子级的关系，一个进程可以包含一个或者多个线程。进程主要是负责保护和管理资源，而线程主要负责是CPU执行代码的...
Java进程与线程
微信公众号：饺子泡牛奶
03-27 2120
你可能已经很熟悉多任务（multitasking），这是操作系统的一种能力，看起来就可以在同一时刻运行多个程序。 例如，在编辑或下载邮件的同时可以打印文件等场景。 一、线程 1.1 什么是线程？ 线程是程序执行中一个单一的顺序控制流程，是程序执行流的最小单元，是处理器调度和分派的基本单位。 一个进程可以有一个或多个线程，各个线程之间共享程序的内存空间(也就是所在进程的内存空间)。 一个标准的线程由线程ID，当前指令指针PC，寄存器和堆栈组成。而进程由内存空间(代码，数据，进程空间，打开的文件.
区分python中的进程与线程
12-17
与进程不同，线程本身不拥有系统资源，但可以共享属于同一进程的资源。这意味着线程间的通信更加便捷，因为它们可以直接访问共同的内存空间。线程的创建和销毁比进程更快，这使得线程成为实现高并发的理想选择。在一...
JDK1.0主要特性
最新发布
FoolRabbit的专栏
10-06 221
JDK1.0主要特性。
JavaScript ArrayBuffer的读写与类型转换
白瑕 的博客
10-01 463
所有视图的基本单位是ArrayBuffer, ArrayBuffer中只存储二进制格式的数据.ArrayBuffer不可直接读写, 必须通过视图(比如DataView)暴露的API.
java将word转pdf
紫月7575的博客
09-30 540
java将word转pdf
spring-boot 整合 mybatis
m0_72168501的博客
09-29 562
spring boot 整合 mybatis
Java内存布局
阿呆的专栏
10-01 810
64位 JVM 不启用指针压缩时：Object Header 大小是16字节。64位 JVM 启用指针压缩时（默认）：Object Header 大小是12字节。32位 JVM：Object Header 大小是8字节。JVM在默认情况下启用指针压缩，但如果堆内存超过32GB，就会禁用指针压缩。32GB是压缩指针的最大寻址范围。超过32GB的堆内存中，压缩指针带来的性能提升并不显著，而且需要解压指针反而可能增加开销。
深入理解Android进程与线程
"深入理解Android进程与线程" 在Android系统中，进程和线程是运行应用程序的基础。Android的每一个应用程序都被赋予了一个独立的Linux用户ID，确保了不同应用之间的数据和资源隔离，增强了系统的安全性。当一个...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值