Day35、线程同步、生产者和消费者、信号量级

最新推荐文章于 2025-01-31 00:18:30 发布

原创最新推荐文章于 2025-01-31 00:18:30 发布 · 222 阅读

0 ·

CC 4.0 BY-SA版权

一、线程和线程的同步

pthread_cancel（3）

#include<pthread.h>

intpthread_cancel(pthread_t thread);

Compile and linkwith -pthread.

功能：给一个线程发送终止的请求

参数：指定的线程id

返回值：0成功错误返回错误码

线程的终止：有三种

return pthread_exit pthread_cancel 终止的信息是-1

pthread_detach（3）

#include<pthread.h>

intpthread_detach(pthread_t thread);

Compile and linkwith -pthread.

功能：标记一个线程为detached状态，当这个状态的线程终止的时候，线程的资源会被自动回收。（和join不能公用）

参数：thread：线程的id

返回值：0成功错误返回错误码

举例

1 #include<stdio.h>

2 #include<pthread.h>

4 void *th_fn1(void *arg){

5 printf("thread1 returning...\n");

6 return (void *)1;

7 }

8 void *th_fn2(void *arg){

9 printf("thread2 exit...\n");

10 pthread_exit((void *)2);

11 }

12 void *th_fn3(void *arg){

13 while(1){

14 printf("thread3 exit...\n");

15 sleep(1);

16 }

17 }

19 int main(void){

20 pthread_t tid;

21 void *ret;

22 pthread_create(&tid,NULL,th_fn1,NULL);

23 pthread_join(tid,&ret);

24 printf("thread1 exit code%d\n",(int)ret);

26 pthread_create(&tid,NULL,th_fn2,NULL);

27 pthread_join(tid,&ret);

28 printf("thread2 exit code %d\n",(int)ret);

30 pthread_create(&tid,NULL,th_fn3,NULL);

31 pthread_cancel(tid);

32 pthread_join(tid,&ret);

33 printf("thread3 exit code %d\n",(int)ret);

35 pthread_create(&tid,NULL,th_fn1,NULL);

36 pthread_detach(tid);

37 return 0;

38 }

tarena@tarena-virtual-machine:~/day35$./join

thread1returning...

thread1 exitcode 1

thread2 exit...

thread2 exitcode 2

thread3 exit...

thread3 exitcode -1

1 #include<stdio.h>

2 #include<stdlib.h>

3 #include<pthread.h>

4 #define NLOOP 5

5 int counter=0;

6 void *doit(void *);

7 int main(void){

8 int i=0;

9 pthread_t tidA, tidB;

10 //创建两个线程

11 pthread_create(&tidA,NULL,&doit,NULL);

12 pthread_create(&tidB,NULL,&doit,NULL);

13 //等着线程的结束，以便回收资源

14 // pthread_join(tidA,NULL); （测试）

15 // pthread_join(tidB,NULL); （测试）子线程相当于调用一个函数

16 printf("i=%d",i);

17 return 0;

18 }

19 void *doit(void *arg){

20 int i,val;

21 for(i=0;i<NLOOP;i++){

22 val=counter;

23 printf("%x:%d\n",(unsigned int)pthread_self(),val+1);

24 counter=val+1;

25 }

26 return NULL;

27 }

线程的同步：

同步的实现：

互斥锁：mutex锁

pthread_mutex_init（3）

需要对变量初始化和销毁

pthread_mutex_init(pthread_mutex_t *__mutex, __const pthread_mutexattr_t *__mutexattr)

pthread_mutex_destroy(pthread_mutex_t *__mutex)

功能：销毁Mutex指定的锁

参数：mutex 变量

pthread_mutex_trylock(pthread_mutex_t *__mutex)

尝试加锁

pthread_mutex_lock(pthread_mutex_t *__mutex)

举例：lock.c 两个线程进行同步，

1 #include<stdio.h>

2 #include<stdlib.h>

3 #include<pthread.h>

4 #define NLOOP 50

5 pthread_mutex_tc_mutex=PTHREAD_MUTEX_INITIALIZER;

6 int counter=0;

7 void *doit(void *);

8 int main(void){

9 pthread_t tidA, tidB;

10 //创建两个线程

11 pthread_create(&tidA,NULL,&doit,NULL);

12 pthread_create(&tidB,NULL,&doit,NULL);

13 //等着线程的结束，以便回收资源

14 pthread_join(tidA,NULL);

15 pthread_join(tidB,NULL);

16 return 0;

17 }

18 void *doit(void *arg){

19 int i,val;

20 static int counter;

21 for(i=0;i<NLOOP;i++){

22 pthread_mutex_lock(&c_mutex);

23 counter++;

24 printf("%x:%d\n",(unsignedint)pthread_self(),counter);

25 pthread_mutex_unlock(&c_mutex);

26 }

27 return NULL;

28 }

tarena@tarena-virtual-machine:~/day35$gcc lock.c -lpthread -o lock

tarena@tarena-virtual-machine:~/day35$./lock

b6d9ab40:1

b6d9ab40:2

b6d9ab40:3

b6d9ab40:4

b6d9ab40:5

b6d9ab40:6

b6d9ab40:7

b6d9ab40:8

….

b759bb40:98

b759bb40:99

b759bb40:100

如果不加锁可能会异步

22 // pthread_mutex_lock(&c_mutex);

23 counter++;

24 printf("%x:%d\n",(unsignedint)pthread_self(),counter);

25 // pthread_mutex_unlock(&c_mutex);

b6df1b40:1

b6df1b40:3

b6df1b40:4

b6df1b40:5

b6df1b40:6

….

b6df1b40:101

b75f2b40:2

b75f2b40:102

条件变量：（conditionbariable）

线程需要等待某个条件成立才能继续往下执行，条件不成立，线程就阻塞。等待另外一个线程将条件设置成成立，此时唤醒阻塞的线程，继续往下执行

pthread_cond_t类型的变量来表示条件变量

pthread_cond_init（3）

#include<pthread.h>

pthread_cond_tcond=PTHREAD_COND_INITIALIZER;

pthread_cond_init(pthread_cond_t *cond, pthread_condattr_t *cond_attr)

功能：初始化这个条件变量

参数：

Cond：条件变量的地址

Cond_attr：NULL

返回值：

Int pthread_cond_destroy (pthread_cond_t *cond);

功能：销毁条件变量

参数：cond：条件变量的地址

intpthread_cond_signal (pthread_cond_t *cond)；

功能：唤醒在条件变量上等待的某个线程

int pthread_cond_broadcast(pthread_cond_t *cond)

功能：唤醒在条件变量上等待的全部线程

intpthread_cond_wait (pthread_cond_t *cond, pthread_mutex_t *mutex);

功能：等待条件成立

第一步：解锁mutex

第二步：阻塞等待

第三步：当被唤醒的时候，重新获得mutex锁

参数：cond条件变量

Mutex：mutex锁变量

intpthread_cond_timedwait (pthread_cond_t *cond, pthread_mutex_t *mutex,，const struct timespec *abstime)

功能：有时限的等待

参数：abstime 规定了等待的时限

演示一个生产者和消费者的例子。生产者生产一个结构体串在链表的头部，消费者从头部取走结构体

举例：pro-con.c

1 #include<stdio.h>

2 #include<stdlib.h>

3 #include<pthread.h>

4 typedef struct msg{

5 struct msg *next;

6 int num;

7 }msg_t;

8 msg_t *head;

9 //初始化锁和条件变量

10 pthread_cond_th_prod=PTHREAD_COND_INITIALIZER;

11 pthread_mutex_tlock=PTHREAD_MUTEX_INITIALIZER;

12 //生产者往链表的头部插入结点

13 void *producer(void *arg){

14 msg_t *mp;

15 for(;;){

16 mp=(msg_t *)malloc(sizeof(msg_t));

17 mp->num=rand()%1000+1;

18 printf("producer %d\n",mp->num);

19 //需要往链表里插入数据

20 pthread_mutex_lock(&lock);

21 mp->next=head;

22 head=mp;

23 //数据插入结束

24 pthread_mutex_unlock(&lock);

25 pthread_cond_signal(&h_prod);

26 sleep(rand()%5);

27 }

28 }

29 //消费者从链表的头部取走结点

30 void *consumer(void *arg){

31 msg_t *mp;

32 for(;;){

33 //先获得锁

34 pthread_mutex_lock(&lock);

35 //链表中没有结点的时候

36 while(head==NULL){

37 pthread_cond_wait(&h_prod,&lock);

38 }

39 mp=head;

40 head=head->next;//释放头结点

41 //解锁

42 pthread_mutex_unlock(&lock);

43 printf("consumer %d\n",mp->num);

44 free(mp);

45 mp=NULL;

46 sleep(rand()%5);

47 }

48 }

49 int main(void){

50 pthread_t tidp,tidc;

51 //创建两个线程

52 pthread_create(&tidp,NULL,producer,NULL);

53 pthread_create(&tidp,NULL,consumer,NULL);

54 //等待线程的结束

55 pthread_join(tidp,NULL);

56 pthread_join(tidc,NULL);

57 return 0;

58 }

producer 457

producer 43

consumer 43

consumer 457

producer 920

consumer 920

信号量：

既可以进程间通信，也可以线程间通信

mutex 非0即1

semaphore和mutex类似，表示可用资源的数量

使用sem_t类型表示信号量

sem_init（3）

Link with -lrt or -pthread.

#include <semaphore.h>

int sem_init(sem_t *sem, int pshared, unsigned int value);

功能：初始化一个未命名的信号量

参数：

sem：要初始化的信号量

value：用value的值初始化信号量

pshared：0 用于多线程

返回值：

0表示成功。

-1表示失败，errno被设置

sem_wait（3）

#include <semaphore.h>

int sem_wait(sem_t *sem);

功能：使信号量-1，如果信号量大于0，则立即返回。若信号量等于1，阻塞等待。

参数：sem：指定的信号量

返回值：0表示成功。

-1表示失败，errno被设置

sem_destroy（3）

#include <semaphore.h>

int sem_destroy(sem_t *sem);

功能：销毁信号量

参数：sem：要销毁的信号量

返回值：0代表成功，-1代表失败，errno被设置

sem_trywait（3）

int sem_trywait(sem_t *sem);

非阻塞，其它同sem_wait

sem_post（3）

int sem_post(sem_t *sem);

功能：使信号量加1，在这个信号量上等待的线程被唤醒

参数：sem：指定的信号量

返回值：0代表成功，-1代表失败，errno被设置

实现生产者和消费者的代码，基于固定大小的环形队列

生产和消费队列共5个，当生产的数字大于消费的数字大于等于5时，等待消费，直到消费时，才开始生产

vi sem_cilcle.c

1 #include<stdio.h>

2 #include<semaphore.h>

3 #include<pthread.h>

4 #define NUM 5

5 int queue[NUM];//环形队列

6 sem_t b_number,p_number;

7 //生产者

8 void *producer(void *arg){

9 int in=0;

10 while(1){

11 sem_wait(&b_number);

12 queue[in]=rand()%1000+1;

13 printf("producer %d\n",queue[in]);

14 sem_post(&p_number);

15 in=(in+1)%NUM;

16 sleep(rand()%2);

17 }

18 }

19 //消费者

20 void *consumer(void *arg){

21 int c=0;

22 while(1){

23 sem_wait(&p_number);

24 printf("consumer%d\n",queue[c]);

25 queue[c]=0;

26 sem_post(&b_number);

27 c=(c+1)%NUM;

28 sleep(rand()%8);

29 }

30 }

31 int main(void){

32 pthread_t pid,cid;

33 //初始化信号量

34 sem_init(&b_number,0,NUM);

35 sem_init(&p_number,0,0);

36 //创建两个线程

37 pthread_create(&cid,NULL,consumer,NULL);

38 pthread_create(&pid,NULL,producer,NULL);

39 //等待线程的结束

40 pthread_join(cid,NULL);

41 pthread_join(pid,NULL);

42 //销毁信号量

43 sem_destroy(&b_number);

44 sem_destroy(&p_number);

45 return 0;

46 }

tarena@tarena-virtual-machine:~/day35$gcc sem_circle.c -lpthread -o sem

tarena@tarena-virtual-machine:~/day35$./sem

producer 384

producer 778

consumer 384

producer 336

producer 493

producer 85

consumer 414

consumer 981

二、信号量集semaphore

消息队列

共享内存

信号量：

信号量与其它几种IPC机制（管道、共享内存和消息队列）都不一样，它的目的不是在进程之间搭建数据流通的桥梁，而是提供一个可为多个进程共同访问计数器，实时跟踪可用资源的数量，以解决多个用户分享有限资源时的竞争与冲突问题

ftok（2）

semget（2）

#include<sys/types.h>

#include<sys/ipc.h>

#include<sys/sem.h>

int semget(key_tkey, int nsems, int semflg);

功能：获取一个跟key值相关的信号量的id

参数：

key：ftok（2）产生的键值

nsems：要创建的信号集包含的信号的个数

semflg：IPC_CREAT

返回值：

-1失败返回信号量集的id

信号量的操作：

semop（2）

#include<sys/types.h>

#include<sys/ipc.h>

#include<sys/sem.h>

int semop(intsemid, struct sembuf *sops, unsigned nsops);

功能：信号量集的操作

参数：

semid：semget（2）的返回值，在这个信号量集上执行操作

sops：指向了进行操作的结构体的数组

noops：要操作的信号的个数

struct sops{

unsigned short sem_num; /* semaphore number */

short sem_op; /* semaphore operation */

short sem_flg; /* operation flags */

}

sem_num：信号量在信号量集中的下标索引

sem_op：每个信号量的操作类型

sem_op>0：给信号量加上sem_op值

sem_op=0：如果设置了IPC_NOWAIT,马上返回，错误设置成EAGAIN,没有设置。进程进入睡眠状态，直到信号量为0

sem_op<0：给信号量加上sem_op值，表示进程控制资源

sem_flg：IPC_NOWAIT或者IPC_SEM

返回值：

0成功 -1失败，errno被设置

semctl（2）

#include<sys/types.h>

#include<sys/ipc.h>

#include<sys/sem.h>

int semctl(intsemid, int semnum, int cmd, ...);

参数：

semid：

semnum：在集合中的下标

cmd：指明控制操作的类型

union semun {

int val; /* Value for SETVAL */

struct semid_ds *buf; /* Buffer for IPC_STAT, IPC_SET */

unsigned short *array; /* Array for GETALL, SETALL */

struct seminfo *__buf; /* Buffer for IPC_INFO

};

举例：server.c

Client

重点：内存的管理

进程的管理

线程的管理

信号管理

文件管理

文件系统管理

网络通讯