什么是进程?

0 |2 m7 P/ _$ \$ ]1 a; }在Linux系统中，进程是管理事务的基本的过程。进程拥有自己独立的处理环境和系统资源。进程整个生命可以简单划分为三种状态：

1 R+ F! q7 G" B6 L& k" J  a' g5 [6 g

就绪态:
' A# b$ |+ s9 G* }3 U  \进程已经具备执行的一切条件，正在等待分配CPU的处理时间。
执行态:
8 {/ q4 ~/ U. V( }9 d/ T该进程正在占用CPU运行。
, X0 m- Z$ w. k$ b$ A等待态:
0 X/ K( ~% q/ y5 ~# w3 o3 k进程因不具备某些执行条件而暂时无法执行的状态。

  ~/ o! \6 r) v! s2 F8 X1 O

进程间通信概念

7 y4 i$ W4 K1 p7 W& R3 f7 T' _进程是一个独立的资源分配单元，不同进行之间的资源是独立的，不能在一个进程中直接访问另一个进程的资源。所以不同的进程需要进行信息的交互状态的传递等，因此需要进程间通信。LINUX常见的进程间通信如下：
, E" k" b) G8 F8 I

1.管道
. w! H" n. Y1 X" I* m, }8 l2.命名管道
, z7 A5 U: h6 j- Y4 \% ~3.消息队列
4.信号量
5.共享内存
6.套接字

1~5都是同一个主机进程间通信。序号6是不同主机（网络）进程间通信；

+ Y/ s4 ]+ r; B# o( F

管道

管道又称无名管道。是一种古老的IPC通信形式，管道的作用正如其名，需要通信的两个进程在管道的两端；管道是一种特殊类型的文件，存在于内核的缓冲区。管道有如下的特点:
2 i8 j# x8 @4 y" [$ f7 Y  F1.半双工，数据不能在两段上传数据，数据只能在一个方向流动。
2.管道不是普通的文件，不属于某个文件系统，只存在于内存中。
3.管道没有名字，只能在亲缘关系的父子进程之间通信。

pid_t fork(void);
, I1 C1 R0 A& ~

( _& N4 b3 Q$ k# @# P1 R6 b) B9 Dfork()函数得到的子进程是父进程的复制品，它从父进程处继承了整个进程的地址空间。
' w; {' F/ j) a) d' ?) s
+ @5 {; N, ?' ], f5 d+ D) p, R

返回值

& Z- X( e2 V7 b2 U  W0 t  @当成功完成时，fork()将返回0给子进程，并将子进程的进程ID返回给父进程。这两个进程都应该继续从fork()函数执行。否则，-1将返回给父进程，不创建子进程，并将errno设置为指示错误。

6 x1 |7 W- k* M4 F

int pipe(int fildes[2]);

pipe()函数应该创建一个管道，并将两个文件描述符放入参数fildes[0]和fildes[1]中，每个文件描述符都引用管道读写端打开的文件描述。

返回值

成功完成后，返回0;否则，将返回-1并设置errno表示错误，不分配任何文件描述符，不修改fildes的内容。
( y) a* l- e- `- L% i+ n
% C& }6 E8 p8 X( c% m" }3 G" _fork函数执行结果

: c4 ]: _6 C3 o  o2 q" G

举个简答例子，使用了pipe()函数来创建管道,通过无名管道通信：

#include <stdio.h>
3 r$ I$ K0 ?0 _#include <unistd.h>//pipe , fork
9 Y$ l7 S  x+ r$ r#include <sys/types.h>
) C' W* ^; c2 m7 z4 j5 T  d0 @#include <string.h>//memset
0 E: m' i, B5 [! X' O* K
int main(int argc, char const *argv[])
$ w8 @9 K+ P( B  D3 W, x! a- g! z/ Y5 Z{
6 X  H4 Z, {/ r  _7 [2 h
2 U* J( u$ n; x% o    int fd_pipe[2];//描述符，0表示为读，1表示为写
    pid_t pid = 0;
- ^6 ?3 V/ _( K3 T: ?    char buf[128] = "minger";
* l$ p! _7 |; L6 t  j    int n = 0;
* v8 m: n3 Y$ Q& ]" E$ u    if (pipe(fd_pipe) < 0)
    {
        perror("pipe");
  T4 [3 Q% H4 l- b$ X" M        return -1;
* q  N5 x! c  M* r2 a    }

# m. p6 l3 v) ~5 B* P    pid = fork();
7 ^  e* U: K4 g    if ( pid < 0)
" M" V2 c( }% ?7 f0 R4 t, }9 C    {
        perror("fork");
4 u/ }; X; m8 b2 y' Y- }* y        return -1;
  N* w" v7 O1 |$ p    }
' `4 S) n$ w$ z7 k+ z( V
2 F* s! `8 {, q    else if (pid > 0) //父进程
& F  ]' ~5 h7 f- ^! v0 ~- s4 `# l    {
' L0 E; u6 r9 N9 @  m' k        close(fd_pipe[1]);//关闭管道的写端
& p, l) i7 q( t+ v7 o3 q        memset(buf,0,sizeof(buf));
2 c6 [6 H5 i8 G        n = read(fd_pipe[0],buf,sizeof(buf)); //从管道读出数据
        printf("Read %d from the pipe: %s\n",n,buf);
    }
; U' {, B. m9 j# \' b6 k
9 j; m: i2 f1 p& ]    else //子进程
    {
        close(fd_pipe[0]);//关闭管道的读端
        write(fd_pipe[1], buf, strlen(buf)); //向管道写入数据
    }
! l; b0 k8 W& `1 V/ p0 l& ]8 J    return 0;
$ q. C5 J2 Z! |8 T6 ~2 B* ^}

编译结果:

在程序中，利用无名管道实现进程通信。子进程向管道写入字符串，父进程从管道中读取字符串。

命名管道

! c1 H- E) |, z. x( j

命名管道与管道不同的是，命名管道允许没有亲缘关系的进程进行通信和不相关的进程也能够进行数据交换。

/ x' R( P& c5 h5 q5 a

int mkfifo(const char *path, mode_t mode);
  y! ]" p% o, j6 \: w: d4 ~

) ^+ T% ]+ ^  b& `# ~# l# A

mkfifo实用程序应该按照指定的顺序创建由操作数指定的FIFO特殊文件。

参数：

! H& V, n* M) ~3 x! J

path:文件操作数用作路径参数。
mode:模式参数

6 h9 z. r1 D4 t; Q: e' @

写一个小例子测试一下，命名管道通信，创建两个.c文件，读进程和写进程。

读进程例子：

#include <stdio.h>
+ x* c; s0 X8 [0 N& H/ ^4 f#include <unistd.h>
& |9 ]4 S$ p$ `2 T#include <sys/types.h>
#include <sys/stat.h>
#include <errno.h>
$ A! S* h6 h& U8 l" W  ]#include<fcntl.h>
: |' M) U6 A5 N4 W* S( z6 A0 @#include <string.h>

int main(int argc, char const *argv[])
7 \+ l; ?5 ^5 U. O{
    int fd_read;
    char buf[128] = {0};
: w6 Y1 D! q6 a
    if (mkfifo("FIFO",S_IRUSR|S_IWUSR) != 0); //0666, 0777
$ m  ]. i$ J7 `& L' J. z    {
& o* H7 _, q' T% R1 \' O, ?        perror("mkfifo");
        //return -1;
) f1 H! M" K( R. R7 u( {, T1 \* k    }
    printf("before open\n");
# _4 E1 i5 H& n+ N( o    fd_read = open("FIFO",O_RDONLY); //只读方式打开
7 _$ h8 o, n2 H& l0 d6 W" Y# ?; q    if (fd_read < 0)
' Y1 p2 S9 P/ w3 }: ]8 D    {
- X1 u3 \  E+ F# g        perror("open");
        return-1;
: e4 P: m% n( f9 e3 C( l    }
    printf("after open\n");
# N4 X, ]5 ~( _* A* p    memset(buf,0,sizeof(buf));
9 K( t) B; O: R8 A* v* c" k. |    read(fd_read,buf,sizeof(buf));
    printf("read from FIFO buf: %s\n",buf);

0 [; H0 p& S2 V' R/ W
( @, X7 L- ~5 A; g) n    return 0;
' s+ j3 U. S5 \, v/ r. r/ V7 G' l}

1 q; `. N7 O* Z% R2 {- |. H& i

写进程例子：

' o9 I* N# ^9 x5 U# h

#include <stdio.h>
0 c8 n+ ]- p& b2 b! [- |#include <unistd.h>
& \, m* E4 ~1 Z) b( @3 i#include <sys/types.h>
#include <sys/stat.h>
) d2 T- f/ G0 F& Z! a, s#include <errno.h>
#include<fcntl.h>
$ W+ C. n& ]: ^$ S, F, l/ T2 W#include <string.h>
' C8 p, A3 M1 X& l1 e7 l  o
int main(int argc, char const *argv[])
{
4 Y3 H% _, z& c9 T8 j    int fd_write;
. F- }' C2 ~5 ^! M) B( w0 R    char buf[128] = "minger";

% v' R7 Y; h( h' ^" ~    if (mkfifo("FIFO",S_IRUSR|S_IWUSR) != 0); // 0666,0777
# h' H$ g7 a+ y: T" `    {
        perror("mkfifo");
        //return -1;
    }
2 `) K  N8 y& z2 `, H' M: ^
    fd_write = open("FIFO",O_WRONLY); //只读方式打开
    if (fd_write < 0)
    {
        perror("open");
        return-1;
    }
7 A/ B6 a5 f& U
    write(fd_write,buf,strlen(buf));
+ [  m: k6 O7 Y- `1 ~9 }* u+ K    printf("Write from FIFO buf: %s\n",buf);

! t7 m/ D3 |8 \/ x% L, n. ~: ~& b
: `  J& t3 o: b( U7 u4 G. f    return 0;
0 J# Z4 o- n! A1 q}

打开两终端，一个终端先运行写进程，然后运行读进程，编译结果如下：

6 _: T8 a4 @% w" A

5 z% `- t# j4 m9 P1 Q' J. s

运行结果可以看到，两个没有亲缘关系的进程可以通过FIFO进行通信。在终端下，可以通过ls -alh，查看FIFO文件是否是命名管道文件；如果p开头表示是管道。

消息队列
  C& W  D4 ?5 n3 O1 V

消息队列是消息的链表，存储在内核中。一个消息队列由一个标识符（即队列ID）来标识。

消息队列的特点

0 c2 B+ x" @2 U$ B0 Y; x

1.消息队列中的消息是有类型和格式的
  b7 }- h; e! Z6 Y6 ?2.消息队列可以实现消息的随机查询。消息不一定要以先进先出次序读取。可以按消息的类型读取。
5 J4 V$ m; S( N3.每个消息队列都有消息队列的标识符，消息队列的标识符在整个系统中是唯一的
% N& f0 _( e, Z1 Z9 y7 x4.消息队列允许一个或者多个进程向它写入或者读取消息。

( S' ?7 l- y: g* V: }

函数原型

" T% ~: \1 m7 I' i

创建消息队列

' \7 T8 P. B, M) G8 l1 I$ z0 J

int msgget(key_t key, int msgflg);
7 |" T( S" }! Q4 [+ p) ~

; r5 H5 \* A7 P9 c

功能：

创建或打开消息队列。

参数：

  G2 I9 g$ L" ]5 T/ Q$ K5 k, D6 Ckey:IPC键值
msgfig:标识消息队列是否存在。并且(msgflg & IPC_CREAT)是非零的。
IPC_CREAT：创建消息队列是否存在
; M9 S; U5 E/ P% \! Z0 t3 C0 v! c( m

返回值

! z8 u2 n, ]/ [, j. [  R7 S, X2 h成功完成后，msgget()将返回一个非负整数，即消息队列标识符。
否则，它将返回-1并，表示错误。

! V4 ^, w  J/ y  z发送消息

int msgsnd(int msqid, const void *msgp, size_t msgsz, int msgflg);
6 R  |: A' L/ }# P* R8 y" Z( A

. |) l0 @) b" ]$ ~; E* K2 o' H% U, l- S2 D

功能：
/ N5 I' N. l2 I, H9 h
$ h! I8 t9 @$ V2 v5 L添加消息队列

参数：

" a+ Y/ w- n+ i, @  Y0 Pmsqid：消息队列的标识符
msgp：待发送的消息队列的地址
$ j6 Q0 g0 j% h7 A( B* k0 q, Cmsgsz：消息队列正文的字节数
msgflg：如果(msgflg & IPC_NOWAIT)非零，则不发送消息，调用线程应立即返回。
4 K% J) c( J  l; J& ~# z) c如果(msgflg & IPC_NOWAIT)为0，调用线程将暂停执行；
3 p9 O; y" h  m# L

返回值
, G, s5 }9 v8 p
! i' t0 I/ Q$ w+ C) U1 v成功完成后，msgsnd()返回0;
否则，将不发送任何消息，msgsnd()将返回-1，并将errno设置为指示错误。

. v3 x4 ?- B  J& n; Z, ^" m消息队列的消息格式

struct mymsg {
/ \5 l; e4 @& ^8 p3 b0 L6 y3 n, v    long   mtype;       //消息类型.
    char   mtext[1];    //消息文本。
6 r7 Y6 L5 ^: v8 ~};

结构成员mtype是一种非零正长类型，可由接收流程用于消息选择。
& ~, A3 n8 I- X, \& ~结构成员mtext是长度为msgsz字节的任何文本。参数msgsz的范围可以从0到系统设置的最大值。

. {3 Y2 l$ k1 u5 @

接收消息
+ W2 M2 x7 ~* {% e# E% y5 w" P

, {9 ^# q0 B1 V( r$ t3 j) `3 @- G

ssize_t msgrcv(int msqid, void *msgp, size_t msgsz, long msgtyp,int msgflg);
1 k& c: H- ?. ~

2 I+ w( E7 l$ y5 d. w

功能：

1 r6 k- N/ b  P5 D' N读取消息
/ d+ g" d/ r9 u+ q
1 R3 j  @3 b" q8 s- b

参数：

msqid：消息队列的标识符。
msgp： 存放消息结构体的地址。
msgsz：消息正文的字节数。
msgtyp:消息类型，有几种类型：
如果msgtyp为0，则接收队列上的第一个消息。
( g" }7 P, ]2 Z如果msgtyp大于0，则接收msgtyp类型的第一条消息。
如果msgtyp小于0，则接收小于或等于msgtyp绝对值的最低类型的第一条消息。
5 U; S4 R3 v. |; i- V' L
msgflg：如果(msgflg & IPC_NOWAIT)非零，调用线程应立即返回，返回值为-1；
如果(msgflg & IPC_NOWAIT)为0，调用线程将暂停执行。
+ S6 G1 i" T* k/ ?
1 k2 T' h3 I6 {  q$ M5 K4 M

返回值
8 x4 W, C3 ~0 \6 C; e* s成功完成后，msgrcv()将返回一个与实际放入缓冲区mtext中的字节数相等的值。
否则，将不接收任何消息，msgrcv()将返回-1，并将errno设置为指示错误。

消息队列的控制

int msgctl(int msqid, int cmd, struct msqid_ds *buf);
9 x( b6 H, b# N; B: f/ d! l

( }4 Y: G! G0 D/ g0 D" o

功能:
控制消息队列，如修改消息队列的属性，或者删除消息队列等。

) t7 a6 P$ N/ ?5 s8 s

参数：
$ @9 |9 K3 N8 S* U9 d
0 x: }% W1 X! Z3 x; q" Y! Wmsqid：消息队列的标识符
2 u. V: i: {' E" Wcmd：函数的控制功能
buf：msqid_ds 数据类型的地址
4 p- x2 x- ~7 w) @# \  W* K

返回值

成功完成后，msgctl()返回0;
2 _* x, K4 \" C8 x1 `否则，它将返回-1并，表示错误。
% ^) `. x  n7 g, J0 ~1 [9 }7 S
8 P, o. h0 V: s' T& S' C/ c' h获得IPC键值
: B" \/ _7 m* g8 R& L+ G$ z

key_t ftok(const char *path, int id);
功能：

, O' Q. @( A& H1 I; m4 g7 a获得唯一的IPC键值
) J) u' e! E+ m0 B% N; U

/ R& b% E9 ~- X6 k& N

参数：

( B( z, C4 g) X( a7 E. ~path:路径名
id:项目ID

, h5 v+ B5 d9 u- y+ u( |: ]

返回值

成功完成后，ftok()将返回一个密钥。
否则，ftok()将返回(key_t)-1，表示错误。
0 A! b1 s2 p0 A/ v$ C
0 F+ i8 f4 b) w# i$ M8 c) C; a有了这些函数原型，接下来就写消息队列简单例子：一个任务任务负责发送消息，另一个任务负责接收，通过ftok()创建子进程实现多任务。
4 \' U( D+ P( l" z) f1 }
: ^! l3 R8 ?, L+ B" T7 smessage_read.c

#include <stdio.h>
9 A1 L# W0 j3 V% ~5 H# U#include <sys/types.h>
#include <unistd.h>
- \& x. V8 W8 ~% F) f#include <sys/ipc.h>
/ M; y6 A: p5 D; Z8 }0 {#include <sys/msg.h>
#include <string.h>
0 B7 ]: W% Y- Q#include <stdlib.h>
) \, n5 }0 J8 n2 `& q' i! o" d
& |# x  t: u4 u# l! N% U5 Wtypedef struct msg
{
) K# X( A; K. e" r3 \    long mtype; //消息类型
: {. n' w+ B; Y8 h- x6 z    char ntext[128];//消息正文
}MSG;

int main(int argc, char const *argv[])
0 m- M0 R+ l2 b$ R/ _4 v+ H{
    key_t key;
! {. R; H; s, V1 x: o8 M! v    int msgqid;
! b* Q# z8 `5 G, r5 s  f0 l    MSG my_msg;
) T) p% H9 m- V4 ]
5 o: K, ]. ~  u: C( b* G
5 H$ L7 V$ |+ x5 A) I1 S- Y( o    if ((key = ftok(".",2019)) == -1)
    {
( V7 i# ^9 r3 x  A6 c5 @+ L        perror("ftok");
& `( H2 G( Z3 j        exit(-1);

    }
    printf("message queue key: %d\n",key );
- E5 `9 i1 b4 v: O2 T. K4 R
+ d' D" O+ v  Z    if ((msgqid = msgget(key,IPC_CREAT|0666)) == -1)//打开消息队列
    {
        perror("message");
5 R- j' I* h/ |6 @6 D3 U        exit(-1);
- K/ `* G( ]* i- h2 a* J! r/ [3 ]/ P* f    }
    printf("msgqid: %d\n",msgqid);//打印消息队列ID

+ g. {6 G2 x% C* X0 @. \) G" i    msgrcv(msgqid,&my_msg,sizeof(my_msg.ntext),111,0);
    printf("my_msg.ntext= %s\n",my_msg.ntext);
! E0 g; @2 v/ U    msgctl(msgqid,IPC_RMID,NULL);//删除由msgqid指示的消息队列


    return 0;
. Q4 y% ?: l$ K! I$ s5 w; \5 B. ^}

3 a2 D! _4 J0 J5 h2 A

message_write.c

% O6 _/ Q) V. b3 ?

#include <stdio.h>
4 {9 h" x" P$ ^7 H' S( V#include <sys/types.h>
) W$ U  m: a6 h8 }; k#include <unistd.h>
% b. O% W% q: Q' J+ W#include <sys/ipc.h>
#include <sys/msg.h>
9 A1 I* l) B( t1 E* d#include <string.h>
! d0 z) G! H6 r8 h#include <stdlib.h>
9 T2 e$ r6 c4 y3 C/ k- z1 Z
typedef struct msg
* V% V+ J0 l5 A) z/ Y) c7 I' {4 m4 Q/ v{
    long mtype; //消息类型
    char ntext[128];//消息正文
% c( E, L; Y0 K}MSG;

( C4 {& _2 j2 ~) e. i7 p  Wint main(int argc, char const *argv[])
; r0 B* @$ X2 h: u, i1 q{
    key_t key;
    int msgqid;
0 h5 l  A' W8 J# k+ C( E- J    MSG my_msg;
; U. w. ~0 Z4 T# D3 W/ t: y% \

    if ((key = ftok(".",2019)) == -1)
    {
        perror("ftok");
; J8 \) x% v( ?. K8 H- c+ j& j        exit(-1);
; o' J  F6 @  K2 g# N, }( m, M
  w" Y; D7 \  Q% ^    }
    printf("message queue key: %d\n",key );
/ g0 T# V+ h# R- g
+ J2 V  L1 C9 a7 S, j, s: C    if ((msgqid = msgget(key,IPC_CREAT|0666)) == -1)//打开消息队列
4 y9 d/ M; G- o# C    {
0 C* @! l, t: F1 H. P# k        perror("message");
# M% w2 ~5 x. S5 S2 c; k        exit(-1);
    }
! Y, C8 S& T9 E2 h; |7 o! ^    printf("msgqid: %d\n",msgqid);//打印消息队列ID
; X$ {2 `: G& O/ L" I( ]/ B    my_msg.mtype = 111;
& u! ~( m& K9 ~7 C    strcpy(my_msg.ntext,"hello minger");
    msgsnd(msgqid,&my_msg,sizeof(my_msg.ntext),0);


  z/ l1 t" D) _! H7 Z. f    return 0;
}
, V: g" r+ J! j' l: L3 B, d

刚开始编译的时候没有运行，查看消息队列 ipcs -q，显示已用字节数为 0，消息为0

9 P  Y1 r" v  v# w0 c$ S6 G

1 E" {! M$ m; I2 S, z# F9 }0 s2 L

编译结果

信号量

信号量是一个计数量，它主要用在多个进程需要对共享数据进行访问的时候。用于进程或线程间的同步和互斥。那么借助信号量就可以完成这样的事情。
/ e* u+ q' w; W" T6 ^2 O
- d" }, `$ `  d& b. N" ?

流程及特点

' {# u# O9 o4 N  \( @8 V操作系统的P操作就是上锁，V操作就是解锁
# R4 R6 v! U0 ?+ e2 r如果信号量值大于0，则资源可用，并且将其减1，表示当前已被使用
' \/ ?5 P, U3 v# O- o4 e如果信号量值为0，则进程休眠直至信号量值大于0

4 J# b- U: k9 K

函数原型

信号初始化
) i" ?8 o, I4 @' b* p' s" i

: P$ V. j! K# M( |

int sem_init(sem_t *sem, int pshared, unsigned value);
) \8 b, |8 ?. U/ h  X1 ?$ H  v

9 M0 b2 t8 b- |7 v8 R

功能：

创建一个信号量并初始化她的值。

参数：

sem:信号量的地址
pshared:如果pshared=0，则信号量在线程之间共享;pshared不等于于0，信号量在进程间共享。
value:信号量的初始值；

0 t3 f: c" b9 t- }

返回值

成功完成后，sem_init()函数将在sem中初始化信号量并返回0。
否则，它将返回-1并，表示错误。
: F, O0 ]5 Q9 g- Y8 O

信号的p操作

int sem_wait(sem_t *sem);

6 X+ }" ?  h* Z9 r* m. u

功能:

通过对sem引用的信号量执行信号量锁操作来锁定信号量。如果信号量值当前为0，那么调用线程将不会从调用返回到sem_wait()，直到锁定信号量或调用被信号中断。

参数：

sem:信号量的地址

# ~( p, u: b! {+ h- @

返回值：

, q/ S, \( Y% @9 n成功返回0，否则返回 -1；

信号量V操作

" r. J' x8 Y+ b; \

int sem_post(sem_t *sem);

功能:

通过对sem引用的信号量执行信号量解锁操作来解锁该信号量。将信号量的值加1，并发出唤醒解锁该信号量。

$ r8 s$ y% G' l7 x% I2 _* I

参数

7 K2 \4 A1 u" n. Z

sem:信号量的地址

返回值：

如果成功，sem_post()函数将返回0;

否则，函数将返回-1，表示错误。

5 w# H. J+ S5 p1 |: v" L

信号量实现互斥

#include <stdio.h>
#include <pthread.h>
, n- D8 c" `# b3 n9 @#include <unistd.h>
" G- S! @& p2 x8 d#include <semaphore.h>

sem_t sem;
void display(char *pstr)
{
- S, z# k/ x  H6 g" y' d/ c; P    sem_wait(&sem); //上锁
    if (pstr == NULL)
9 A/ O& i- _  i/ ]        return ;
    while (*pstr != '\0')
$ b9 E  ^- J7 n* _    {
. v& R0 [" `3 m! M4 \) t! m        putchar(*pstr); //每次只处理一个字符
        fflush(stdout);//往屏幕中打印字符
        pstr ++;
% Z" \" d8 E0 W  w
! t# z' A( e8 e' {+ ~$ J$ x        sleep(1);
    }
    sem_post(&sem);//解锁

}

9 G6 A' E8 U$ s1 l" Evoid *thread_task1(void *argv)
{
+ T" V3 `3 S) u/ O    char *pstr = "abcdef";
6 L" Z# t: T* M: |2 `# J; l    display(pstr);
% y* h8 U- _) ]) \0 b7 W7 O}
+ z# X/ B  f% w' J- T* q
void *thread_task2(void *argv)
{
2 @$ r% c7 F/ L$ n. |$ g    char *pstr = "ghijkl";
    display(pstr);
- F2 c/ ]+ D% o% N6 \& n}
& ?/ F8 v5 d8 n7 _" A. S* C
int main(int argc, char const *argv[])
{

    pthread_t tid1,tid2;
0 {% e/ g$ v, t1 m# g& v    if (sem_init(&sem,0,1) != 0)  //0表示是线程，1表示初始化sem值为1
7 l0 E9 F% P# e3 Z    {
/ `  G( W( H7 h/ t& [0 x        perror("sem_init");
4 A9 ?& n. b/ D  D! a' D: W        return 0;
    }
    //线程创建
) ]9 A, V; G7 ]. g  I1 J    if (pthread_create(&tid1,NULL,thread_task1,NULL) != 0)
/ S8 H! |: H( U1 T& ?    {
        perror("pthread_create");
        return 0;
  I7 H: o# B6 f    }
/ f- C' W* r7 o6 G& F2 S+ Q1 I    if (pthread_create(&tid2,NULL,thread_task2,NULL) != 0)
: s( O0 U" i! [; Q+ w    {
        perror("pthread_create");
8 j) n- y( N$ V1 f        return 0;
    }
/ e3 q+ `* Q9 G+ U. H
1 v' D  Z+ c8 W" c. F+ Z  K    //线程等待
7 E0 L9 o5 ^/ z; H3 J  q; o  C" |    pthread_join(tid1,NULL);
6 Y' E9 A) q+ B. O    pthread_join(tid2,NULL);
# ^2 G3 q! m3 P# R+ b9 s    printf("\nDone\n");
    return 0;

运行结果:

编译时候用到了线程 所以要加上 -lpthread，结果为什么不是abcdefghijk呢，这得看cpu调度算法；

信号量实现同步

+ |/ Y3 @: n  W  C" z6 Z# I

#include <stdio.h>
1 c' x' Q1 D8 t$ K2 y#include <pthread.h>
#include <unistd.h>
#include <semaphore.h>

) _* m2 ^- [1 N1 g. }2 E" Lsem_t sem1,sem2;
char ch = 'a';
2 h7 s, t( w4 n6 f- @! R) G% o
& l' N8 S: J& v9 y+ K
void *pthread_task1(void *argv)
{
$ Z6 B+ k0 U, T& @5 C* g% t! \    while (1)
    {
& [0 o1 [: Z" j' j4 W# v1 V% h        sem_wait(&sem1);
, s& W$ s* n, y0 n8 b( A% X5 M2 O6 L        ch ++;
        sleep(1);
& u) s9 @& f/ \7 ?: g! E        sem_post(&sem2);
    }
}
3 b; f0 |- }; S$ e1 [, D4 E. s  n9 o
. ~6 j# [5 \) q$ H. {3 U5 Kvoid *pthread_task2(void *argv)
{
    while (1)
. c+ a9 k& D5 E) Z  {, H  x    {
        sem_wait(&sem2);
        putchar(ch);
! D# ]2 l% u, k0 t0 I: ?' ?: E; V6 G        fflush(stdout);
7 d& I! j3 v5 g, O. E4 z        sem_post(&sem1);
    }
1 n) d; p- C1 ~- k}

. s) Z; s/ d5 W$ k, n8 W$ N, Qint main(int argc, char const *argv[])
) u8 O8 T2 s& [% f{

    pthread_t tid1,tid2;
    if (sem_init(&sem1,0,0) != 0)
    {
9 O7 e5 l2 M  M        perror("sem_init");
        return 0;
/ z5 t; Q5 v" S4 E+ y( j5 D    }

    if (sem_init(&sem2,0,1) != 0)
  K1 m! z9 t- k% i1 A) `* n6 `1 Y    {
        perror("sem_init");
        return 0;
    }

    if (pthread_create(&tid1,NULL,pthread_task1,NULL) !=0 )
    {
        perror("pthread_create");
) Z$ X) a  x3 I3 e        return 0;
- c8 Y: g$ i+ j$ ?' x0 Z# L9 k    }
$ h& Y6 u, ?% `( G$ |& f, Z# g8 R( B5 B
    if (pthread_create(&tid2,NULL,pthread_task2,NULL) !=0 )
    {
        perror("pthread_create");
        return 0;
. v! O' x! E7 S" Q1 f    }
; V9 k+ |5 Y9 F2 s
2 e0 q5 |2 ]* u, V3 n    pthread_join(tid1,NULL);
    pthread_join(tid2,NULL);
5 {' G' _4 R% L: q$ _4 @    printf("Done\n");

# N, m4 H$ ~" y- Z    return 0;
6 m7 c! X2 `7 A}
" {( \, U+ ]2 V5 q# I

输出结果:

验证了信号量实现同步的功能。

共享内存

共享内存运行多个进程共享给定的存储区域。共享内存是进程间共享数据最快的方法。使用共享内存需要注意的是多个进程之间的对一个给定的存储区访问的互斥，需要用到前面所用到的信号量来实现同步与互斥；

函数原型

共享存储的标识符

int shmget(key_t key, size_t size, int shmflg);
) J% K) Z, ]9 {: y5 Z功能:

创建或打开一块共享内存区

& K  K1 w  _) ~& T' [

参数:

key:IPC键值
" G* K. F/ F7 l$ ?5 f) Usize:共享内存段的长度
7 p9 {6 P+ B4 X/ ^! @shmflg:标识函数的共享内存权限
; t3 V& c( u, Z, z! F$ OIPC_CREAT：如果不存在就创建 ;
' h8 s; ]/ z( D; f9 j3 Z% hIPC_EXCL：如果已经存在则返回失败;

返回值

+ ?) I8 g: l; {0 S5 m2 {成功完成后，shmget()返回一个非负整数，即共享内存标识符;
否则，它将返回-1,表示错误。
# C( @; I: z" c8 l8 X  a3 j

共享内存映射

- r( n: {# C2 \. c

void *shmat(int shmid, const void *shmaddr, int shmflg);

功能:

+ L  d/ S9 w: N; x将一个共享内存段映射到调用进程的数据段中。
将与shmid指定的共享内存标识符相关联的共享内存段附加到调用进程的地址空间。
如果shmaddr是一个空指针，则在系统选择的第一个可用地址处附加段。如果shmaddr不是一个空指针，并且(shmflg &SHM_RND)为0，则在shmaddr给出的地址处附加段。

参数：

shmid:共享内存的标识符
* k* M" `) o% i9 b1 ushmaddr:共享内存映射地址，一般使用NULL。
5 h( |. [" w, x: {& ^* oshmflg:共享内存段的访问权限和映射条件。
如果(shmflg &SHM_RDONLY)非零且调用进程具有读权限，则附加该段进行读取;否则，如果它是0，并且调用进程具有读和写权限，则附加该段用于读和写。
& I3 S3 w8 w/ ^% d

返回值

成功返回0，失败返回 -1；
  k9 h/ i) w7 i; U" D
& w& o' ~! p* U! W8 O0 P% d解除共享内存映射

int shmdt(const void *shmaddr);
2 v7 E9 y, B* }

+ g' F# E' C- [

功能:

从调用进程的地址空间中分离位于shmaddr指定地址的共享内存段。

参数：

shmaddr:共享内存映射地址。

返回值：

6 Z8 B( V5 {  C' k8 a# H成功返回0；
否则，共享内存段将不会被分离，shmdt()将返回-1，为指示错误。

共享内存控制

* y# V. Y9 t1 f6 B% g& ?

int shmctl(int shmid, int cmd, struct shmid_ds *buf);
5 [+ D. R& y" R

功能:

共享内存空间的控制

9 u5 Q- `0 {9 e# z

参数：

7 X- \  U$ K1 w+ q) w  Q% \; Yshmid:共享内存的标识符
3 r6 o' M& y) |- P# u- Zcmd:函数功能的控制。
& S8 Q( q, R; K. ZIPC_RMID：删除。
3 X$ s, Q0 t6 `2 O! @! b0 FIPC_SET：设置 shmid_ds 参数。
; m7 U, R6 |$ q5 E6 dIPC_STAT：保存 shmid_ds 参数。
* k7 c* F& \; Q. B: USHM_LOCK：锁定共享内存段(超级用户)。
SHM_UNLOCK：解锁共享内存段。
buf: shmid_ds 数据类型的地址，用来存放或修改共享内存的属性。

0 {! B: f. M+ w9 U

返回值

2 i  h9 h; r2 L: R/ x# f成功返回0，失败返回-1

4 q/ ~' i. I6 s$ E" J4 _& x; vshare_write.c

#include <stdio.h>
* s& f0 o- j# ^4 N& ~#include <stdlib.h>
#include <string.h>
#include <unistd.h>
' ]3 y% J5 P- U' N. P8 o#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/shm.h>
4 p6 v. U8 T+ g# x1 a
#define SIZE 1024*2
4 J1 d  M1 @( I' M% c- {
int main(int argc, char *argv[])
0 f/ \0 N, F0 d5 J2 r5 C{
    int shmid;
. h0 K  u# i6 g5 [' E, q9 u    int ret;
    key_t key;
    char *shmadd;
5 v1 d: |( {- w3 _, p! V! Z
2 c) X, e# t2 O- k    if ((key= ftok(".", 2012)) == -1)
    {
1 d% ^" D6 j) [. Y) B' q5 F6 q        perror("ftok");
1 v+ f; x- D7 o. K  U    }
4 V0 v3 Y5 Q( i, b8 w2 d. V    system("ipcs -m");//查看共享内存
' {- j; W) @0 x' A
' G) M5 [8 c$ q6 Y
    if ((shmid = shmget(key, SIZE, IPC_CREAT|0666)) < 0)
    {
# }! [, W4 i, V- x+ A  ?" _        perror("shmget");
        exit(-1);
9 C3 A* h5 `* B4 {# s% u    }

    if ((shmadd = shmat(shmid, NULL, 0)) < 0)
    {
        perror("shmat");
        exit(-1);
/ x) }# o# j+ M3 B/ H    }
6 i% ?, x+ `3 U. g, m2 }; _
    printf("data =%s\n", shmadd);
    if ((ret = shmdt(shmadd)) < 0)
    {
        perror("shmdt");
$ l; `7 b# S) A: Z; _        exit(1);
% Q, w1 M  }7 f1 s1 U1 \% G" Z8 O6 _    }
& G; c7 I4 y, v+ Q) p    else
    {
6 i) f3 D9 r6 ^% x6 X3 c9 x0 ~7 O        printf("deleted shared memory\n");
    }
    shmctl(shmid, IPC_RMID, NULL);
' H2 z# K$ R3 q8 ?    system("ipcs -m");
! o0 b2 z* Z8 M2 [% H, ?    return 0;
2 }% ?# {  o* N8 k}
3 i& y3 w$ W- X  ^. n

share_read.c

( h2 g  f+ l6 S/ j

#include <stdio.h>
2 R; c- {8 l! A* ~% d+ ^& t8 B#include <stdlib.h>
; j) ^* \. N( x! B#include <string.h>
& u- r" d0 P5 I/ @) F+ b7 f#include <unistd.h>
$ j1 J* ?* H# I, a5 i% _, k#include <sys/types.h>
; b# R2 |: h/ q6 P  e#include <sys/ipc.h>
#include <sys/shm.h>

. w8 v8 _5 A4 L8 i#define SIZE 1024*2

int main(int argc, char *argv[])
7 q% r0 c/ @3 }; W{
- F1 e8 }# g' ]7 W8 \3 S# ?5 k$ Q    int shmid;
) q" l# D" H; _" \4 @% L& ^    int ret;
. W4 Y2 m7 G( P7 S' n& x1 X! W    key_t key;
    char *shmadd;
3 o  }3 m2 s$ U& k2 Z- f% y
    if((key = ftok(".", 2012)) == -1)
    {
; Z% n+ ]" Z2 m* ~$ X        perror("ftok");
    }

    if ((shmid = shmget(key, SIZE, IPC_CREAT|0666)) < 0) //创建共享内存
5 R( ]3 u% K/ x    {
) Q) S' Q/ A; w# y, Y0 ~) Y        perror("shmget");
5 U+ N5 O. J+ r/ s$ F1 G        exit(-1);
' W) ^  _7 R) k0 S$ K( p    }
: E# Z+ A: w4 W! k- ]- Y
$ z' u& T( n; D5 \2 L! r) o9 Q    if((shmadd = shmat(shmid, NULL, 0)) < 0)//映射
0 f3 C4 ?# ^/ O1 u2 U7 N$ F    {
        perror("shmat");
+ R' ~3 P6 K  y9 r# ]* G        _exit(-1);
5 G% ]# g7 ]; t    }
) P* `+ h! u# J/ \
2 x, @# i+ B; f1 h9 o5 d    printf("copy data to shared-memory\n");//拷贝数据至共享内存区
4 J9 e5 v# X7 h    bzero(shmadd, SIZE);
    strcpy(shmadd, "data in shared memory\n");
1 p# g& p7 g3 n+ ]1 o5 a4 d% j2 o% Z    return 0;
}
2 ~; z) W4 p+ |5 j) U

输出结果

套接字

套接字是一种通信机制，凭借这种机制，不同主机之间的进程可以进行通信。也就是说它可以让不在同一台计算机但通过网络连接计算机上的进程进行通信。也因为这样，套接字明确地将客户端和服务器区分开来。
/ u1 ~1 N8 x( k! O' F
5 l# a( P  ?* A8 ?1 Z+ F$ Y8 I总结

9 K+ H7 R+ ?) N2 a  Z+ @# u0 b本文简单介绍了进程间通信的常见方式，除了套接字没有例子，剩下的都有简单的例子。套接字（socket）应该目前应用最广泛的进程间通信方式。能用于不同计算机之间的不同进程间通信。套接字话题太大，等以后慢慢安排上哈。

7 s" N2 T& i/ A% T

顶一下