◼ 当有一个线程已经持有互斥锁时，互斥锁将所有试图进入临界区的线程都阻塞住。但是考
虑一种情形，当前持有互斥锁的线程只是要读访问共享资源，而同时有其它几个线程也想
读取这个共享资源，但是由于互斥锁的排它性，所有其它线程都无法获取锁，也就无法读
访问共享资源了，但是实际上多个线程同时读访问共享资源并不会导致问题。
◼ 在对数据的读写操作中，更多的是读操作，写操作较少，例如对数据库数据的读写应用。
为了满足当前能够允许多个读出，但只允许一个写入的需求，线程提供了读写锁来实现。
◼ 读写锁的特点：
如果有其它线程读数据，则允许其它线程执行读操作，但不允许写操作。
如果有其它线程写数据，则其它线程都不允许读、写操作。
写是独占的，写的优先级高。
读写锁的类型 pthread_rwlock_t int pthread_rwlock_init(pthread_rwlock_t *restrict rwlock, const pthread_rwlockattr_t *restrict attr); int pthread_rwlock_destroy(pthread_rwlock_t *rwlock); int pthread_rwlock_rdlock(pthread_rwlock_t *rwlock); int pthread_rwlock_tryrdlock(pthread_rwlock_t *rwlock);//尝试加上读锁 int pthread_rwlock_wrlock(pthread_rwlock_t *rwlock); int pthread_rwlock_trywrlock(pthread_rwlock_t *rwlock);//尝试加上写锁 int pthread_rwlock_unlock(pthread_rwlock_t *rwlock);
程序实例：
创建多个写线程以及读线程读写数据；
#include#include #include // 创建一个共享数据 int num = 1; // pthread_mutex_t mutex; pthread_rwlock_t rwlock; void * writeNum(void * arg) { while(1) { pthread_rwlock_wrlock(&rwlock); num++; printf("++write, tid : %ld, num : %dn", pthread_self(), num); pthread_rwlock_unlock(&rwlock); usleep(100); } return NULL; } void * readNum(void * arg) { while(1) { pthread_rwlock_rdlock(&rwlock); printf("===read, tid : %ld, num : %dn", pthread_self(), num); pthread_rwlock_unlock(&rwlock); usleep(100); } return NULL; } int main() { pthread_rwlock_init(&rwlock, NULL);//初始化读写锁 // 创建3个写线程，5个读线程 pthread_t wtids[3], rtids[5];//创建数组表示其三个写线程，五个读线程； for(int i = 0; i < 3; i++) { pthread_create(&wtids[i], NULL, writeNum, NULL); } for(int i = 0; i < 5; i++) { pthread_create(&rtids[i], NULL, readNum, NULL); } // 设置线程分离 for(int i = 0; i < 3; i++) { pthread_detach(wtids[i]); } for(int i = 0; i < 5; i++) { pthread_detach(rtids[i]); } pthread_exit(NULL); pthread_rwlock_destroy(&rwlock); return 0; }
ls rwlock.c qiyifei@qiyifei-virtual-machine:~/桌面/sanqi/03/03$ gcc rwlock.c -o rwlock -pthread qiyifei@qiyifei-virtual-machine:~/桌面/sanqi/03/03$ ./pthread
运行结果：
基本概念：生产者生产商品将商品放入容器中；
消费者将容器中的商品从容器中取出来；
生产者消费者模型中的对象：
1.生产者
2.消费者
3.容器
利用互斥量的生产者消费者模型
#include条件变量#include #include #include // 创建一个互斥量 pthread_mutex_t mutex; struct Node{ int num; struct Node *next; }; // 头结点 struct Node * head = NULL; void * producer(void * arg) { // 不断的创建新的节点，添加到链表中 while(1) { pthread_mutex_lock(&mutex); struct Node * newNode = (struct Node *)malloc(sizeof(struct Node));//添加到头节点中； newNode->next = head; head = newNode; newNode->num = rand() % 1000; printf("add node, num : %d, tid : %ldn", newNode->num, pthread_self()); pthread_mutex_unlock(&mutex); usleep(100); } return NULL; } void * customer(void * arg) { while(1) { pthread_mutex_lock(&mutex); // 保存头结点的指针 struct Node * tmp = head; // 判断是否有数据 if(head != NULL) { // 有数据 head = head->next; printf("del node, num : %d, tid : %ldn", tmp->num, pthread_self()); free(tmp); pthread_mutex_unlock(&mutex); usleep(100); } else { // 没有数据 pthread_mutex_unlock(&mutex); } } return NULL; } int main() { pthread_mutex_init(&mutex, NULL); // 创建5个生产者线程，和5个消费者线程 pthread_t ptids[5], ctids[5]; for(int i = 0; i < 5; i++) { pthread_create(&ptids[i], NULL, producer, NULL); pthread_create(&ctids[i], NULL, customer, NULL); } for(int i = 0; i < 5; i++) { pthread_detach(ptids[i]); pthread_detach(ctids[i]); } while(1) { sleep(10); } pthread_mutex_destroy(&mutex); pthread_exit(NULL);//退出主线程，这样程序不会执行 return 0，那么程序可以一直存在（主要是子线程）； return 0; }
条件变量的类型 pthread_cond_t
int pthread_cond_init(pthread_cond_t *restrict cond, const pthread_condattr_t *restrict attr);
int pthread_cond_destroy(pthread_cond_t *cond);
int pthread_cond_wait(pthread_cond_t *restrict cond, pthread_mutex_t *restrict mutex);
- 等待，调用了该函数，线程会阻塞。
int pthread_cond_timedwait(pthread_cond_t *restrict cond, pthread_mutex_t *restrict mutex, const struct timespec *restrict abstime);
- 等待多长时间，调用了这个函数，线程会阻塞，直到指定的时间结束。
int pthread_cond_signal(pthread_cond_t *cond);
- 唤醒一个或者多个等待的线程
int pthread_cond_broadcast(pthread_cond_t *cond);
- 唤醒所有的等待的线程
#include#include #include #include // 创建一个互斥量 pthread_mutex_t mutex; // 创建条件变量 pthread_cond_t cond; struct Node{ int num; struct Node *next; }; // 头结点 struct Node * head = NULL; void * producer(void * arg) { // 不断的创建新的节点，添加到链表中 while(1) { pthread_mutex_lock(&mutex); struct Node * newNode = (struct Node *)malloc(sizeof(struct Node)); newNode->next = head; head = newNode; newNode->num = rand() % 1000; printf("add node, num : %d, tid : %ldn", newNode->num, pthread_self()); // 只要生产了一个，就通知消费者消费 pthread_cond_signal(&cond); pthread_mutex_unlock(&mutex); usleep(100); } return NULL; } void * customer(void * arg) { while(1) { pthread_mutex_lock(&mutex); // 保存头结点的指针 struct Node * tmp = head; // 判断是否有数据 if(head != NULL) { // 有数据 head = head->next; printf("del node, num : %d, tid : %ldn", tmp->num, pthread_self()); free(tmp); pthread_mutex_unlock(&mutex); usleep(100); } else { // 没有数据，需要等待 // 当这个函数调用阻塞的时候，会对互斥锁进行解锁，当不阻塞的，继续向下执行，会重新加锁。 pthread_cond_wait(&cond, &mutex); pthread_mutex_unlock(&mutex); } } return NULL; } int main() { pthread_mutex_init(&mutex, NULL); pthread_cond_init(&cond, NULL); // 创建5个生产者线程，和5个消费者线程 pthread_t ptids[5], ctids[5]; for(int i = 0; i < 5; i++) { pthread_create(&ptids[i], NULL, producer, NULL); pthread_create(&ctids[i], NULL, customer, NULL); } for(int i = 0; i < 5; i++) { pthread_detach(ptids[i]); pthread_detach(ctids[i]); } while(1) { sleep(10); } pthread_mutex_destroy(&mutex); pthread_cond_destroy(&cond); pthread_exit(NULL); return 0; }
运行结果
信号量的类型 sem_t
int sem_init(sem_t *sem, int pshared, unsigned int value);
- 初始化信号量
- 参数：
- sem : 信号量变量的地址
- pshared : 0 用在线程间 ，非0 用在进程间
- value : 信号量中的值
int sem_destroy(sem_t *sem);
- 释放资源
int sem_wait(sem_t *sem);
- 对信号量加锁，调用一次对信号量的值-1，如果值为0，就阻塞
- -1操作
int sem_trywait(sem_t *sem);
int sem_timedwait(sem_t *sem, const struct timespec *abs_timeout);
int sem_post(sem_t *sem);
- 对信号量解锁，调用一次对信号量的值+1
- +1操作
int sem_getvalue(sem_t *sem, int *sval);
sem_t psem;
sem_t csem;
init(psem, 0, 8);
init(csem, 0, 0);
producer() {
sem_wait(&psem);
sem_post(&csem)
}
customer() {
sem_wait(&csem);
sem_post(&psem)
}
程序：
#include#include #include #include #include // 创建一个互斥量 pthread_mutex_t mutex; // 创建两个信号量 sem_t psem; sem_t csem; struct Node{ int num; struct Node *next; }; // 头结点 struct Node * head = NULL; void * producer(void * arg) { // 不断的创建新的节点，添加到链表中 while(1) { sem_wait(&psem); pthread_mutex_lock(&mutex); struct Node * newNode = (struct Node *)malloc(sizeof(struct Node)); newNode->next = head; head = newNode; newNode->num = rand() % 1000; printf("add node, num : %d, tid : %ldn", newNode->num, pthread_self()); pthread_mutex_unlock(&mutex); sem_post(&csem); } return NULL; } void * customer(void * arg) { while(1) { sem_wait(&csem); pthread_mutex_lock(&mutex); // 保存头结点的指针 struct Node * tmp = head; head = head->next; printf("del node, num : %d, tid : %ldn", tmp->num, pthread_self()); free(tmp); pthread_mutex_unlock(&mutex); sem_post(&psem); } return NULL; } int main() { pthread_mutex_init(&mutex, NULL); sem_init(&psem, 0, 8); sem_init(&csem, 0, 0); // 创建5个生产者线程，和5个消费者线程 pthread_t ptids[5], ctids[5]; for(int i = 0; i < 5; i++) { pthread_create(&ptids[i], NULL, producer, NULL); pthread_create(&ctids[i], NULL, customer, NULL); } for(int i = 0; i < 5; i++) { pthread_detach(ptids[i]); pthread_detach(ctids[i]); } while(1) { sleep(10); } pthread_mutex_destroy(&mutex); pthread_exit(NULL); return 0; }
运行结果
