Posix线程与互斥锁的同步

Question

我越努力学习这个东西，越是感到困惑，所以我愿意接受任何建议和帮助。谢谢。程序是关于狭窄的桥（互斥体），并在其上运行汽车（进程），但一次只能有一个进程跨越它。跨越后，桥接线程可以将其自身添加到队列中或前往其睡眠的城市，然后添加到队列中。进程（汽车）需要运行，直到程序终止。如有必要，我可以将代码翻译成英文。编译后运行如下：./program -n-debug n - 线程数，调试 - 打印队列，仅可选。我认为线程不同步工作，例如我运行8个线程的程序，并在队列中有34号线程。不知道为什么，它发生在我“固定”的代码之后。

/* 
There's a road(bridge) from city A to B. Only one car can use it to move at a time. 
Cars should run(change cities) all the time, no end of program. 
Access to the bridge should be synchronized with mutexes. Every car have its numer from 1 to N where N is given as first parameter. 
Program should printing something like this when one of printing variable is changing: 
A - 5 10 >> >[>> 4 >> ] << <4 6 - B 
@up That means that in city A is 5 cars, in city A queue is 10 cars (wanting to change city). Thread with numer 4 is changing city from A to B. In city B queue is 4 cars and in city B is 6 cars. 
If second parameter -debug is given, then program should printf queue status. 
*/ 

#include <stdio.h> 
#include <stdlib.h> 
#include <pthread.h> 
#include <errno.h> 
#include <string.h> 

#define true 1 
#define false 0 

pthread_mutex_t countOfQueueA; 
pthread_mutex_t countOfQueueB; 
pthread_mutex_t bridge; 
pthread_mutex_t queueA; 
pthread_mutex_t queueB; 
pthread_mutex_t cityA; 
pthread_mutex_t cityB; 

int inQueueA = 0; // Number of cars in queue of city A 
int inQueueB = 0; // Number of cars in queue of city B 
int inCityA = 0; // Number of cars in city A 
int inCityB = 0; // Number of cars in city B 

int createdThreads = 0; // Number of created threads by pthread_create 
int numberOfCars = 0; // 
int debugMode = 0; // 0 - no, 1 - debug 
int *queueInA; // Pointer to queue in city A 
int *queueInB; // Pointer to queue in city B 



void printQueue(char city) 
{ 
    int i; 
    if (city == 'a') 
    { 
    printf("\nQueue A status: "); 
    for (i = 0; i<numberOfCars; i++) 
    { 
     printf("%d ", queueInA[i]); 
    } 
    printf("\n"); 
    } 
    else if (city == 'b') 
    { 
    printf("\nQueue B status: "); 
    for (i = 0; i<numberOfCars; i++) 
    { 
     printf("%d ", queueInB[i]); 
    } 
    printf("\n"); 
    } 
} 

void addToQueue(char city, int threadNumber) // Adding at the end of the queue in selected city 
{ 
    if (city == 'a') 
    { 
    pthread_mutex_lock(&queueA); 
    pthread_mutex_lock(&countOfQueueA); 
    int i = 0; 
    while (queueInA[i] != 0) //Looking for first free place = 0 to add car 
    { 
     i++; 
    } 
    queueInA[i] = threadNumber; 
    inQueueA++; 
    printf("\nA-%d %d>>> [ BLANK ] <<<%d %d-B", inCityA, inQueueA, inQueueB, inCityB); 
    if (debugMode == 1) 
    { 
     printQueue(city); 
    } 
    pthread_mutex_unlock(&queueA); 
    pthread_mutex_unlock(&countOfQueueA); 
    } 
    else if (city == 'b') 
    { 
    pthread_mutex_lock(&queueB); 
    pthread_mutex_lock(&countOfQueueB); 
    int i = 0; 
    while (queueInB[i] != 0) 
    { 
     i++; 
    } 
    queueInB[i] = threadNumber; 
    inQueueB++; 
    printf("\nA-%d %d>>> [ BLANK ] <<<%d %d-B", inCityA, inQueueA, inQueueB, inCityB); 
    if (debugMode == 1) 
    { 
     printQueue(city); 
    } 
    pthread_mutex_unlock(&queueB); 
    pthread_mutex_unlock(&countOfQueueB); 
    } 
} 

void changeCity2(int threadNumber, char city) 
{ 
    if (city == 'a') 
    { 
    while (queueInA[0] != threadNumber);// Oczekiwanie dopoki samochod nie jest 1szy w kolejce 

    pthread_mutex_lock(&bridge); 
    removeFromQueue(city, threadNumber); 

    printf("\nA-%d %d>>> [>> %d >>] <<<%d %d-B", inCityA, inQueueA, threadNumber, inQueueB, inCityB); 
    if (debugMode == 1) 
    { 
     pthread_mutex_lock(&queueA); 
     printQueue(city); 
     pthread_mutex_unlock(&queueA); 
    } 
    city = 'b'; 

    pthread_mutex_unlock(&bridge); 
    sleep(2); // Sleeping for simulating "working" time 

    int randomNumber = rand() % 4; 

    if (randomNumber % 2 == 0) 
    { 
     addToQueue(city, threadNumber); 
     changeCity2(threadNumber, city); 
    } 
    else 
    { 
     runIntoCity(threadNumber, city); 
    } 
    } 
    else if (city == 'b') 
    { 
    while (queueInB[0] != threadNumber); // Oczekiwanie dopoki samochod nie jest 1szy w kolejce  

    pthread_mutex_lock(&bridge); 


    removeFromQueue(city, threadNumber); 


    printf("\nA-%d %d>>> [<< %d <<] <<<%d %d-B", inCityA, inQueueA, threadNumber, inQueueB, inCityB); 
    if (debugMode == 1) 
    { 
     pthread_mutex_lock(&queueB); 
     printQueue(city); 
     pthread_mutex_unlock(&queueB); 
    } 
    city = 'a'; 


    pthread_mutex_unlock(&bridge); 
    sleep(2); 

    int randomNumber = rand() % 4; 

    if (randomNumber % 2 == 0) 
    { 
     addToQueue(city, threadNumber); 
     changeCity2(threadNumber, city); 
    } 
    else 
    { 
     runIntoCity(threadNumber, city); 
    } 
    } 
} 

void runIntoCity(int threadNumber, char city) 
{ 

    if (city == 'a') 
    { 
    pthread_mutex_lock(&cityA); 
    inCityA++; 
    printf("\nA-%d %d>>> [ BLANK ] <<<%d %d-B", inCityA, inQueueA, inQueueB, inCityB); 
    if (debugMode == 1) 
    { 
     pthread_mutex_lock(&queueA); 
     printQueue(city); 
     pthread_mutex_unlock(&queueA); 
    } 
    pthread_mutex_unlock(&cityA); 

    sleep(3); 

    pthread_mutex_lock(&cityA); 
    inCityA--; 
    printf("\nA-%d %d>>> [ BLANK ] <<<%d %d-B", inCityA, inQueueA, inQueueB, inCityB); 

    if (debugMode == 1) 
    { 
     pthread_mutex_lock(&queueA); 
     printQueue(city); 
     pthread_mutex_unlock(&queueA); 
    } 
    pthread_mutex_unlock(&cityA); 
    } 
    else 
    { 
    pthread_mutex_lock(&cityB); 
    inCityB++; 
    printf("\nA-%d %d>>> [ BLANK ] <<<%d %d-B", inCityA, inQueueA, inQueueB, inCityB); 

    if (debugMode == 1) 
    { 
     pthread_mutex_lock(&queueB); 
     printQueue(city); 
     pthread_mutex_unlock(&queueB); 
    } 
    pthread_mutex_unlock(&cityB); 

    sleep(3); 

    pthread_mutex_lock(&cityB); 
    inCityB--; 
    printf("\nA-%d %d>>> [ BLANK ] <<<%d %d-B", inCityA, inQueueA, inQueueB, inCityB); 
    if (debugMode == 1) 
    { 
     pthread_mutex_lock(&queueB); 
     printQueue(city); 
     pthread_mutex_unlock(&queueB); 
    } 
    pthread_mutex_unlock(&cityB); 
    } 


    addToQueue(city, threadNumber); 
    changeCity2(threadNumber, city); 
} 

void removeFromQueue(char city, int threadNumber) // Removing car from queue if its 1st in queue 
{ 
    if (city == 'a') // Car being removed from queue of city A 
    { 
    pthread_mutex_lock(&queueA); 
    pthread_mutex_lock(&countOfQueueA); 
    if (queueInA[0] == threadNumber) 
    { 

     inQueueA--; 

     int i = 1; 
     while (queueInA[i] != 0) 
     { 
      queueInA[i - 1] = queueInA[i]; 
      i++; 
     } 
     queueInA[i - 1] = 0; 
     printf("\nA-%d %d>>> [ BLANK ] <<<%d %d-B", inCityA, inQueueA, inQueueB, inCityB); 


     if (debugMode == 1) 
     { 

      printQueue(city); 
     } 
    } 
    else printf("Car is not first in queue. Error!"); 
    pthread_mutex_unlock(&queueA); 
    pthread_mutex_unlock(&countOfQueueA); 
    } 
    else if (city == 'b') 
    { 
    pthread_mutex_lock(&queueB); 
    pthread_mutex_lock(&countOfQueueB); 
    if (queueInB[0] == threadNumber) 
    { 

     inQueueB--; 

     int i = 1; 
     while (queueInB[i] != 0) 
     { 
      queueInB[i - 1] = queueInB[i]; 
      i++; 
     } 
     queueInB[i - 1] = 0; 

     printf("\nA-%d %d>>> [ BLANK ] <<<%d %d-B", inCityA, inQueueA, inQueueB, inCityB); 

     if (debugMode == 1) 
     { 
      printQueue(city); 
     } 
    } 
    else printf("Samochod nie jest pierwszy w kolejce. BLAD W KODZIE!"); 
    pthread_mutex_unlock(&queueB); 
    pthread_mutex_unlock(&countOfQueueB); 
    } 
} 



void changeCity(int threadNumber, char city) 
{ 
    if (city == 'a') 
    { 
    while (queueInA[0] != threadNumber); // Waiting until car is ready to change city - it's first in queue 

    pthread_mutex_lock(&bridge); 
    removeFromQueue(city, threadNumber); 



    printf("\nA-%d %d>>> [>> %d >>] <<<%d %d-B", inCityA, inQueueA, threadNumber, inQueueB, inCityB); 
    if (debugMode == 1) 
    { 
     pthread_mutex_lock(&queueA); 
     printQueue(city); 
     pthread_mutex_unlock(&queueA); 
    } 
    city = 'b'; 


    pthread_mutex_unlock(&bridge); 
    sleep(2); 

    int randomNumber = rand() % 4; 

    if (randomNumber % 2 == 0) 
    { 
     addToQueue(city, threadNumber); 
     changeCity2(threadNumber, city); 
    } 
    else 
    { 
     runIntoCity(threadNumber, city); 
    } 
    } 
    else if (city == 'b') 
    { 
    while (queueInB[0] != threadNumber); // Waiting until car is ready to change city - it's first in queue 

    pthread_mutex_lock(&bridge); 


    removeFromQueue(city, threadNumber); 


    printf("\nA-%d %d>>> [<< %d <<] <<<%d %d-B", inCityA, inQueueA, threadNumber, inQueueB, inCityB); 
    if (debugMode == 1) 
    { 
     pthread_mutex_lock(&queueB); 

     printQueue(city); 
     pthread_mutex_unlock(&queueB); 
    } 
    city = 'a'; 


    pthread_mutex_unlock(&bridge); 
    sleep(2); 

    int randomNumber = rand() % 4; 

    if (randomNumber % 2 == 0) 
    { 
     addToQueue(city, threadNumber); 
     changeCity2(threadNumber, city); 
    } 
    else 
    { 
     runIntoCity(threadNumber, city); 
    } 
    } 
} 

char cityDraw() // Being used at start of thread to attach threads to cities 
{ 
    int randomNumber = rand() % 100; 
    int randomNumber2 = rand() % randomNumber; 

    if (randomNumber2 % 2 == 0) 
    { 
    return 'a'; 
    } 
    else 
    { 
    return 'b'; 
    } 
} 

void *threadInitiate(int threadNumber) 
{ 
    char city = cityDraw(); 
    addToQueue(city, threadNumber); 
    while (inQueueA + inQueueB < numberOfCars); // Waiting for all threads to get run by pthread_create 
    changeCity(threadNumber, city); 
} 

void createThreads() 
{ 
    pthread_t car[numberOfCars]; 
    int i; 
    for (i = 0; i < numberOfCars; i++) 
    { 
    int wynik = pthread_create(&car[i], NULL, &threadInitiate, (void *)i + 1); //!!!!!!!!!!!!! 
    if (wynik != 0) printf("Pthread_create failed\n"); 
    else createdThreads++; 
    } 

    for (i = 0; i < numberOfCars; i++) 
    { 
    pthread_join(car[i], NULL); 
    } 
} 

void initiateQueues() // Making every elem. of queues became 0. Just to be sure. Thread numbers are starting from number 1. 
{ 
    int i; 
    for (i = 0; i<numberOfCars; i++) 
    { 
    queueInA[i] = 0; 
    queueInB[i] = 0; 
    } 
} 

int checkNumberOfCars(char *arg) // Parsing and converting to int, numer of cars from parameter 
{ 
    int argSize = 1; 
    while (arg[argSize] != '\0') 
    { 
    argSize++; 
    } 

    char temp[argSize]; 
    int indArg = 1; 
    int indTemp = 0; 
    for (indArg = 1; indArg<argSize; indArg++) 
    { 
    temp[indTemp] = arg[indArg]; 
    indTemp++; 
    } 
    temp[indTemp] = '\0'; 

    int ls = atoi(temp); 
    return ls; 
} 

int debugCheck(int argc, char **argv) // Checking if -debug parameter is given 
{ 
    if (argc>2) 
    { 
    if (strcmp(argv[2], "-debug") == 0) 
     return true; 
    else 
     return false; 
    } 
} 

int main(int argc, char **argv) 
{ 
    numberOfCars = checkNumberOfCars(argv[1]); 
    printf("\nNumber of cars from param = %d", numberOfCars); 
    debugMode = debugCheck(argc, argv); 
    if (debugMode == 1) printf("\nDebugMode is ON - writing queues status on every change"); 
    int queueArrayA[numberOfCars]; 
    int queueArrayB[numberOfCars]; 
    queueInA = queueArrayA; 
    queueInB = queueArrayB; 
    initiateQueues(); 

    pthread_mutex_init(&bridge, NULL); 
    pthread_mutex_init(&queueA, NULL); 
    pthread_mutex_init(&queueB, NULL); 
    pthread_mutex_init(&cityA, NULL); 
    pthread_mutex_init(&cityB, NULL); 
    pthread_mutex_init(&countOfQueueA, NULL); 
    pthread_mutex_init(&countOfQueueB, NULL); 

    createThreads(); 

    return 0; 
} 

Answer 1

这看起来像并发编程课程的作业。这段代码有很多问题，我认为不值得尝试去找出错误，因为你不会得到这个错误，而且无论如何都必须重写。以下是大致按重要性排列的问题。

1. 排队的目的是什么？汽车线程应该都试图锁定互斥锁。程序中不需要队列 - 等待互斥量的线程队列由操作系统在幕后进行管理。该车线程可能应该做这样的事情：

   pthread_mutex_lock(&bridge); 
   // remove car from city of origin 
   // no need for mutex, because only one car can be on the bridge at once, 
   // so only the car on the bridge will modify the car count fields in cities 
   city[i].cars--; 
   sleep(/* some time */); 
   // add car to destination city 
   city[1-i].cars++; 
   pthread_mutex_unlock(&bridge); 
   sleep(/* some time */); 
   

2. 汽车线程将一直运行下去，但他们会继续递归调用的功能越来越多。这将最终炸毁堆栈。将汽车线程函数写成明确的无限循环。没有物理计算机会允许你有一个无限深度的调用图。
3. 吨重复的代码。一切都写了两次，一次为城市'一'，第二次为城市'B'。使用数组并将数字0指定给一个城市，将数字1指定给另一个城市，以便您可以执行诸如city[1-i].car_count++之类的操作。
4. 管理队列数据结构的代码（例如，发现一个空的空间，将队列从队列中移出等等）与其他不相关的代码混合在一起。如果您确实需要这些我怀疑的队列，请编写一个struct car_queue以及添加和删除汽车的操作，而不是直接在函数changeCity2，addToQueue等中写入队列操作。
5. 不必要的互斥。例如，countofQueueA和queueA应该合并为一个互斥量。事实上，可能应该只有三个互斥体：A城市，B城市和桥梁。它甚至可以用一个互斥体来完成。
6. 你为什么要做rand() % 4之后% 2之后的结果呢？它没有任何意义，请立即执行rand() % 2。
7. cityDraw中的双随机化是完全没有意义的，给你一个有点偏见的结果。例如，如果您在第一行中得到0，您将在第二行中获得0,1或2，因此汽车将前往城市A的概率为2/3。如果您在第一行得到0线路上，不管你在第二条路上会得到什么，车子都会去A市。只要做rand() % 2。
8. 千万不要做像#define true 1这样的事情 - 这只是引入了与C++无关的不兼容问题。相反，请使用#include <stdlib.h>并编写TRUE和FALSE。