[linux复习]——多线程

int ticket =100;

void *run(void *arg)
{
    char *id = (char*) arg;
    while(1){
        if(ticket > 0)
        {
            usleep(1000);
            printf("%s sells ticket:%d\n",id,ticket);
            ticket--;
        }
        else break;
    }
}

int main()
{
    pthread_t id1,id2,id3,id4;
    char *ip1 = "thread 1";
    char *ip2 = "thread 2";
    char* ip3 = "thread 3";
    char* ip4 = "thread 4";

    pthread_create(&id1,nullptr,run,ip1);
    pthread_create(&id2,nullptr,run,ip2);
    pthread_create(&id3,nullptr,run,ip3);
    pthread_create(&id4,nullptr,run,ip4);

    pthread_join(id1,nullptr);
    pthread_join(id2,nullptr);
    pthread_join(id3,nullptr);
    pthread_join(id4,nullptr);
    return 0;
}

        上面这段代码之所以出现负数是因为：

        1.if语句判断条件为真以后，代码可以并发的切换到其他线程

        2.usleep这个模拟漫长业务的过程，在这个漫长的业务过程中，可能有很多个线程会进入该代码段

        3.--ticket操作本身就不是一个原子操作（我前面的文章讲过原子库感兴趣的可以看看）

        对ticket的操作并不是原子的，因为它对应着三条汇编指令

        1.load：将共享变量ticket从内存加载到寄存器中

        2.update：更新寄存器里面的值，执行-1操作

        3.store：将新值，从寄存器写回共享变量ticket的内存地址

        要解决上面的问题，需要做到三点：

        1.代码必须要有互斥行为：当代码进入临界区执行时，不允许其他线程进入改临界区。

        2.如果多个线程同时要求执行临界区的代码，并且临界区没有线程在执行，那么只能允许一个线程进入该临界区

        3.如果线程不在临界区执行，那么该线程不能阻止其他线程进入临界区。

        要做到这三点，本质上就是需要一把锁。linux上提供的这把锁叫互斥量。

互斥量的接口

初识互斥量（有两种方法）

        法一：静态分配

pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER

        法二：动态分配

int pthread_mutex_init(pthread_mutex_t *restrict mutex, const pthread_mutexattr_t *restrict
attr);
参数：
mutex：要初始化的互斥量
attr：NULL

销毁互斥量：

        销毁互斥量需要注意的事件：

        1.使用静态分配的互斥量不需要销毁

        2.不要销毁一个已经加锁的互斥量

        3.已经销毁的互斥量，要确保后面不会有线程再尝试加锁

int pthread_mutex_destroy(pthread_mutex_t *mutex)；

互斥量的加锁和解锁

int pthread_mutex_lock(pthread_mutex_t *mutex);
int pthread_mutex_unlock(pthread_mutex_t *mutex);
返回值:成功返回0,失败返回错误号

        调用pthread_mutex_lock时，可能会遇到以下情况：

        1.互斥量处于未锁状态，该函数会将互斥量锁定，同时返回成功

        2.发起函数调用时，其他线程已经锁定互斥量，或者存在其他线程同时申请互斥量，但没有竞争到互斥量，那么pthread_mutex_lock调用会陷入阻塞（执行流被挂起），等待互斥量解锁

//改进后的代码
#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);
    char *ip1 = "thread 1";
    char *ip2 = "thread 2";
    char *ip3 = "thread 3";
    char *ip4 = "thread 4";

    pthread_create(&t1, nullptr, route, ip1);
    pthread_create(&t2, nullptr, route, ip2);
    pthread_create(&t3, nullptr, route, ip3);
    pthread_create(&t4, nullptr, route, ip4);

    pthread_join(t1, nullptr);
    pthread_join(t2, nullptr);
    pthread_join(t3, nullptr);
    pthread_join(t4, nullptr);
    pthread_mutex_destroy(&mutex);
}

互斥量实现原理探究

      经过上面的例子，大家已经意识到单纯的 i++ 或者 ++i 都不是原子的，有可能会有数据一致性问题

        为了实现互斥锁操作,大多数体系结构都提供了swap或exchange指令,该指令的作用是把寄存器和内存单元的数据相交换,由于只有一条指令,保证了原子性,即使是多处理器平台,访问内存的 总线周期也有先后,一个处理器上的交换指令执行时另一个处理器的交换指令只能等待总线周期。 现在我们把lock和unlock的伪代码改一下

3.常见锁概念

3.1 死锁

3.2 linux线程同步

int pthread_cond_init(pthread_cond_t *restrict cond,const pthread_condattr_t *restrict
attr);
参数：
cond：要初始化的条件变量
attr：NULL

int pthread_cond_destroy(pthread_cond_t *cond)

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 <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <pthread.h>
pthread_cond_t cond;
pthread_mutex_t mutex;
void *r1(void *arg)
{
    while (1)
    {
        pthread_cond_wait(&cond, &mutex);
        printf("活动\n");
    }
}
void *r2(void *arg)
{
    while (1)
    {
        pthread_cond_signal(&cond);
        sleep(1);
    }
}
int main(void)
{
    pthread_t t1, t2;
    pthread_cond_init(&cond, NULL);
    pthread_mutex_init(&mutex, NULL);
    pthread_create(&t1, NULL, r1, NULL);
    pthread_create(&t2, NULL, r2, NULL);
    pthread_join(t1, NULL);
    pthread_join(t2, NULL);
    pthread_mutex_destroy(&mutex);
    pthread_cond_destroy(&cond);
}

按照上面的说法，我们设计出如下的代码：先上锁，发现条件不满足，解锁，然后等待在条件变量上不就
行了，如下代码

// 错误的设计
pthread_mutex_lock(&mutex);
while (condition_is_false) {
pthread_mutex_unlock(&mutex);
//解锁之后，等待之前，条件可能已经满足，信号已经发出，但是该信号可能被错过
pthread_cond_wait(&cond);
pthread_mutex_lock(&mutex);
}
pthread_mutex_unlock(&mutex);

pthread_mutex_lock(&mutex);
while (条件为假）
pthread_cond_wait(cond, mutex);
修改条件
pthread_mutex_unlock(&mutex);

pthread_mutex_lock(&mutex);
设置条件为真
pthread_cond_signal(cond);
pthread_mutex_unlock(&mutex);