在未加锁的情况下
#include<iostream>
#include<pthread.h>
#include<stdlib.h>
#include<unistd.h>
using namespace std;
pthread_mutex_t mutex;
int ticket_num = 20;
void *fun1(void *args) {
for (int i = 0; i < 20; ++i) {
if (ticket_num > 0) {
sleep(1);
cout<<"buy the "<<20 - ticket_num + 1<<" th"<<endl;
--ticket_num;
}
}
}
int main()
{
pthread_t tids[4];
pthread_mutex_init(&mutex, NULL);
int flag;
for (int i = 0; i < 4; ++i) {
flag = pthread_create(&tids[i], NULL, &fun1, NULL);
if（flag） {
//创建线程失败
}
}
void *ans;
sleep(5);
for (int i = 0; i < 4; ++i) {
int flag = pthread_join(tids[i], &ans);
if (flag) {
//等待线程结束出错
}
cout<<"ans = "<<ans<<endl;
}
return 0;
}
运行截图
线程之间运行的很乱,这就是线程未进行同步的原因,好比四个同时在12306抢票，这时余票都显示余票还有一张，四个人同时抢，都抢到了，钱也扣了，你们这时候问题来了，这张票你是给谁呢。所以要进行线程同步
1.互斥锁：
#include<iostream>
#include<pthread.h>
#include<stdlib.h>
#include<unistd.h>
using namespace std;
pthread_mutex_t mutex;
int ticket_num = 20;
void *fun1(void *args) {
for (int i = 0; i < 20; ++i) {
pthread_mutex_lock(&mutex);
if (ticket_num > 0) {
sleep(1);
cout<<"buy the "<<20 - ticket_num + 1<<" th"<<endl;
--ticket_num;
}
pthread_mutex_unlock(&mutex);
}
}
int main()
{
pthread_t tids[4];
pthread_mutex_init(&mutex, NULL);
// pthread_mutex_t mutex_x=PTHREAD_MUTEX_INITIALIZER;//静态初始化互斥锁
int flag;
for (int i = 0; i < 4; ++i) {
flag = pthread_create(&tids[i], NULL, &fun1, NULL);
if（flag） {
//创建线程失败
}
}
void *ans;
//sleep(10);
for (int i = 0; i < 4; ++i) {
int flag = pthread_join(tids[i], &ans);
if (flag) {
//等待线程结束出错
}
cout<<"ans = "<<ans<<endl;
}
return 0;
}
2.条件变量
互斥量不是万能的，比如某个线程正在等待共享数据内某个条件出现，可可能需要重复对数据对象加锁和解锁（轮询），但是这样轮询非常耗费时间和资源，而且效率非常低，所以互斥锁不太适合这种情况
我们需要这样一种方法：当线程在等待满足某些条件时使线程进入睡眠状态，一旦条件满足，就换线因等待满足特定条件而睡眠的线程
如果我们能够实现这样一种方法，程序的效率无疑会大大提高，而这种方法正是条件变量！
#include<iostream>
#include<pthread.h>
#include<stdlib.h>
#include<unistd.h>
using namespace std;
pthread_mutex_t mutex;
pthread_cond_t cond;
int ticket_num = 20;
void *f1 (void* args) {
cout<<"f1 start"<<endl;
pthread_mutex_lock(&mutex);
while (ticket_num > 10) {
pthread_cond_wait(&cond, &mutex);
}
pthread_mutex_unlock(&mutex);
cout<<"f1 end"<<endl;
}
void *f2 (void* args) {
cout<<"f2 start"<<endl;
pthread_mutex_lock(&mutex);
ticket_num = 1;
pthread_mutex_unlock(&mutex);
cout<<"f2 end"<<endl;
if (ticket_num < 10) {
pthread_cond_signal(&cond);
}
}
int main()
{
pthread_t tids[2];
pthread_mutex_init(&mutex, NULL);
pthread_cond_init(&cond, NULL);
int flag;
for (int i = 0; i < 1; ++i) {
pthread_create(&tids[0], NULL, &f1, NULL);
sleep(2);
pthread_create(&tids[1], NULL, &f2, NULL);
}
void *ans;
//sleep(10);
for (int i = 0; i < 2; ++i) {
int flag = pthread_join(tids[i], &ans);
if (flag) {
}
//cout<<"ans = "<<ans<<endl;
}
return 0;
}
可以多个线程同时读，但是不能多个线程同时写
1.读写锁比互斥锁更加具有适用性和并行性
2.读写锁最适用于对数据结构的读操作读操作次数多余写操作次数的场合！
3.锁处于读模式时可以线程共享，而锁处于写模式时只能独占，所以读写锁又叫做共享-独占锁
4.读写锁有两种策略：强读同步和强写同步
在强读同步中，总是给读者更高的优先权，只要写者没有进行写操作，读者就可以获得访问权限
在强写同步中，总是给写者更高的优先权，读者只能等到所有正在等待或者执行的写者完成后才能进行读
不同的系统采用不同的策略，比如航班订票系统使用强写同步，图书馆查阅系统采用强读同步
根据不同的业务场景，采用不同的策略
1）初始化的销毁读写锁
静态初始化：pthread_rwlock_t rwlock=PTHREAD_RWLOCK_INITIALIZER
动态初始化：int pthread_rwlock_init(rwlock，NULL)，NULL代表读写锁采用默认属性
销毁读写锁：int pthread_rwlock_destory(rwlock)
在释放某个读写锁的资源之前，需要先通过pthread_rwlock_destory函数对读写锁进行清理。释放由pthread_rwlock_init函数分配的资源
如果你想要读写锁使用非默认属性，则attr不能为NULL，得给attr赋值
int pthread_rwlockattr_init(attr),给attr初始化
int pthread_rwlockattr_destory(attr)，销毁attr
2）以写的方式获取锁，以读的方式获取锁，释放读写锁
int pthread_rwlock_rdlock(rwlock),以读的方式获取锁
int pthread_rwlock_wrlock(rwlock)，以写的方式获取锁
int pthread_rwlock_unlock(rwlock),释放锁
上面两个获取锁的方式都是阻塞的函数，也就是说获取不到锁的话，调用线程不是立即返回，而是阻塞执行，在需要进行写操作的时候，这种阻塞式获取锁的方式是非常不好的，你想一下，我需要进行写操作，不但没有获取到锁，我还一直在这里等待，大大拖累效率
所以我们应该采用非阻塞的方式获取锁：
int pthread_rwlock_tryrdlock(rwlock)
int pthread_rwlock_trywrlock(rwlock)
代码待更
信号量
代码待更
文章部分借鉴于https://www.cnblogs.com/yinbiao/p/11190336.html