线程的同步与互斥
如果每个线程使用的变量都是其他线程不会读取和修改的,那么就不存在一致性问题。同样,如果变量是只读的,多个线程同时读取该变量也不会有一致性问题。但是,当一个线程可以修改的变量,其他线程也可以读取和修改的时候,我们就需要对这些线程进行同步,确保他们再访问变量的存储内容时不会访问到无效的值。
假设两个线程读写相同变量时,线程A读取变量然后给这个变量赋予一个新的值,但写操作需要两个存储周期。当线程B在这两个写周期读取这个变量时,可能会得到不一致的值。为了避免这个问题,就需要互斥,同一时间只允许一个线程访问该变量。
互斥量
要做到三点:
- 代码必须要有互斥行为:当代码进入临界区执行时,不允许其他线程进入该临界区。
- 如果多个线程同时要求执行临界区的代码,并且临界区没有线程在执行,那么只能允许一个线程进入该临界区。
- 如果线程不在临界区执行,那么该线程不能阻止其他线程进入
要做到这三点,本质上就是需要一把锁。Linux上提供的这把锁叫互斥量。
改进售票系统:
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <pthread.h>
#include <sched.h>
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 ticket:%d\n", id, ticket);
ticket--;
pthread_mutex_unlock(&mutex);
// sched_yield(); 放弃CPU
} else {
pthread_mutex_unlock(&mutex);
break;
}
}
}
int main( void )
{
pthread_t t1, t2, t3, t4;
pthread_mutex_init(&mutex, NULL);
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);
pthread_mutex_destroy(&mutex);
}
条件变量:
void* route_t1(void* arg)
{
while(1)
{
printf("i am thread A\n");
}
}
void* route_t2(void* arg)
{
while(1)
{
printf("i am thread B\n");
sleep(1);
}
}
int main()
{
pthread_t t1,t2;
pthread_create(&t1,NULL,route_t1,(void**)"thread 1");
pthread_create(&t2,NULL,route_t2,(void**)"thread 2");
pthread_join(t1,NULL);
pthread_join(t2,NULL);
}
总结:互斥量是为了实现互斥
初始化互斥量:
动态方式:int pthread_mutex_init(pthread_mutex_t *restrict mutex,
const pthread_mutexattr_t *restrict attr);
静态分配: pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
销毁互斥量:
int pthread_mutex_destroy(pthread_mutex_t *mutex)
加锁:
int pthread_mutex_lock(pthread_mutex_t *mutex);
解锁:
int pthread_mutex_unlock(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;
销毁互斥量:
int pthread_mutex_destroy(pthread_mutex_t *mutex)
加锁:
int pthread_mutex_lock(pthread_mutex_t *mutex);
解锁:
int pthread_mutex_unlock(pthread_mutex_t *mutex);
总结:互斥量是为了实现互斥
读写锁
- 读写锁与互斥量类似,不过读写锁允许更高的并行性。互斥量要么是锁住状态,要么就是不加锁状态,而且一次只有一个线程可以对其加锁。读写锁可以有三种状态:读模式下加锁状态,写模式下加锁状态,不加锁状态。一次只可以一个线程可以占用写模式的读写锁,但是多个线程可以同时占用读模式的读写锁。
读写锁非常适合于对数据结构读的次数远大于写的情况。当读写锁在写模式下,他所保护的数据结构就可以被安全的修改,因为一次只有一次一个线程可以在写模式下拥有这个锁。当读写锁在读模式下,只要线程先获取了读模式下的读写锁,该锁所保护的数据几个就可以被多个获得读模式锁的线程读取。
int counter;
pthread_rwlock_t lock;
void* route_write(void* arg)
{
int t;
int i=*(int*)arg;
free(arg);
while(1)
{
t=counter;
usleep(1000);
pthread_rwlock_wrlock(&lock);
printf("write:%d:%#x: counter=%d ++counter=%d\n",i,pthread_self(),t,++counter);
pthread_rwlock_unlock(&lock);
usleep(5000);
}
}
void* route_read(void* arg)
{
int t;
int i=*(int *)arg;
free(arg);
while(1)
{
pthread_rwlock_rdlock(&lock);
printf("read:%d:%#x: counter=%d\n",i,pthread_self(),counter);
pthread_rwlock_unlock(&lock);
usleep(900);
}
}
int main()
{
int i=0;
pthread_t tid[8];
pthread_rwlock_init(&lock,NULL);
for(i=0;i<3;i++)
{
int *p=(int* )malloc(sizeof(int));
*p=i;
pthread_create(&tid[i],NULL,route_write,(void* )p);
}
for(i=0;i<5;i++)
{
int *p=(int* )malloc(sizeof(int));
*p=i;
pthread_create(&tid[i+3],NULL,route_read,(void* )p);
}
for(i=0;i<8;i++)
{
pthread_join(tid[i],NULL);
}
return 0;
}
自旋锁
自旋锁与互斥量类似,但它不是通过休眠使进程阻塞,而是在获取所之前一直处于自旋状态。自旋锁可以用于以下情况:锁被持有的时间短,而且线程并不希望在重新调度上花费太多成本。
当自旋锁用在非抢占式内核中是非常有用的:除了提供互斥机制以外,它们会阻塞中断,这样中断处理程序就不会让系统陷入死锁状态,因为它需要获取已被加锁的自旋锁。
屏障
屏障是用户协调多个线程并行工作的同步机制。屏障允许每个线程等待,直到所有的合作线程都到达某一点,然后从该点继续执行。我们已经看到一种屏障,pthread_join函数本身就是一种屏障,允许一个线程等待,直到另一个线程退出。但是屏障对象的概念更广,他们允许任意数量的线程等待,直到所有的线程完成处理工作,而线程不需要退出。所有线程达到屏障后可以继续工作。