linux线程互斥锁

互斥量mutex
大部分情况，线程使用的数据都是局部变量，变量的地址空间在线程栈空间内，这种情况，变量归属单个线程，其他线程无法获得这种变量。

但有时候，很多变量都需要在线程间共享，这样的变量称为共享变量，可以通过数据的共享，完成线程之间的交互。

多个线程并发的操作共享变量，会带来一些问题。

线程同步：通过互斥锁，让多线程从并发执行，变成串执行，执行完一个线程才能去执行另一个。

互斥锁的相关函数

创建互斥锁： pthread_mutex_t mutex;
初始化：pthread_mutex_init(&mutex,NULL); – mutex = 1
找到线程共同操作的共享数据
加锁：操作共享资源之前加锁，pthread_mutex_lock(&mutex); //阻塞 --mutex = 0
pthread_mutex_trylock(&mutex); // 如果锁上锁直接返回，不阻塞
XXXXXX共享数据操作 //临界区 ，越小越好
解锁：pthread_mutex_unlock(&mutex); // – mutex = 1
阻塞在锁上的线程会被唤醒
销毁：pthread_mutex_destory(&mutex)；

代码

#include 
#include 
#include 
#include 
#define MAX 1000
int number;
pthread_mutex_t mutex;
void *pthread1(void * arc)
{
        for(int j=0;j<MAX;j++)
        {       //lock
                pthread_mutex_lock(&mutex);
                int ret = number;
                ret++;
                number =ret;

                printf("pthread ld is %ld,number =%d\n",pthread_self(),number);
                //unlock
                pthread_mutex_unlock(&mutex);
                usleep(10);
        }

}
void *pthread2(void * arc)
{
        for(int i=0;i<MAX;i++)
        {
                 //lock
                pthread_mutex_lock(&mutex);
                int ret = number;
                ret++;
                number =ret;

                printf("pthread ld is %ld,number =%d\n",pthread_self(),number);
                //unlock
                pthread_mutex_unlock(&mutex);
                usleep(10);

        }
}

int main()
{

        pthread_t id1,id2;
        //初始化锁
        pthread_mutex_init(&mutex,NULL);
        pthread_create(&id1,NULL,pthread1,NULL);
        pthread_create(&id2,NULL,pthread2,NULL);

        pthread_join(id1,NULL);
        pthread_join(id2,NULL);
        pthread_mutex_destroy(&mutex);
}

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

执行结果

当线程上锁，其他线程拿不到锁，就会阻塞，等待拿到锁才继续执行，这就保证了线程的同步。即一个线程临界区执行的时候，其他线程不会执行。