进程与线程的同步与互斥

进程间通信 




1、早期的古老通信模式： 管道  信号 ====》os都支持


2、较新 IPC 对象： 消息队列 共享内存 信号量集 ===》system V   POSIX


3、BSD 系列： socket   ====》网络




管道：===》无名管道 有名管道


无名管道 ===》管道 ====》通信管道


1、只能用于具有亲缘关系的进程间使用。
2、半双工通信，有固定的读端和写端。
3、特殊的系统文件，可以支持文件IO。
4、管道的数据存储方式类似队列，先进先出。
5、管道的默认容量大小是64k字节 ===》ulimit -a ====>4k 早期的大小
6、管道默认的读操作会阻塞等待，如果写操作满了的时候也会阻塞等待。
7、管道的读端存在时候，写管道才有意义，否则程序会退出。




无名管道的使用：


1、管道的创建与打开
int pipe(int fd[2]) ;
功能：通过该函数可以创建一个无名管道，同时打开该管道。
参数： fd[2]  要操作的管道名称，有两个元素
fd[0]  管道的固定的读端
fd[1]  管道的固定的写端


返回值： 成功 0
失败  -1


注意：在创建新的进程之前就应该先创建管道，之后之间的资源可以
通过管道传递。










2、管道的读写


读： ssize_t read(int fd, void * buff,size_t count );
从fd中读count个字节的数据到buff中。


写： ssize_t  write(int fd, const void * buff,size_t count)
从buff中取count个字节的数据写入到fd文件中。


3、管道的关闭


close（fd[0]）；
close(fd[1]);




小练习：使用无名管道完成父子进程间发送信息，要求父进程动态获取用户的输入并写入到管道的写端。
     子进程从管道的读端获取用户的输入信息，并打印输出到终端。
当输入“quit” 程序整体结束。





///////////////////////////////////////////////////////////////////////////////////////////////////


有名管道 ===》相同的管道特性


特点：1、可以用于不同进程间通信，不限于必须有亲缘关系。




管道的操作流程：


1、管道的创建 =====》mkfifo
int mkfifo(const char * filename,mode_t mode);
功能：通过该函数可以创建一个有名管道的设备文件出来。
参数：filename 要创建的管道名称+ 路径
mode  创建的管道的文件权限。
返回值： 成功 0
失败  -1；


2、管道的打开 =====》open
int open(const char * filename,int flag);
参数： filename要打开的有名管道文件名称
      flag == 》O_RDONLY  只读  
O_WRONLY  只写
O_RDWR  不能用。




3、管道的读写  ====>read  write


读： ssize_t read(int fd, void * buff,size_t count );
从fd中读count个字节的数据到buff中。


写： ssize_t  write(int fd, const void * buff,size_t count)
从buff中取count个字节的数据写入到fd文件中。


4、管道的关闭  ====>close


close（fd）；


5、管道的卸载  ====>unlink
int unlink(const char * pathname);
功能：卸载或者删除已经创建的有名管道文件
参数： pathname 要卸载的管道文件名称+路径
返回值： 成功  0
失败 -1；






小练习： 编写程序从主函数传参的方式创建有名管道，并在该程序中获取用户输入的信息。写到有名管道中。
编写另一个程序，循环从有名管道中读取数据，并将数据实时打印到终端。




2、将fifo的创建和删除操作写成通用的工具，允许用户的指定创建和删除，比如
./fifo_tool -C  fifo ====>会在当前目录下创建一个名称为fifo的有名管道文件
./fifo_tool -D  fifo ===>会删除当前目录下的名称为fifo的管道文件。








//////////////////////////////////////////////////////////////////////////////


信号的发送


kill 函数 =====》支持的信号列表 kill -l ====>所有当前系统支持的默认信号

头文件： signal.h   sys/types.h
函数：  int  kill(pid_t pid,int sig);
功能：给指定的pid进程发送sig信号。
参数：pid要接收信号的进程id
sig 要发送的信号编号 ====》kill -l 中的信号
kill -l 中前32 属于系统原始信号，也叫不稳定信号
 后32个属于稳定信号。
返回值： 成功 0
 失败 -1；




int raise(int sig);
功能：进程可以自己通过该函数给自己发送信号。
参数：sig 要发的信号的编号
返回值：成功 0
失败 -1；




闹钟函数和暂停函数

暂停函数 ====》pause() ====>while(1){sleep(1);}

int pause(void ) ====>执行该函数后程序暂停。


闹钟函数 =====》alarm（） =====》定时时间到了发送 SIGALRM 信号给自己。

unsigned int alarm(unisgned int sec);======>指定间隔sec秒之后给自己发送信号。
默认的SIGALRM 信号会使程序终止运行。



信号的接收处理


三种方式： 默认处理  忽略处理  自定义处理


1、捕获信号和处理


void () (int);======>void fun(int arg);


void (*signal(int signum,void (*handler)(int)))(int);
signal(int signum , test);===>
test == void(*handler)(int);


typedef void (*SIGNAL)(int);
===> void (*signal(int signum,void (*handler)(int)))(int); == SIGNAL signal(int singnum,SIGNAL handler);


简化成： signal(int sig, void fun); ====>信号扑捉处理函数
参数： sig 要处理的信号
fun  信号的处理函数，如果其是：SIG_IGN 表示该程序对所有的信号做忽略处理
     SIG_DFL 表示该程序对所有的信号做默认处理
     fun     表示改程序有一个回调函数用来自定义处理






注意：在所有系统预制的信号列表中，9号SIGKILL 和 19 号的SIGSTOP信号不能被忽略处理。




信号在进程间通信中的缺陷：
1、不能发送大量数据，包括字符串。
2、发送的信号必须是双方约定好的。
3、发送的信号必须是系统预制的范围内的。
4、发送的信号在接收方必须有自定义处理，一般用SIGUSR1 SIGUSER2.其他信号有系统含义 建议不要使用。






key 的获取


1、私有key =====》IPC_PRIVATE === 0X00000000
2、测试key =====》ftok() ====>指定路径+字符
3、自定义key ====》0X12345678 




key_t ftok(const char * pathname ,int pro_id);
功能：通过该函数可以以指定的路径为基本生成一个唯一键值。
参数：pathname 任意指定一个不可卸载的目录同时要求改目录不能被删除重建。
      pro_id  一个数字，或者字符，表示将该值与参数1做运算之后的值作为键值。


返回值：成功  返回唯一键值
失败 -1；




作业：
使用信号通信方式完成指定程序对于用户的自定义信号处理，
如果程序收到SIGUSR1 信号就开始打印连续数据，如果收到SIGUSR2信号则打印停止。
其他所有信号尽量屏蔽。


./a.out   ====>pid = 123


kill -10 123 ===>循环打印数据
kill -12 123 ====>打印停止

kill  -1 123  ====>程序无响应

IPC 对象 


1、查看对象信息 ====》ipcs -a
ipcs -q ====>只查看消息队列的对象信息
ipcs -m  ====>只查看共享内存的对象信息
ipcs -s  ====》只查看信号量的对象信息




基本操作流程：


key  ====>申请或者创建IPC对象====》读写数据 ====》卸载对象


消息队列：


0、头文件：
sys/types.h
sys/ipc.h
sys/msg.h


1、申请消息队列;


int msgget(key_t key ,int flag);
功能：向内核提出申请一个消息队列对象。
参数： key  用户空间的键值
      flag  消息对象的访问权限，但是如果是第一次
向内核提出申请，则需要添加IPC_CREAT 和 IPC_EXCL 


返回值：成功 返回消息对象id
失败 -1




2、消息对象的操作：


发送消息：int msgsnd(int msgid,void * msgp,size_t size ,int flag);
 参数：msgid 要发送到的消息对象id
msgp ====>要发送的消息结构体===》
struct msgbuf
{
long mtype;   ////消息的类型
char mtext[N];////消息的正文，N 自定义的数据大小
}；
size  要发送的消息正文的长度，单位是字节。
flag  = 0  表示阻塞发送
     = IPC_NOWAIT 非阻塞方式发送
返回值：成功  0
失败  -1；



接收消息：
int msgrcv(int msgid,void * msgp,size_t size,long type,int flag);
参数： msgid 要接收到的消息对象id
msgp ====>要接收的消息结构体变量，必须事先定义一个空变量，用来存储数据。
size  ====》要接收的数据长度，一般是 sizeof(msgp);
type  ====>要接收的消息类型
flag  ====》接收消息的方式，0 表示阻塞接收  IPC_NOWAIT 非阻塞接收


返回值：成功  0
失败  -1；



练习：用两个程序完成如下功能：
a.out  ===>用当前路径下的test目录创建消息队列的对象。并向该对象中发送获取到的用户输入信息
b.out ===>用同样的路径下的test目录来获取key值并从该消息对象中接收用户输入的消息。






IPC 对象的操作命令：


ipcs  ===>查看命令   ===》ipcs -a  ipcs -q  ipcs -m   ipcs -s  ===》查看对象的当前信息
 ipcs -l  ipcs -lq  ipcs -lm ipcs -ls ===>查看对象的默认上限值
ipcrm ===>删除命令  ===》ipcrm -q msgid ====>删除消息队列中队列id是msgid的对象
ipcrm -m shmid ====>共享内存对象删除
ipcrm -s  semid ====>信号量集对象删除




3、消息队列对象的卸载：


int msgctl(int msgid,int cmd, struct msgid_ds * buff);
功能：调整消息队列的属性，很多时候用来删除消息队列。
参数： msgid 要操作的消息队列对象id
cmd  ==>IPC_RMID ====>删除消息队列的宏
IPC_SET  ====>设置属性
IPC_STAT ====》获取属性
buff ====》属性结构体
返回值：成功 0
失败 -1；








共享内存的操作流程：
0、头文件：
sys/shm.h


1、key值得创建


2、shmget 向内核申请共享内存对象
int shmget(key_t key ,int size ,int flag);
参数： key  用户空间的唯一键值
size 要申请的共享内存大小
flag  申请的共享内存访问权限，如果是第一次申请，则需要 IPC_CREAT IPC_EXCL;
返回值： 成功 shmid
失败 -1；




3、shmat  将内核申请成功的共享内存映射到本地
void * shmat(int shmid,const void * shmaddr,int flag);
参数： shmid  申请好的共享内存id
shmaddr   ===》NULL 表示由系统自动查找合适的内存映射。
flag  ====》对于挂载之后的内存的操作权限。0  表示可直接读写
SHM_RDONLY   表示只读权限
返回值：成功 返回映射后的可以使用的地址
失败 NULL;




4、读写共享内存 ====》类似操作堆区的方式


5、shmdt  断开本地与共享内存的映射
int shmdt(void * shmaddr);
参数： shmaddr  要断开的已经映射的地址，就是shmat的返回值。
返回值： 成功 0 
失败 -1；




6、shmctl  删除共享内存操作对象
int shmctl(int shmid,int cmd ,struct shmid_ds *buff);
参数： shmid 要删除的共享内存对象
cmd 要操作的宏，IPC_RMID 表示删除对象
IPC_STAT 表示获取对象属性
IPC_SET  表示设置对象属性
buff 属性结构体对象
返回值：成功 0
失败-1
 




信号量集：


0、头文件
sys/sem.h


1、key 唯一键值




2、semget 向内核申请一个信号量集


int semget（key_t key ,int nsems, int flag）;
参数：key  用户空间的唯一键值
     nsems 要申请的信号量个数
     flag  申请信号量的权限，如果是第一次申请则需IPC_CRATE IPC_EXCL;
返回值：成功 0
失败 -1


3、semop 操作信号量 ===》PV 操作 ====》信号量的加一 减一


int semop(int semid,struct sembuf * buff,size_t opts);
参数： semid  要操作的信号量集id
buff要操作的方式方法===》操作结构体
struct sembuf
{
short sem_num;    //要操作的信号量的编号，一般都是从0 编号。
short sem_op;     //要给该信号量进行的操作，1  V操作 释放资源
  -1 P 操作 申请资源
   0  阻塞等待
short sem_flg;    //0  表示阻塞方式执行信号量
          IPC_NOWAIT 表示非阻塞
  SEM_UNDO   表示操作结束后返回原值
}；
    opts 要操作的信号量的个数。
返回值： 成功 0 
失败 -1；






小练习：配合共享内存和信号量集两个方式完成A进程向B进程发送实时的消息，完成基本聊天功能。


要求：当输入quit的时候两个程序都退出
所有的信号量操作模块写成独立函数。分别是 my_sem_wait() my_sem_post();









4、semctl 删除信号量

int semctl(int semid, int semnum,int cmd ...);
功能：通过该函数可以调整信号量集中指定的信号量的属性。
参数：semid 要调整的信号量集的id
     semnum 要调整的信号量编号
     cmd  要执行的动作  IPC_RMID  表示要删除该对象
SETVAL   表示设置信号量的值
GETVAL   表示获取信号量的值
返回值：成功 0
失败 -1
















gdb 调试core文件 ===》如果程序出现 seg... fault


1、先在编译文件的时候 加 -g  参数，使编译后的代码有调试符号。


2、设置系统允许生成core文件 ====》 ulimit -c unlimited


3、启动有问题的程序 执行一次 ===》./a.out   ====>segmentaion fault (core dumped)====>程序出现严重错误并彻底退出


4、gdb a.out core ====>如果错误时在main函数中则能直接定位到错误的准确位置


5、如果处错误的位置不是在main函数中可以用 bt 命令，打印堆栈信息查看函数的调用过程。




作业：


用消息队列的方式完成进程1 给进程2 发送一个完整的文件。











//////////////////////////////////////////////////////////////////////////////////////////////////////
临界值的访问需要保证一致性 ===》互斥锁




操作流程：


1、定义互斥锁
在线程开始之前定义一个全局变量 ====》 pthread_mutex_t mutex;=====>其中mutex 就是互斥锁。



2、初始化互斥锁 ====》一般在定义多线程开始之前。


int  pthread_mutex_init(pthread_mutex_t *mutex,pthread_mutexattr_t * attr);
功能：通过该函数可以将已经定义的互斥锁设置为默认属性的锁。
参数： mutex  定义好的互斥锁
attr 锁子的属性，NULL表示默认属性。
返回值:成功  0
失败  -1；




3、加锁
int pthread_mutex_lock(pthread_mutex_t *mutex);

4、解锁
int pthread_mutex_unlock(pthread_mutex_t *mutex);


以上两个函数一般成对出现，其中mutex参数就是要加锁的锁子。
如果有先lock 则在unlock 之前的所有代码有可以保证属于原子操作
在执行被保护的代码过程中，其他需要用到该代码的程序会阻塞等待。




5、销毁锁


int  pthread_mutex_destroy(pthread_mutex_t * mutex);
功能： 将已经不在使用的互斥锁销毁。
参数：mutex 要销毁的锁
返回值：成功 0
失败 -1；



问题：
1、该程序要表达什么样的用意
2、由几个线程在执行
3、_LOCK_的作用是什么
4、首次执行的结果是什么
5、要看到不同的输出结果要如何修改




线程同步 ===》多个线程 有顺序 配合完成一个任务。


线程同步的对象 ====》posix  无名信号量。====》PV操作


信号量的值是非负整数，主要是二值信号量 ===》0 1 ===》0 阻塞  1 通行。


公共头文件： semaphore.h


信号量的操作流程：


0、信号量的定义：
sem_t  sem; ====>定义一个信号量。


1、信号量的初始化 =====》一般要放到线程创建之前。


int sem_init(sem_t *sem,int pshared, unsigned int value);
功能：通过该函数可以将指定的信号量做初始化赋值。
参数： sem 要初始化的信号量
      pshared  0 线程间使用
非0  进程间使用
value  信号量的初始值，如果是0 表示默认开始就阻塞
   1 表示默认处于允许通过。
返回值： 成功0
失败 -1；




2、信号量的P操作 ====》申请信号量判断是否可用
int sem_wait(sem_t *sem);
功能： 通过该函数可以判断信号量是否可以用，就是判断其当前值是否> 0，如果< 0则
程序会在该函数部分阻塞等待。如果>0 则该函数可以继续执行通过，并且sem= sem-1；


参数：要判断的信号量
返回值： 成功 0 
失败 -1；




3、信号量的V操作 ===》释放信号量，表示可用。
int  sem_post(sem_t * sem);
功能： 该函数可以正常执行通过，并且将指定的信号量sem= sem+1；
参数： sem 要操作的信号量
返回值： 成功 0
失败 -1；






4、辅助函数：
sem_trywait();===》sem_wait() 作用一样用于检测是否有可用信号量，但是不则阻塞。


sem_getvalue();====》获取当前线程的信号量的值。

int sem_getvalue(sem_t *sem ,int *value);
参数： sem 要获取的信号量地址
value 信号量的当前值
返回值：成功 0
失败 -1






可以做个小练习加深印象：
火车票售票系统，要求:用两个子线程分别模拟两个售票窗口，假设有100张车票，现在要求通过
两个窗口均匀的将车票卖出，考虑用信号量或者互斥锁来实现。
不能出现0 票和 小于0 的车票以及大于100 的车票卖出。




思路：应该有两个信号量组成同步操作。
首先要初始化两个信号量，一个要初始化成0  一个要初始化成1
第二开始执行过程中，线程1 和线程2 之间都先做 sem_wait();
第三步，当开始执行的线程执行完毕应该要 sem_post() 对方的信号量，提示他可以卖票了。
第四步，当对端完成卖票后要sem_post() 刚才另一端的信号量，提示对方可卖票了。
如此循环直到所有的票都正常卖出。