嵌入式系统设计——进程间通信（7）
进程管理
嵌入式Linux多任务：进程，线程
硬件条件：单个CPU单个核
单任务：一个任务执行完毕之后，下个任务才能执行
多任务：任务的执行可以被中断，中断之后可以执行其他任务（并发，并行）
单核CPU:并发
多核CPU:并发，并行
进程实现多任务
特点：给每个进程分配独立的地址空间，4G大小（1G内核，3G用户空间）
进程创建方式：fork>exec函数族>system>vfork
进程的退出：exit()库函数/清理缓冲
-exit()系统调用/不清理缓冲
进程的等待：wait();解决僵尸进程
<僵尸进程、孤儿进程、守护进程、控制台进程，后台进程>
学习目标：学会创建多任务进程
进程间通信（IPC）方式
广义上进程间的通信
进程——文件——进程
进程——数据库——进程
例：通过文件进行通信
#include
#include
#include
#include
#include
#include
#include
int main()
{
pid_t pid;
`` pid = fork();
if (pid == -1)
{
perror("fork error!");
exit(1);
}
if (pid == 0)
{
//普通文件
int fd = open("b.txt", O_CREAT | O_WRONLY, 0655);
if (fd == -1)
{
perror("open file error!");
exit(1);
}
char buf[100] = "hello world";
write(fd, buf, strlen(buf));
close(fd);`
}
else if (pid > 0)
{
sleep(1);
int fd = open("b.txt", O_RDONLY);
if (fd == -1)
{
perror("open file error!");
exit(1);
}
char buf[100] = {0};
read(fd, buf, sizeof(buf));
printf("rec buf = %s\n",buf);
close(fd);
return 0;
}
狭义上进程间的通信分为：管道，消息队列，共享内存，信号量，套接字
（1）管道(pipe)
结构简单，只能单向，会发生阻塞，分为无名通道和有名通道
无名通道：只允许具有血缘关系的进程间通信，如父子进程
API: int pipe(int pipefd[2]);
有名通道:允许任意进程间通信
API:i nt mkfifo(const char *pathname,mode_t mode);
#include
#include
#include
#include
#include
#include
#include
int main()
{
pid_t pid;
if (mkfifo("/tmp/p1", 0644) < 0)
{
perror("mkfifo error!");
exit(1);
}
pid = fork();
if (pid == -1)
{
perror("fork error!");
exit(1);
}
if (pid == 0)
{
int fd = open("/tmp/p1", O_WRONLY);
if (fd == -1)
{
perror("open file error!");
exit(1);
}
char buf[100] = {0};
while (1)
{
scanf("%s", buf);
write(fd, buf, strlen(buf));
}
}
else if (pid > 0)
{
int fd = open("/tmp/p1", O_RDONLY);
if (fd == -1)
{
perror("open file error!");
exit(1);
}
char buf[100] = {0};
while (1)
{
int len = read(fd, buf, sizeof(buf));
buf[len] = '\0';
printf("recv = %s\n", buf);
}
}
return 0;
}
（2）消息队列(msg)
消息队列的本质是由内核创建的用于存放消息的链表
特点：传送有格式的消息流；适用于多进程网状交叉通信；能实现大规模数据的通信
**组成：**消息标号+消息正文
API：
int msgget (key_t key,int msgflag) //创建消息队列
int msgsnd (int msqid,const voidmsgp,size_t msgsz,int msgflg) //将消息写入到消息队列
ssize_t msgrcv (int msqid,voidmsgp,size_t msgsz,long msgtyp,int msgflg)//从消息队列读取消息
int msgctl(int msqid,int cmd,struct msqid_ds*buf) //释放消息队列
例：
#include
#include
#include
#include
#include
#include
#include
struct msgbuf
{
/* data */
long id;
char buf[100];
};
int main()
{
pid_t pid;
key_t key;
key = ftok("/tmp/1", 'a');
//msgid消息队列描述符 == 文件描述符
int msgid = msgget(key, IPC_CREAT | 0644);
//int msgid = msgget(IPC_PRIVATE, IPC_CREAT | 0644);
if (msgid < 0)
{
perror("msg get error!");
exit(1);
}
pid = fork();
if (pid < 0)
{
perror("fork error!");
exit(1);
}
if (pid == 0)
{
//msgid
struct msgbuf msg;
msg.id = 1;
strcpy(msg.buf, "hello world");
msgsnd(msgid, &msg, sizeof(struct msgbuf), 0);
msg.id = 2;
strcpy(msg.buf, "hello world2");
msgsnd(msgid, &msg, sizeof(struct msgbuf), 0);
msg.id = 3;
strcpy(msg.buf, "hello world3");
msgsnd(msgid, &msg, sizeof(struct msgbuf), 0);
}
else if (pid > 0)
{
//msgid
struct msgbuf msg;
msgrcv(msgid, &msg, sizeof(struct msgbuf), 2, 0);
printf("recv:%s\n", msg.buf);
wait(NULL);
msgctl(msgid,IPC_RMID,NULL);
}
return 0;
}
（3）共享内存(shm)
让同一块物理内存被映射到进程A、B各自的进程地址空间。进程A可以即时看到进程B对共享内存中数据的更新
特点：减少进行内核空间访问次数；直接使用地址来读写缓存时，效率会更高，适用于大数据量的通信
API：
int shmget(key_t,size_t size,int shmflg)
void *shmat(int shmid,const void *shmaddr,int shmflg)
int shmdt(const void *shmaddr)
int shmctl(int shmid,int cmd,struct shmid_ds *buf)
例：
#include
#include
#include
#include
#include
#include
#include
int main()
{
pid_t pid;
key_t key;
key = ftok("/tmp/kk", 'k');
int shmid = shmget(key, 1024, IPC_CREAT | 0644);
if (shmid < 0)
{
perror("shm get error!");
exit(1);
}
pid = fork();
if (pid < 0)
{
perror("fork error!");
exit(1);
}
if (pid == 0)
{
//shmid
void *addr = shmat(shmid, NULL, 0);
char buf[100] = {0};
while (1)
{
scanf("%s", buf);
strcpy((char *)addr, buf);
sleep(1);
}
}
else if (pid > 0)
{
//shmid
sleep(1);
void *addr = shmat(shmid, NULL, 0);
while (1)
{
if (strlen((char *)addr) > 0)
{
printf("recv = %s\n", (char *)addr);
}
else
{
printf("no data!");
}
sleep(1);
}
}
return 0;
}
(4)信号量(sem)
当多个进程/线程进行共享操作时，用于资源保护，以防止出现相互干扰的情况；
资源保护的操作：互斥、同步（通过加锁）；
信号量其实是OS创建的一个共享变量，进程在进行操作之前，会先检查这个变量的值，这变量的值就是一个标记，通过这个标记就可以知道可不可以操作，以实现互斥；
API：
int semget(key_t key, int nsems, int semflg);
int semctl(int semid, int semnum, int cmd, …);
int semop(int semid, struct sembuf *sops, unsigned nsops);
例：
#include
#include
#include
#include
#include
#include
#include
#include
int main()
{
pid_t pid;
key_t key = ftok("/tmp/5", 'p');
int semid = semget(key, 1, IPC_CREAT | 0644);
if(semid < 0)
{
perror("sem get error!");
exit(1);
}
if(semctl(semid,0,SETVAL,1) < 0)
{
perror("semctl error!");
exit(1);
}
if ((pid = fork()) < 0)
{
perror("frok error!");
exit(1);
}
//b.txt
if (pid == 0)
{
//"hello world\n"
int fd = open("b.txt", O_WRONLY);
if (fd == -1)
{
perror("open file error!");
exit(1);
}
struct sembuf sem;
sem.sem_num = 0;
sem.sem_flg = SEM_UNDO;
while (1)
{
//-1 p
sem.sem_op = -1;
semop(semid,&sem,1);
write(fd, "hello", 5);
write(fd, "world", 5);
write(fd, "\n", 1);
sem.sem_op = +1;
semop(semid,&sem,1);
//v
//+1
//sleep(1);
}
}
else if (pid > 0)
{
int fd = open("b.txt", O_WRONLY);
if (fd == -1)
{
perror("open file error!");
exit(1);
}
struct sembuf sem;
sem.sem_num = 0;
sem.sem_flg = SEM_UNDO;
while (1)
{
//-1
sem.sem_op = -1;
semop(semid,&sem,1);
write(fd, "hhhhh", 5);
write(fd, "wwwww", 5);
write(fd, "\n", 1);
sem.sem_op = +1;
semop(semid,&sem,1);
//+1
//sleep(1);
}
}
return 0;
}
(5)套接字