linux系统编程7-锁、信号量、线程同步

一、同步概念

主旨在协同步调，按预定的先后次序运行。

1、线程同步

线程同步，指一个线程发出某一功能调用时，在没有得到结果之前，该调用不返回。同时其它线程为保证数据一致性，不能调用该功能。

“同步”的目的，是为了避免数据混乱，解决与时间有关的错误。实际上，不仅线程间需要同步，进程间、信号间等等都需要同步机制。

因此，所有“多个控制流，共同操作一个共享资源”的情况，都需要同步。

2、数据混乱原因

1. 资源共享（独享资源则不会)
2. 调度随机（意味着数据访问会出现竞争)
3. 线程间缺乏必要的同步机制。

以上3点中，前两点不能改变，欲提高效率，传递数据，资源必须共享。只要共享资源，就一定会出现竞争。只要存在竞争关系，数据就很容易出现混乱。
所以只能从第三点着手解决。使多个线程在访问共享资源的时候，出现互斥。

二、互斥量mutex

Linux中提供一把互斥锁mutex(也称之为互斥量)。
每个线程在对资源操作前都尝试先加锁，成功加锁才能操作，操作结束解锁。资源还是共享的，线程间也还是竞争的，
但通过“锁”就将资源的访问变成互斥操作，而后与时间有关的错误也不会再产生了。

建议锁！对公共数据进行保护。所有线程应该在访问公共数据前先拿锁再访问。但，锁本身不具备强制性。

1、使用mutex的基本步骤

	pthread_mutex_t 类型。 

	1. pthread_mutex_t lock;  创建锁

	2  pthread_mutex_init; 初始化		1

	3. pthread_mutex_lock;加锁		1--	--> 0

	4. 访问共享数据（stdout)		

	5. pthrad_mutext_unlock();解锁		0++	--> 1

	6. pthead_mutex_destroy；销毁锁
1
2
3
4
5
6
7
8
9
10
11
12
13
14

注意事项

		尽量保证锁的粒度， 越小越好。（访问共享数据前，加锁。访问结束【立即】解锁。）

		互斥锁，本质是结构体。 我们可以看成整数。 初值为 1。（pthread_mutex_init() 函数调用成功。）

		加锁： --操作， 阻塞线程。

		解锁： ++操作， 换醒阻塞在锁上的线 你  程。

		try锁：尝试加锁，成功--。失败，返回。同时设置错误号 EBUSY
1
2
3
4
5
6
7
8
9

	初始化互斥量：

		pthread_mutex_t mutex;

		1. pthread_mutex_init(&mutex, NULL);   			动态初始化。

		2. pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;	静态初始化。

1
2
3
4
5
6
7
8
9

2、主要应用函数

pthread_mutex_init函数
pthread_mutex_destroy函数
pthread_mutex_lock函数
pthread_mutex_trylock函数
pthread_mutex_unlock函数
以上5个函数的返回值都是:成功返回0，失败返回错误号。

pthread_mutex_t类型，其本质是一个结构体。为简化理解，应用时可忽略其实现细节，简单当成整数看待。pthread_mutex_t mutex;变量 mutex只有两种取值1、O。
1
2
3
4
5
6
7
8

3、加锁与解锁

使用锁时

4、加锁步骤测试

三、死锁

	是使用锁不恰当导致的现象：

		1. 对一个锁反复lock。

		2. 两个线程，各自持有一把锁，请求另一把。

1
2
3
4
5
6
7

四、读写锁

1. 锁只有一把。以读方式给数据加锁——读锁。以写方式给数据加锁——写锁。
2. 读共享，写独占。
3. 写锁优先级高。

写正在占着资源时，这时候有读来了，也不会让给读
只有读和写在同一地位时，读优先的地位才会显现出来。

1、读写锁特性:

1. 读写锁是“写模式加锁”时，解锁前，所有对该锁加锁的线程都会被阻塞。
2. 读写锁是“读模式加锁”时，如果线程以读模式对其加锁会成功;如果线程以写模式加锁会阻塞。
3. 读写锁是“读模式加锁”时，既有试图以写模式加锁的线程，也有试图以读模式加锁的线程。那么读写锁会阻塞随后的读模式锁请求。优先满足写模式锁。读锁、写锁并行阻塞，写锁优先级高时

读写锁也叫共享-独占锁。当读写锁以读模式锁住时，它是以共享模式锁住的;当它以写模式锁独占模式锁住的。写独占、读共享。

读写锁非常适合于对数据结构读的次数远大于写的情况。

五、条件变量

条件变量本身不是锁!但它也可以造成线程阻塞。通常与互斥锁配合使用。给多线程提供一个会合的场所。

1、主要应用函数

pthread_cond_init函数
pthread_cond_destroy函数
pthread_cond_wait函数
pthread_cond_timedwait函数
pthread_cond_signal函数
pthread_cond_broadcast函数
以上6个函数的返回值都是:成功返回o，失败直接返回错误号。
pthread_cond_t类型用于定义条件变量
pthread_cond_t cond;

1
2
3
4
5
6
7
8
9
10
11

1） pthread_cond_init函数 初始化一个条件变量

int pthread_cond_init(pthread_cond_t *restrict cond, const pthread_condattr_t *restrict attr);

参2: attr表条件变量属性，通常为默认值，传 NULL即可

也可以使用静态初始化的方法，初始化条件变量:
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
1
2
3
4
5
6

2） pthread_cond_destroy函数 销毁一个条件变量

int pthread_cond_destroy(pthread_cond_t *cond);
1

3）pthread_cond_wait函数 阻塞等待一个条件变量

要有个互斥锁当参数，
互斥锁要求是实现已经锁上，这个函数将会释放这个锁，然后等待唤醒
比如生产者和消费者模型，消费者先对容器加锁，发现没有食物了，然后就会阻塞，程序就会停到当前位置，释放所占有的锁，然后让生产者拿着这个锁去放食物，让生产者发出信号把自己唤醒。

	int pthread_cond_wait(pthread_cond_t *restrict cond, pthread_mutex_t *restrict mutex);

	函数作用:
	1.阻塞等待条件变量cond（参1）满足
	2．释放已掌握的互斥锁（解锁互斥量）相当于pthread_mutex_unlock(&mutex);
		1.2.两步为一个原子操作。
	3. 当被唤醒，pthread_cond_wait 函数返回时，解除阻塞并重新申请获取互斥锁pthread_mutex_lock(&mutex);
1
2
3
4
5
6
7

4） pthread_cond_timedwait函数 限时等待一个条件变量

int pthread_cond_timedwait(pthread_cond_t *restrict cond, pthread_mutex_t *restrict mutex, const struct timespec*restrict abstime);
	参3:参看man sem_timedwait函数，查看struct timespec结构体。
		struct timespec {
			time_t tv_sec;/*seconds*/秒
			long tv_nsec;/* nanosecondes*/纳秒
	形参abstime:绝对时间。
		如: time(NULL)返回的就是绝对时间。而alarm(1)是相对时间，相对当前时间定时1秒钟。
		struct timespec t= {1,0};
		pthread_cond_timedwait (&cond,&mutex, &t);只能定时到1970年1月1日 00:00:01秒(早已经过去)正确用法:
		time_t cur = time(NULL);获取当前时间。
		struct timespec t;定义timespec 结构体变量tt.tv_sec = cur+1;定时1秒
		pthread_cond_timedwait (&cond,&mutex,&t);
在讲解setitimer函数时我们还提到另外一种时间类型:
		struct timeval {
			time_t
			tv_sec;/* seconds */秒
			suseconds_t tv_usec;/* microseconds*/微秒
	};

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

5）pthread_cond_signal函数 唤醒至少一个阻塞在条件变量上的线程

int pthread_cond_signal(pthread_cond_t *cond);
1

6） pthread_cond_broadcast函数 唤醒全部阻塞在条件变量上的线程

int pthread_cond_broadcast(pthread_cond_t *cond);
1

2、生产者消费者条件变量

/*借助条件变量模拟 生产者-消费者 问题*/
#include 
#include 
#include 
#include 

/*链表作为公享数据,需被互斥量保护*/
struct msg {
    struct msg *next;
    int num;
};

struct msg *head;

/* 静态初始化 一个条件变量 和 一个互斥量*/
pthread_cond_t has_product = PTHREAD_COND_INITIALIZER;
pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;

void *consumer(void *p)
{
    struct msg *mp;

    for (;;) {
        pthread_mutex_lock(&lock);
        while (head == NULL) {           //头指针为空,说明没有节点    可以为if吗
            pthread_cond_wait(&has_product, &lock);
        }
        mp = head;      
        head = mp->next;                 //模拟消费掉一个产品
        pthread_mutex_unlock(&lock);

        printf("-Consume %lu---%d\n", pthread_self(), mp->num);
        free(mp);
        sleep(rand() % 5);
    }
}

void *producer(void *p)
{
    struct msg *mp;

    for (;;) {
        mp = malloc(sizeof(struct msg));
        mp->num = rand() % 1000 + 1;        //模拟生产一个产品
        printf("-Produce ---------------------%d\n", mp->num);

        pthread_mutex_lock(&lock);
        mp->next = head;
        head = mp;
        pthread_mutex_unlock(&lock);

        pthread_cond_signal(&has_product);  //将等待在该条件变量上的一个线程唤醒
        sleep(rand() % 5);
    }
}

int main(int argc, char *argv[])
{
    pthread_t pid, cid;
    srand(time(NULL));

    pthread_create(&pid, NULL, producer, NULL);
    pthread_create(&cid, NULL, consumer, NULL);

    pthread_join(pid, NULL);
    pthread_join(cid, NULL);

    return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70

多个消费者那在main函数里面多建几个消费者，然后让其执行自己的程序。

3、条件变量的优点

相较于mutex而言，条件变量可以减少竞争。

如直接使用mutex，除了生产者、消费者之间要竞争互斥量以外，消费者之间也需要竞争互斥量，但如果汇聚(链表）中没有数据，消费者之间竞争互斥锁是无意义的。有了条件变量机制以后，只有生产者完成生产，才会引起消费者之间的竞争。提高了程序效率。

六、信号量

进化版的互斥锁（1–>N)
由于互斥锁的粒度比较大，如果我们希望在多个线程间对某一对象的部分数据进行共享，使用互斥锁是没有办法实现的，只能将整个数据对象锁住。这样虽然达到了多线程操作共享数据时保证数据正确性的目的，却无形中导致线程的并发性下降。线程从并行执行，变成了串行执行。与直接使用单进程无异。
信号量，是相对折中的一种处理方式，既能保证同步，数据不混乱，又能提高线程并发。

1、主要应用函数

sem_init函数
sem_destroy函数
sem_wait函数
sem_trywait 函数
sem_timedwait函数
sem_post函数

以上6个函数的返回值都是:成功返回o，失败返回-1，同时设置errno。(注意，它们没有 pthread前缀)

sem_t类型，本质仍是结构体。但应用期间可简单看作为整数，忽略实现细节（类似于使用文件描述符)。
sem_t sem;规定信号量sem不能<0。头文件

1)sem_init函数 初始化一个信号量

int sem_init(sem_t *sem, int pshared, unsigned int value);
	参1: sem信号量
	参2: pshared取o用于线程间;取非0(一般为1）用于进程间
	参3: value指定信号量初值
1
2
3
4

2)sem_destroy函数 销毁一个信号量

int sem_destroy(sem_t *sem);
1

3) sem_wait函数 给信号量加锁

int sem_wait(sem_t *sem);
1

4)sem_post函数 给信号量解锁

int sem_post(sem_t *sem);
1

5) sem_trywait函数 尝试对信号量加锁

(与sem_wait的区别类比 lock 和 trylock)

int sem_trywait(sem_t *sem);
1

6)sem_timedwait函数 限时尝试对信号量加锁–

int sem_timedwait(sem_t *sem, const struct timespec *abs_timeout);参2: abs_timeout采用的是绝对时间。

	e.g.定时1秒:
		time_t cur = time(NULL);获取当前时间。
		struct timespec t;定义timespec结构体变量tt.tv_sec = cur+1;定时1秒
		t.tv_nsec = t.tv_sec +100;
		sem_timedwait(&sem, &t);传参
1
2
3
4
5
6
7

2、生产者消费者信号量模型