리눅스가 여러 프로세스를 만들 수 있나요?
- 青灯夜游원래의
- 2023-01-31 19:59:051739검색
Linux는 여러 프로세스를 만들 수 있습니다. Linux는 여러 프로세스를 지원하며 동시에 여러 작업을 처리하여 시스템 리소스를 최대한 활용할 수 있습니다. Linux 프로세스 간 통신 방법: 1. 명명되지 않은 파이프 사용(FIFO) 3. 단일 신호 사용 5. 메시지 대기열 사용
이 튜토리얼의 운영 환경: linux7.3 시스템, Dell G3 컴퓨터.
Linux는 여러 프로세스를 만들 수 있습니다.
linux는 여러 프로세스를 지원합니다. 다중 프로세스 시스템의 이점 중 하나는 동시에 여러 작업을 처리하여 시스템 리소스를 최대한 활용할 수 있다는 것입니다.
1장 Linux 다중 프로세스 소개
1.1.1 프로세스 개념
Linux에서는 실행되는 프로그램을 프로세스라고 합니다.
Program: 정적 개념, 컴파일된 바이너리 파일
Process: 동적 개념, 프로그램이 실행 중일 때 시스템이 자동으로 해당 프로세스를 실행합니다.
프로세스에는 Process Control Block(PCB) 코드가 포함되어 있습니다. 세그먼트, 데이터 세그먼트세 부분
프로세스 제어 블록: Linux의 구조로 표현되며 프로세스의 상태 정보를 기록합니다
좀비 프로세스: 상위 프로세스가 하위 프로세스보다 먼저 종료됩니다
하위 프로세스를 생성하면 자식 프로세스의 리소스가 부모 프로세스에서 재활용되지 않으면 자식 프로세스는 좀비 프로세스가 되고 좀비 프로세스는 결국 시스템의 INIT라는 프로세스에 의해 재활용됩니다.
init 프로세스(1번 프로세스)는 시스템이 시작될 때 가장 먼저 실행되는 프로세스로, 모든 프로세스의 조상 프로세스입니다.
1.1.2 프로세스 보기 쉘 명령
- top 동적 프로세스 정보 보기
- ps -ef 프로세스 세부 정보 보기
- pstree 프로세스 정보를 트리 형식으로 표시
- bg 정지된 프로세스를 백그라운드에서 실행시키세요
1.2.1 실행 상태
- 실행 상태(RUNNING): 프로세스가 CPU를 점유하고 있습니다.
- 준비 상태(RUNNING): 프로세스가 예약을 기다리는 대기 큐에 있습니다.
- Light sleep(INTRUPTABLE): 이때 프로세스는 이벤트가 발생하거나 일부 시스템 리소스가 신호에 응답하기를 기다리고 있습니다.
- 딥 슬립(UNINTERRUPTABLE): 현재 프로세스는 이벤트 발생이나 일부 시스템 리소스를 기다리고 있어 신호에 응답할 수 없습니다.
- STOPPED: 현재 프로세스가 일시 중지되었습니다.
- 좀비 상태(ZOMBIE) : 현재 공정을 예정할 수는 없지만 PCB는 공개되지 않았습니다.
죽음 상태(DEAD): 이는 종료된 프로세스이며 PCB가 해제됩니다
1.2.2 사용자 모드/커널 모드
커널 모드: 커널 공간이라고도 합니다. 커널 프로세스/스레드가 위치한 영역입니다. 주로 운영 체제와 하드웨어 상호 작용을 담당합니다.
사용자 모드: 사용자 공간이라고도 하며 사용자 프로세스/스레드가 위치한 영역입니다. 주로 사용자 프로그램을 실행하는 데 사용됩니다.
1. 차이점
커널 모드: 실행 코드에는 제한이 없으며 CPU는 모든 명령을 실행할 수 있습니다.
사용자 모드: CPU를 예약할 수 없으며 하드웨어에 직접 액세스할 수 없습니다 . 실행 중인 코드는 CPU에 의해 많은 검사를 받아야 하며 커널 데이터 및 프로그램에 직접 액세스할 수 없습니다. 즉, 커널 모드 스레드와 같은 유효한 주소에 액세스할 수 없습니다.
운영 체제는 사용자 프로그램을 실행할 때 주로 사용자 모드에서 작동하며 완료 권한이 없는 작업을 수행할 때만 커널 모드로 전환합니다.
2. 사용자 모드와 커널 모드를 구분하는 이유
사용자 프로세스의 오작동이나 시스템에 대한 악의적인 손상을 방지하는 보호 메커니즘
리소스의 중앙 집중식 관리를 보장하고 리소스 사용 충돌을 줄입니다.
3. 사용자 모드에서 커널 모드로 전환
(1) 시스템 호출(활성)
시스템 호출(시스템 호출)은 운영체제에서 사용자 프로세스에게 운영체제를 요청하기 위해 제공하는 인터페이스입니다. 즉, 사용자 프로세스에 서비스를 제공하는 창입니다. Linux에서는 man syscalls 명령을 사용하여 Linux에서 제공하는 모든 시스템 호출 API 인터페이스를 볼 수 있습니다.
사용자 상태는 특정 작업을 완료할 수 없기 때문에 사용자 상태는 커널 상태로의 전환을 요청하고, 커널 상태는 사용자를 위해 특별히 열린 인터럽트를 통해 전환을 완료합니다.
(2) 주변 장치 인터럽트(수동)
인터럽트가 발생하면 주변 장치가 인터럽트 신호를 보냅니다. 현재 실행 중인 프로세스가 일시 중지되고 CPU가 사용자에서 실행 중인 경우 운영 체제 커널이 처리합니다. 인터럽트 프로그램 이전의 모드는 사용자 모드에서 커널 모드로 전환하는 것과 같습니다.
인터럽트는 운영 체제가 특정 작업을 수행할 수 있도록 CPU 제어권을 운영 체제로 넘겨주는 데 사용됩니다.
(3) 예외(수동)
사용자 프로그램을 실행할 때 알 수 없는 예외가 발생하면 사용자 프로그램에서 예외를 처리하는 커널의 프로그램으로 전환합니다. 커널 상태. ㅋㅋㅋ 복사 상위 프로세스의 모든 리소스(생성 시 한 번만 복사됨,
이후 달라질 예정임 ), 상위 프로세스와 하위 프로세스 중 어느 것이 먼저 나오는지는 확실하지 않습니다.
#include <unistd.h>
pid_t fork(void);
返回值: > 0表示处于父进程中 这个时候的返回值就是**子进程进程id号**
==0 表示处于子进程中
< 0 创建进程出错
#include <sys/types.h>
#include <unistd.h>
pid_t vfork(void); (2) **vfork()** 하위 프로세스는 상위 프로세스의 모든 리소스를 공유합니다. 하위 프로세스가 먼저 실행되어야 하며 그런 다음 상위 프로세스가 실행됩니다( 수면을 추가하더라도( ) 인위적으로 방해하기 위함) 역시 쓸모가 없습니다) (3) 참고 자식 프로세스에서 exit()를 사용한 결과는 사용하지 않은 결과와 전혀 다릅니다부모 프로세스에서 sleep()을 사용하여 포기하는 CPU 타임슬라이스도 다릅니다 상위 프로세스에서 wait()를 사용하면 waitpid() 결과도 다릅니다
(4) 프로세스 전환 실행
1.3.2 프로세스 exitexit/_exit
#include <stdlib.h>
void exit(int status);
void _exit(int status);
参数：
status --->进程退出时的状态
status在实际编写程序中是可以自己约定的：
比如： exit（2）----》出现打开文件错误
exit（3）----》出现段错误（逻辑错误）
exit（0）----》正常退出
返回： void
区别：
exit（）在退出的时候会刷新IO缓冲区，然后才退出（负责任的退出）
_exit() 直接退出（不负责任的退出）
1.3.3 자식 프로세스가 종료될 때까지 기다립니다(상위 프로세스는 리소스를 재활용합니다) wait/waitpid
#include <sys/wait.h>
pid_t wait(int *stat_loc);
返回值：你回收的那个子进程的id号
参数：stat_loc --》保存子进程退出时的状态信息(不仅仅只是返回值)
stat_loc里面不仅仅只是保存了exit退出时的数值，它还保存了子进程退出时是哪个信号让它退出的，
出错了是什么原因导致的。
2, waitpid()pid_t waitpid(pid_t pid, int *stat_loc, int options); 回收子进程/进程组
参数： pid ----》你指定要回收的那个子进程的id
<-1 等待进程组号为-pid中的某个子进程退出
-1 等待任意一个子进程
==0 等待本进程组中的某个子进程退出
> 0 等待PID为pid的进程
stat_loc-----》存放子进程退出状态（可为NULL）
options ----》一般设置为0
WNOHANG 当没有子进程时立即返回
WUNTRACED 当有子进程被暂停时立即返回
WCONTINUED 当有子进程收到SIGCONT立即返回
返回值：-1 执行失败
> 0 成功 返回值为被回收的进程的PID
0 指定了WNOHANG，且没有已退出的子进程
1.3.4 프로세스 ID 가져오기 – getpid（1）获取自己的id getpid（）
#include <unistd.h>
pid_t getpid(void); 返回值：就是该进程的id号
（2） 获取父进程id getppid（）
#include <unistd.h>
pid_t getppid(void); 返回值：就是父进程的id号
2장 Linux 다중 프로세스 통신 방법
프로세스 간 통신인지 스레드 간 통신인지 . 공유 리소스 할당(공유 리소스에 대한 다양한 프로세스/스레드 액세스 조정)
2.1 프로세스 간 통신 방법
1. 전통적인 프로세스 간 통신 방법
Unnamed PipeNamed PipeSignal2, System V IPC object
Shared memoryMessage queue- Semaphore
- 3, BSD
- 2.1.1 이름 없는 파이프 파이프
- 1. 특징: 프로세스 간 가장 독창적인 통신 방법
- 친화성
이름이 없습니다(존재합니다). );
Linux와 Windows 간의 공유에서 생성할 수 있지만(파이프 파일은 전혀 생성되지 않음) 명명된 파이프는 생성할 수 없습니다(파이프 파일이 생성됨).- 2. 이름 없는 파이프 사용 (1) 파이프 만들기()
#include <unistd.h>
int pipe(int fildes[2]);
参数：fildes[2]里面放的是两个文件描述符fildes[0]，fildes[1]
fildes[0] 读端
fildes[1] 写端
返回值：成功返回0 失败返回-1 (2) 파이프 정보 보내기 및 받기myid = fork(); //创建子进程
if(myid == 0)
{
write(fd[1],"dad,thanks!",20); //子进程向父进程发送消息
close(fd[1]);
close(fd[0]);
exit(0);
}
else if(myid > 0)
{
read(fd[0],buf,20); //父进程阻塞接受子进程消息
printf("buf is:%s\n",buf);
close(fd[1]);
close(fd[0]);
}
2.1.2 이름 있는 파이프(FIFO)
1. 모든 것이 괜찮습니다
Linux와 Windows 간의 공유에서는 생성할 수 없습니다.
유명한 파이프
(일반적으로 access() 함수는 코드에서 존재 여부를 확인하는 데 사용됩니다. 동일한 이름의 파이프가 이미 존재하는 경우 다시 생성할 수 없습니다.)
닫는 것을 잊지 마세요. 사용 후; 파이프가
읽기 전용인 경우모드로 열리면 다른 프로세스가
쓰기 전용- 모드로 파이프를 열 때까지 차단됩니다. 그런 다음 읽기로 열리면 차단되지 않습니다. -쓰기 모드에서는 차단되지 않습니다.
- 전이중 통신, 반이중.
- 2. 유명 파이프 활용 (1) mkfifo()
#include <sys/types.h> #include <sys/stat.h> int mkfifo(const char *pathname, mode_t mode); 参数：pathname 有名管道的路径名 mode：权限 0666 返回值：0 成功 -1 失败 생성 (2) FIFO 프로세스 정보 송수신 fifo_read.c :-----------》 #define FIFO1 "myfifo1" #define FIFO2 "myfifo2" int main(void) { int my_fd,fd1,fd2; char r_buff[30]; char w_buff[30]; bzero(r_buff,30); if(access(FIFO1,F_OK)==-1) { my_fd = mkfifo(FIFO1,0664); //创建管道1 if(my_fd == -1) { perror("failed!\n"); return -1; } } if(access(FIFO2,F_OK)==-1) { my_fd = mkfifo(FIFO2,0664); //创建管道2 if(my_fd == -1) { perror("failed!\n"); return -1; } } fd1 = open(FIFO1,O_RDONLY); //只读打开管道1，获取管道文件描述符 if(fd1==-1) { printf("open fifo1 file failed!\n"); exit(0); } fd2 = open(FIFO2,O_WRONLY); //只写打开管道2，获取管道文件描述符 if(fd2==-1) { printf("open fifo2 file failed!\n"); exit(0); } while(1) { bzero(r_buff,30); read(fd1,r_buff,sizeof(r_buff)); //读取管道1的消息 printf("client receive message is: %s\n",r_buff); printf("client please input a message!\n"); fgets(w_buff,30,stdin); write(fd2,w_buff,30); //发送信息给管道2 } close(fd2); close(fd1); return 0; } fifo_write.c :-----------》 #define FIFO1 "myfifo1" #define FIFO2 "myfifo2" int main(void) { int my_fd,fd1,fd2; char w_buff[30]; char r_buff[30]; bzero(w_buff,30); if(access(FIFO1,F_OK)==-1) { my_fd = mkfifo(FIFO1,0664); if(my_fd == -1) { perror("failed!\n"); return -1; } } if(access(FIFO2,F_OK)==-1) { my_fd = mkfifo(FIFO2,0664); if(my_fd == -1) { perror("failed!\n"); return -1; } } fd1 = open(FIFO1,O_WRONLY); if(fd1==-1) { printf("open fifo1 file failed!\n"); exit(0); } fd2 = open(FIFO2,O_RDONLY); if(fd2==-1) { printf("open fifo2 file failed!\n"); exit(0); } while(1) { bzero(w_buff,30); printf("server please input a message!\n"); fgets(w_buff,30,stdin); write(fd1,w_buff,strlen(w_buff)); //写入消息到管道1文件 read(fd2,r_buff,30); //读取信息从管道2 printf("server receive message is:%s\n",r_buff); } close(fd1); close(fd2); return 0; }- 2.1.3 시그널 싱글 프로그램(프로세스)이 실행되는 동안, 외부 세계는 그렇지 않습니다. 신호는 정기적으로 프로그램에 전송됩니다. 이때 프로그램은 두 가지 선택에 직면합니다: 무시(차단/무시) 차단: 신호를 끊고 프로그램 실행이 끝날 때까지 기다리는 것을 의미합니다. 응답하기 전에
- 무시: 신호 삭제 응답하기
1 Linux의 신호는 무엇입니까: kill -l 보기
1) SIGHUP 2) SIGINT 3) SIGQUIT 4) SIGILL 5) SIGTRAP 6) SIGABRT 7) SIGBUS 8) SIGFPE 9) SIGKILL 10) SIGUSR1 11) SIGSEGV 12) SIGUSR2 13) SIGPIPE 14) SIGALRM 15) SIGTERM 16) SIGSTKFLT 17) SIGCHLD 18) SIGCONT 19) SIGSTOP 20) SIGTSTP 21) SIGTTIN 22) SIGTTOU 23) SIGURG 24) SIGXCPU 25) SIGXFSZ 26) SIGVTALRM 27) SIGPROF 28) SIGWINCH 29) SIGIO 30) SIGPWR 31) SIGSYS 34) SIGRTMIN 35) SIGRTMIN+1 36) SIGRTMIN+2 37) SIGRTMIN+3 38) SIGRTMIN+4 39) SIGRTMIN+5 40) SIGRTMIN+6 41) SIGRTMIN+7 42) SIGRTMIN+8 43) SIGRTMIN+9 44) SIGRTMIN+10 45) SIGRTMIN+11 46) SIGRTMIN+12 47) SIGRTMIN+13 48) SIGRTMIN+14 49) SIGRTMIN+15 50) SIGRTMAX-14 51) SIGRTMAX-13 52) SIGRTMAX-12 53) SIGRTMAX-11 54) SIGRTMAX-10 55) SIGRTMAX-9 56) SIGRTMAX-8 57) SIGRTMAX-7 58) SIGRTMAX-6 59) SIGRTMAX-5 60) SIGRTMAX-4 61) SIGRTMAX-3 62) SIGRTMAX-2 63) SIGRTMAX-1 64) SIGRTMAX
（1）1到31号信号称作非实时信号：不支持队列（如果同时来了多个信号，响应是没有规律）
（2）用户自定义的信号 10) SIGUSR1 12) SIGUSR2
（3） 34到64号信号叫做实时信号：支持队列，是linux系统中后面添加进来的信号
信号类似于中断： 硬件 软件
以上信号有两个很特殊：SIGKILL，SIGSTOP不能够被忽略，也不能被阻塞
2、信号相关的操作函数
（1）发送信号kill（）
#include <signal.h> int kill(pid_t pid, int sig); 参数： pid ----》进程的id 正数：要接收信号的进程的进程号 0：信号被发送到所有和pid进程在同一个进程组的进程 -1：信号发给所有的进程表中的进程(除了进程号最大的进程外) sig ----》信号名字 返回值：0 成功 -1 出错
（2）信号的捕捉 signal（）
#include <signal.h>
void (*signal(int sig, void (*func)(int)))(int); // SIGKILL
参数：sig ----》你需要捕捉的那个信号
void (*func)(int) ----》函数指针,回调函数，捕捉到对应的信号的时候就调用该函数；第二个参数除了可以传递一个函数指针意外，还可以使用以下两个宏定义：
SIG_IGN ---->你捕捉到的那个信号会被忽略
SIG_DFL-----》你捕捉的信号会采用系统默认的方式响应
返回值：成功：设置之前的信号处理方式
出错：-1（3）等待信号 pause（）
#include <unistd.h> int pause(void); 返回值：-1 把error值设为EINTR 0 成功
（4）信号的阻塞
每个进程都有属于它自己的一个信号掩码（也就是该进程在运行的过程中会阻塞掉的那些信号就被称作信号掩码）。
关于信号掩码操作的一系列函数：
#include <signal.h>
int sigemptyset(sigset_t *set)：清空信号掩码
int sigfillset(sigset_t *set)：将所有的信号添加到信号掩码中
int sigaddset(sigset_t *set, int signum)：将特定的信号添加到信号掩码中
int sigdelset(sigset_t *set, int signum)：将特定的信号从掩码中删除
int sigismember(const sigset_t *set, int signum)：判断某个信号在不在该掩码中
参数：sigset_t ----》存储被进程阻塞的信号（5）配置信号掩码 sigprocmask（）—阻塞或解除阻塞信号
#include <signal.h>
int sigprocmask(int how, const sigset_t *restrict set, sigset_t *restrict oset)
参数：
how ---》SIG_BLOCK 将set所包含的信号添加到原来的信号掩码中
SIG_SETMASK 用set去替换原来的信号掩码
SIG_UNBLOCK 将set中包含的信号从原来的掩码中删除
set ---》新的信号掩码
oset ---》原本的信号掩码
原本进程中信号掩码包含了：SIGINT ,SIGCONT（6）捕捉指定信号并获取信号携带信息sigaction（）
#include <signal.h>
int sigaction(int sig, const struct sigaction *restrict act, struct sigaction *restrict oact);
参数：
sig ---》你要捕捉的那个信号
act ---》你需要捕捉的信号对应的响应函数就定义在这个结构体
oact ---》原来的
struct sigaction
{
void(*) (int) sa_handler ----》 信号的响应函数
sigset_t sa_mask ---》信号的掩码
int sa_flags ----》 SA_SIGINFO
void(*) (int, siginfo_t * ，void ）---》信号的响应函数
}
sa_flags ---》等于SA_SIGINFO，那么信号的响应函数是void(*) (int, siginfo_t * ，void ）
不等于，那么信号的响应函数是void(*) (int)
siginfo_t---》/usr/include/i386-linux-gnu/bits/siginfo.h 保存的是信号的状态信息，信号的标号，发送该信号的进程的id等等这些2.1.4 共享内存
查看共享内存: ipcs -m
删除共享内存: ipcrm -m 共享内存的id
SYSTEM-V ipc通信方式：共享内存、信号量、消息队列。
1、共享内存特点：跟mmap（）思想上有些类似
- 在进程通信方式中共享内存是效率最高的，进程可以直接读写内存，而不需要任何数据的拷贝；
- 如果代码不人为地删除共享共享内存，那么程序退出的时候它还在；
多个进程共享一段内存，因此也需要依靠某种同步机制，如互斥锁和信号量等
2、共享内存对应的一系列操作函数
（1）创建共享内存：shmget（）
#include <sys/shm.h>
int shmget(key_t key, size_t size, int shmflg);
返回值：成功—共享内存对象的mid（标识符） 出错—-1
参数：key----》创建共享内存需要用到的键值
size----》内存空间的大小（字节）
shmflg----》设置属性 IPC_CREAT IPC_EXCL 0666组合
key键值的获取有两种方法：
**方法一**：使用ftok（）生成键值
#include <sys/types.h>
#include <sys/ipc.h>
key_t ftok(const char *pathname, int proj_id);
参数：pathname----》 路径名
proj_id----》整数
ftok(“.” , 11) 生成一个唯一的key值
进程1：ftok(“.” , 11) ----》shmget( 100);.............
进程2：ftok(“/home/gec” , 11) ----》shmget( 106);
无法通信，要确保键值一致才能通信
**方法二：**不使用ftok（），程序员自己写个数字
shmget((key_t)1234, size_t size, int shmflg);（2） 映射共享内存到用户空间 shmat（）
#include <sys/shm.h>
void *shmat(int shmid, const void *shmaddr, int shmflg);
返回值：成功—映射到用户空间的那片地址的首地址 出错—-1
参数：shmid ----》使用shmget的返回值
shmaddr----》一般设置为NULL 系统自动分配
shmflg----》 SHM_RDONLY：共享内存只读
一般设置为0: 共享内存可读写
if it is 0 and the calling process has read and write permission, the segment is attached for reading and writing.（3）解除映射：shmdt（）
#include <sys/shm.h> int shmdt(const void *shmaddr); 参数：shmaddr----》 shmat（）共享内存映射后的地址 返回值：成功—0 出错—-1
（4）删除共享内存：shmctl（）
#include <sys/shm.h>
int shmctl(int shmid, int cmd, struct shmid_ds *buf);
参数： shmid----》共享内存的id
cmd----》IPC_RMID 删除共享内存
IPC_STAT (获取对象属性)
IPC_SET (设置对象属性)
*buf----》指定IPC_STAT/IPC_SET时保存共享内存的状态信息
返回值：成功 失败—-1
3、共享内存简单示例
shm_write.c :----------》
int main() {
int shmid;
int *p;
// 创建共享内存
shmid = shmget((key_t)456,1024,IPC_CREAT|IPC_EXCL|0666);
if((shmid == -1)&&(errno == EEXIST)) {
shmid = shmget((key_t)456,1024,0666);
}
// 映射共享内存到进程
p = (int *)shmat(shmid,NULL,0);
*p = 10;
// 解除映射
shmdt(p);
// 删除内存
//shmctl(shmid,IPC_RMID,NULL);
return 0;
}
shm_read.c :----------》
int main() {
int shmid;
int *p;
// 创建共享内存
shmid = shmget((key_t)456,1024,IPC_CREAT|IPC_EXCL|0666);
if((shmid == -1)&&(errno == EEXIST)) {
shmid = shmget((key_t)456,1024,0666);
}
// 映射共享内存到进程
p = (int *)shmat(shmid,NULL,0);
printf("p is :%d\n",*p);
// 解除映射
shmdt(p);
// 删除内存
shmctl(shmid,IPC_RMID,NULL);
return 0;
}2.1.5消息队列
消息队列就是一个消息的列表。用户可以在消息队列中添加消息、读取消息等。
消息队列由消息队列ID来唯一标识
消息队列可以按照类型来发送/接收消息
消息队列的操作包括创建或打开消息队列、添加消息、读取消息和控制消息队列
1、消息队列的特点
写入消息队列的信息，在编写程序的时候会人为的去设置消息的类型（用整数来表示），目的是为了其它进程在读取信息的时候能够准确地通过消息的类型判断要读取的信息。
2、消息队列操作的系列函数
（1）消息队列的创建 msgget（）
#include <sys> int msgget(key_t key, int msgflg);</sys>
（2）消息队列的收发信息msgsnd（）msgrcv（）
#include <sys/msg.h>
int msgsnd(int msqid, const void *msgp, size_t msgsz, int msgflg);
参数：void *msgp ----》你要发送信息就存储在这个指针中
在实际的编程中我们都是定义一个结构体来存储信息
struct msgbuf {
long mtype; ----》消息的类型
char mtext[100]; ----》消息的内容
}
msgsz ----》消息的长度，大小
msgflg ----》设置为0 除开以上三种宏定义之外的----阻塞读写
（3）消息队列的删除 msgctl（）
#include <sys/msg.h> int msgctl(int msqid, int cmd, struct msqid_ds *buf);
3、消息队列通信简单示例
pthread1.c :-----------》
#define SIZE 64
//数据接收结构体
struct msg_rv
{
int mtype;
char msg[50];
};
//数据发送结构体
struct msg_snd
{
int mtype;
char msg[50];
};
int main(void) {
int msgid;
struct msg_rv data;
struct msg_snd snddata;
char buff[50];
//获取msgid
msgid = msgget((key_t)123,IPC_CREAT|0666);
if(msgid == -1) {
printf("msgid failed!\n");
return -1;
}
data.mtype = 88;
snddata.mtype = 89;
while(1) {
bzero(buff,50);
printf("please input data!\n");
fgets(buff,50,stdin);
strcpy(snddata.msg,buff);
if(strncmp(snddata.msg,"end",3)==0) {
break;
}
msgsnd(msgid,(void *)&snddata,strlen(buff)+4,0);//得到的值发送出去
usleep(20);
printf("run here!\n");
if(msgrcv(msgid,(void *)&data,sizeof(struct msg_rv),data.mtype,0)==-1) {
printf("msgsnd failed!\n");
return -1;
}
printf("receive data:%s\n",data.msg);
if(strncmp(data.msg,"end",3)==0) {
break;
}
}
//撤消消息队列
msgctl(msgid,IPC_RMID,0);
return 0;
}
pthread2.c :------------------------》
#define SIZE 64
//数据接收结构体
struct msg_rv
{
int mtype;
char msg[50];
};
//数据发送结构体
struct msg_snd
{
int mtype;
char msg[50];
};
int main(void)
{
int msgid;
struct msg_rv data;
struct msg_snd snddata;
char buff[50];
data.mtype = 89;
snddata.mtype = 88;
//获取msgid
msgid = msgget((key_t)123,IPC_CREAT|0666);
if(msgid == -1) {
printf("msgid failed!\n");
return -1;
}
while(1) {
//接受
if(msgrcv(msgid,(void *)&data,sizeof(struct msg_rv),data.mtype,0)==-1)
{
printf("msgsnd failed!\n");
return -1;
}
printf("receive data:%s\n",data.msg);
if(strncmp(data.msg,"end",3)==0) {
break;
}
//发送
printf("please input data:\n");
bzero(buff,50);
fgets(buff,50,stdin);
strcpy(snddata.msg,buff);
printf("data = %s\n",snddata.msg);
if(strncmp(snddata.msg,"end",3)==0) {
break;
}
msgsnd(msgid,(void *)&snddata,strlen(buff)+4,0);//得到的值发送出去
printf("run here!\n");
}
//撤消消息队列
msgctl(msgid,IPC_RMID,0);
return 0;
}2.1.6 信号量
信号量协调不同进程对于共享资源的访问，它是不同进程间或一个给定进程内部不同线程间同步的机制。
1、信号量概述
（1）二值信号量
值为0或1。与互斥锁类似，资源可用时值为1，不可用时值为0
（2）计数信号量
值在0到n之间。用来统计资源，其值代表可用资源数
（3）对信号量的操作
P操作：即申请资源，亦即将信号量值减1，可能引起进程睡眠。
V操作：即释放资源，亦即将信号量值加1，V操作从不会睡眠。
等0操作：不申请也不释放资源，而是令进程阻塞直到信号量的值为0为止
2、信号量相关的接口函数
（1） 创建信号量集合semget（）
#include <sys/sem.h>
int semget(key_t key, int nsems, int semflg);
参数：key ----》键值
nsems----》你创建的信号量集中信号量的个数
semflg----》 IPC_CREAT|0666组合
返回值：成功—信号量ID
出错—-1（2）设置/删除信号量集 semctl（）
#include <sys/sem.h>
int semctl(int semid, int semnum, int cmd, ...);
返回值：成功—0 失败—-1
（3）信号量的PV操作 semop（）
核心：信号量为 p 减一操作
v 加一操作
#include <sys/sem.h>
int semop(int semid, struct sembuf *sops, size_t nsops);
返回值：成功—0 出错—-1
参数：semid ----》semget的返回值
nsops ---》要操作的信号量的个数(结构体的个数)
sops---》信号量操作结构体
struct sembuf {
short sem_num ;=>> 要操作的信号量的编号（数组下标）
short sem_op; =>> 0 : 等待，直到信号量的值变成0
1 : 释放资源，V操作
-1 : 分配资源，P操作
short sem_flg; =>> 0/IPC_NOWAIT/SEM_UNDO
SEM_UNDO: 程序结束时(不论正常或不正常)，保证信号值会被重设为semop()调用前的值;
IPC_NOWAIT: 对信号的操作不能满足时，semop()不会阻塞，并立即返回，同时设定错误信息;
};3、信号量协同共享内存示例代码
pthread1.c :-----------》
int main()
{
int semid;
int shmid;
char *p;
struct sembuf mysembuf1,mysembuf2;
mysembuf1.sem_num = 0;
mysembuf1.sem_flg = SEM_UNDO;
mysembuf1.sem_op = 1;
mysembuf2.sem_num = 1;
mysembuf2.sem_flg = SEM_UNDO;
mysembuf2.sem_op = -1;
// 创建信号量集合
semid = semget((key_t)789,2,IPC_CREAT|0666);
if(semid == -1) {
perror("creat sem failed!\n");
return -1;
}
// 创建共享内存
shmid = shmget((key_t)456,1024,IPC_CREAT|IPC_EXCL|0666);
if((shmid == -1)&&(errno == EEXIST)) {
shmid = shmget((key_t)456,1024,0666);
}
// 映射共享内存到进程
p = (char *)shmat(shmid,NULL,0);
while(1) {
semop(semid,&mysembuf2,1); // 对信号量2进行p操作（减一）
printf("the message I recv is:%s\n",p);
printf("please input a message!\n");
scanf("%s",p);
printf("message is %s\n",p);
semop(semid,&mysembuf1,1); // 对信号量1进行v操作（加一）
}
//解除映射
shmdt(p);
//删除共享内存
shmctl(semid, IPC_RMID, NULL);
}
pthread2.c :-----------》
int main() {
int semid;
int shmid;
char *p;
struct sembuf mysembuf1,mysembuf2;
mysembuf1.sem_num = 0; // 信号集合中的第一个信号
mysembuf1.sem_flg = SEM_UNDO;
mysembuf1.sem_op = -1; //p操作
mysembuf2.sem_num = 1; // 信号集合中的第二个信号
mysembuf2.sem_flg = SEM_UNDO;
mysembuf2.sem_op = 1; // v操作
// 创建信号量集合
semid = semget((key_t)789,2,IPC_CREAT|0666);
if(semid == -1) {
perror("creat sem failed!\n");
return -1;
}
// 设置信号量的值
semctl(semid,0,SETVAL,1); //第一个信号量初值为1
printf("sem num is:%d\n",semctl(semid,0,GETVAL));
semctl(semid,1,SETVAL,0); //第二个信号量初值为0
printf("sem num is:%d\n",semctl(semid,1,GETVAL));
// 创建共享内存
shmid = shmget((key_t)456,1024,IPC_CREAT|IPC_EXCL|0666);
if((shmid == -1)&&(errno == EEXIST)) {
shmid = shmget((key_t)456,1024,0666);
}
// 映射共享内存到进程
p = (char *)shmat(shmid,NULL,0);
while(1) {
semop(semid,&mysembuf1,1); // 对信号量1进行p操作（减一）不阻塞，因为初值为1
// 执行完这句话以后信号量的值就立马变成1
printf("the message I recv is:%s\n",p);
printf("please input a message!\n");
scanf("%s",p);
printf("message is %s\n",p);
semop(semid,&mysembuf2,1); // 对信号量2进行v操作（加一）不阻塞，因为初值为0
}
//解除映射
shmdt(p);
//删除共享内存
shmctl(semid, IPC_RMID, NULL);
}
- ipcs -q 查看消息队列
- ipcrm -q MSG_ID 删除消息队列
- ipcs -m 查看共享内存
- ipcrm -m SHM_ID 删除共享内存
- ipcs -s 查看信号量
- ipcrm -s SEM_ID 删除信号量
- pipe: 具有亲缘关系的进程间，单工，数据在内存中
- fifo: 可用于任意进程间，双工，有文件名，数据在内存
- signal: 唯一的异步通信方式
- msg：常用于cs模式中， 按消息类型访问 ，可有优先级
- shm：效率最高(直接访问内存) ，需要同步、互斥机制
- sem：配合共享内存使用，用以实现同步和互斥
推荐学习：Linux视频教程
위 내용은 리눅스가 여러 프로세스를 만들 수 있나요?의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!