线程的同步与互斥

互斥：

情况：大多数线程试图修改临界资源，这时就可以申请锁，保证临界资源的安全性。

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