互斥:
情况:大多数线程试图修改临界资源,这时就可以申请锁,保证临界资源的安全性。
mutex(互斥量)
如果多个线程一同操作共享变量,会造成一些问题。
一个售票系统,多个线程一起进行购票操作。
#include<stdio.h>
#include<pthread.h>
#include<unistd.h>
#include<stdlib.h>
int ticket = 100;
void *route(void* arg)
{
char* id = (char*)arg;
while(1)
{
if(ticket > 0)
{
usleep(1000);
printf("%s sells tickets: %d\n",id,ticket);
--ticket;
}
else
{
break;
}
}
}
int main()
{
pthread_t t1,t2,t3,t4;
pthread_create(&t1,NULL,route,"thread 1");
pthread_create(&t2,NULL,route,"thread 2");
pthread_create(&t3,NULL,route,"thread 3");
pthread_create(&t4,NULL,route,"thread 4");
pthread_join(t1,NULL);
pthread_join(t2,NULL);
pthread_join(t3,NULL);
pthread_join(t4,NULL);
}
这里可以写一个循环来创建和等待,
thread 1 sells tickets: 100
thread 2 sells tickets: 99
thread 3 sells tickets: 98
thread 4 sells tickets: 97
thread 1 sells tickets: 96
thread 2 sells tickets: 95
...
thread 4 sells tickets: 4
thread 1 sells tickets: 3
thread 2 sells tickets: 2
thread 3 sells tickets: 1
thread 4 sells tickets: 0
thread 1 sells tickets: -1
thread 2 sells tickets: -2
这里结果发现就出现了问题。
这里提一个概念,原子操作(不会被线程调度机制打断的操作,操作一旦开始,一直运行结束)。
这个代码中--ticket操作本身就不是一个原子的操作。
调用反汇编来看的话--操作对应着3条汇编指令。
问题来了,那这种问题该怎么解决?
1.代码必须要有互斥行为,当代码进入临界区执行时,其他线程不允许进入临界区。
2.若临界区没有线程在执行,且多个线程想执行临界区的代码,那么,只允许进入一个线程进入。
3。该线程不在临界区执行代码,那么也不能阻止其他线程进入临界区。
互斥量的接口
初始化互斥量
动态分配:
#include <pthread.h>
int pthread_mutex_destroy(pthread_mutex_t *mutex);
int pthread_mutex_init(pthread_mutex_t *restrict mutex,
const pthread_mutexattr_t *restrict attr);
静态分配:
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
销毁互斥量
注意;
1.属于静态分配初始化的互斥量不需要销毁
2.不要销毁一个已经加锁的互斥量
3.已经销毁的互斥量,要确保后面不会有线程再尝试加锁。
#include <pthread.h>
int pthread_mutex_destroy(pthread_mutex_t *mutex);
互斥量的加锁和解锁:
#include <pthread.h>
int pthread_mutex_lock(pthread_mutex_t *mutex);
int pthread_mutex_unlock(pthread_mutex_t *mutex);
在调用lock时,会出现以下情况:
1.互斥量处于未锁状态,此时函数会将互斥量锁定,返回成功
2.发起函数调用时,其他线程已经锁定互斥量,或者其他线程同时申请互斥量,但没有竞争到互斥量,此时pthread_lock将会陷入阻塞状态,等待互斥量解锁。
改进以上售票系统:
int ticket = 100;
pthread_mutex_t mutex;
void *route(void* arg)
{
char* id = (char*)arg;
while(1)
{
pthread_mutex_lock(&mutex);
if(ticket > 0)
{
usleep(1000);
printf("%s sells tickets: %d\n",id,ticket);
--ticket;
pthread_mutex_unlock(&mutex);
}
else
{
pthread_mutex_unlock(&mutex);
break;
}
}
}
...
thread 1 sells tickets: 5
thread 1 sells tickets: 4
thread 1 sells tickets: 3
thread 1 sells tickets: 2
thread 1 sells tickets: 1
条件变量
临界资源状态
实现多个线程之间的同步
当一个互斥的访问某个变量时,在其他线程改变状态之前,什么也做不了。
条件变量的接口:
#include <pthread.h>
int pthread_cond_destroy(pthread_cond_t *cond);
int pthread_cond_init(pthread_cond_t *restrict cond,
const pthread_condattr_t *restrict attr);//cond 要初始化的条件变量
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
等待条件满足:
int pthread_cond_wait(pthread_cond_t *restrict cond,
pthread_mutex_t *restrict mutex);
//cond在这个条件变量上等待,mutex:必须要有一个互斥锁与他配合使用
第一个参数:在该条件下等待,释放锁,
第二个参数:重新获得锁,并等待执行
唤醒等待:
int pthread_cond_broadcast(pthread_cond_t *cond);//唤醒大量线程
int pthread_cond_signal(pthread_cond_t *cond);//唤醒单个线程
#include<stdio.h>
#include<pthread.h>
#include<unistd.h>
#include<stdlib.h>
pthread_cond_t cond;
pthread_mutex_t mutex;
void *run1(void* arg)
{
while(1)
{
pthread_cond_wait(&cond,&mutex);
printf("hello\n");
}
}
void* run2(void* arg)
{
while(1)
{
// pthread_cond_signal(&cond);
printf("world\n");
sleep(1);
}
}
int main()
{
pthread_t t1,t2;
pthread_cond_init(&cond,NULL);
pthread_mutex_init(&mutex,NULL);
pthread_create(&t1,NULL,run1,NULL);
pthread_create(&t2,NULL,run2,NULL);
pthread_join(t1,NULL);
pthread_join(t2,NULL);
pthread_mutex_destroy(&mutex);
pthread_cond_destroy(&cond);
}
[root@localhost cond]# gcc cond.c -lpthread
[root@localhost cond]# ./a.out
world
world
world
^C
如果将注释去掉
[root@localhost cond]# gcc cond.c -lpthread
[root@localhost cond]# ./a.out
world
world
hello
hello
world
hello
^C