Linux利用锁机制实现火车票售卖功能

#include<43func.h>
typedef struct shareRes_s{
    int trainTicket;
    pthread_mutex_t mutex;
} shareRes_t;
//1号窗口
void *sellTicket1(void *arg){
    shareRes_t * pShareRes = (shareRes_t *)arg;
    int cnt = 0;
    while(1){
        pthread_mutex_lock(&pShareRes->mutex);
        if(pShareRes->trainTicket <= 0){
            //在所有离开循环的场景，记得解锁
            pthread_mutex_unlock(&pShareRes->mutex);
            break;
        }
        //1号窗口售出一张票之前，车票余票还有多少
        printf("before 1 sell ticket, num = %d\n", pShareRes->trainTicket);
        --pShareRes->trainTicket;
        cnt++;
        //1号窗口售出一张票之后，车票余票还有多少
        printf("after 1 sell ticket, num = %d\n", pShareRes->trainTicket);
        pthread_mutex_unlock(&pShareRes->mutex);
    }
    printf("sellticket1 = %d\n", cnt); 
}
//2号窗口
void *sellTicket2(void *arg){
    shareRes_t * pShareRes = (shareRes_t *)arg;
    int cnt = 0;
    while(1){
        pthread_mutex_lock(&pShareRes->mutex);
        if(pShareRes->trainTicket <= 0){
            //在所有离开循环的场景，记得解锁
            pthread_mutex_unlock(&pShareRes->mutex);
            break;
        }
        //2号窗口
        printf("before 2 sell ticket, num = %d\n", pShareRes->trainTicket);
        --pShareRes->trainTicket;
        cnt++;
        printf("after 2 sell ticket, num = %d\n", pShareRes->trainTicket);
        pthread_mutex_unlock(&pShareRes->mutex);
    }
    printf("sellticket2 = %d\n", cnt);
}
int main(){
    shareRes_t shareRes;
    shareRes.trainTicket = 20000;
    pthread_mutex_init(&shareRes.mutex,NULL);
    pthread_t tid1, tid2;
    //创建两个线程
    pthread_create(&tid1,NULL,sellTicket1,(void *)&shareRes);
    pthread_create(&tid2,NULL,sellTicket2,(void *)&shareRes);
    //对线程资源进行回收
    pthread_join(tid1,NULL);
    pthread_join(tid2,NULL);
    pthread_mutex_destroy(&shareRes.mutex);
}

当票数容量较小的时候，会出现一边倒的情况(即全部由一个窗口售卖)，这是不符合现实情况的，有人就会有疑问，这个锁不公平吧？

其实不是的，当我们把车票容量调大一些，会得到如下的情况

1.比如20000张票  此时两个窗口售票就比较均匀了 窗口1售出10778张票 窗口2售出9222张票

2.比如200000张票，窗口1售出101426张票 窗口2售出98574张票

由此可见锁是公平的！