C：線程同步使用pthreads，鎖定和解鎖互斥鎖

Question

我正在做一個更大的項目，包括兩個線程，其中一個數據庫在它們之間共享。 一個線程的工作是倒計時每個活動元素計時器，當該元素的計時器為零時，它應該將其設置為非活動並將其歸零。

主線程只是以某種方式操作活動元素的其他變量。

我不知道如何同步這些線程，特別是當計時器達到零時計時器線程清理數據庫元素時。 現在我相信在main()的while(1)循環中解鎖和鎖定mutex之間的時間可能太快了？

如果計時器線程在pthread_mutex_lock()等待mutex解鎖； 並且它在main()中解鎖，我們是否知道計時器線程將是下一個鎖定mutex鎖的線程，或者main()可能太快以至於它再次鎖定它，因為pthread_mutex_unlock()和pthread_mutex_lock() () 之間沒有任務pthread_mutex_lock() ?

我沒有使用條件變量的經驗，這可能是個好主意嗎？

這是我更大的項目的最小工作示例。

#include <stdio.h>
#include <pthread.h>
#include <string.h>
#include <time.h>

#define NUM_COMPUTER 10

typedef struct computer
{
    unsigned int active;
    unsigned int timer;
    int x;
}computer_t;

/**
 * Function declarations
 */
void activate(computer_t* comp);
void* timerFunction(void* args);

/**
 * Global variables
 */
computer_t database[NUM_COMPUTER];
pthread_mutex_t mutex;

主要（） function

/**
 * Main
 */
int main(void)
{
    memset(database, 0, sizeof database);

    // Initialize some database elements
    activate(database);
    database[0].x = 5;

    activate(database + 3);
    database[3].x = 23;

    activate(database + 9);
    database[9].x = -7; 

    pthread_t timer_thread;
    pthread_create(&timer_thread, NULL, timerFunction, NULL);

    while(1)
    {
        /**
         * MAY PROBLEMS OCCUR HERE? UNLOCKING AND LOCKING ALMOST DIRECTLY
         */
         
        // ************* LOCK *************
        pthread_mutex_lock(&mutex);

        /**
         * Manipulate struct members 
         */
        for (int i = 0; i < NUM_COMPUTER; i++)
        {
            if (database[i].active)
            {
                database[i].x += 1;
            }
        }
        // ************* UNLOCK *************
        pthread_mutex_unlock(&mutex);
    }

    return 0;
}

額外功能

void activate(computer_t* comp)
{
    comp->active = 1;
    comp->timer = 100;
}

void* timerFunction(void* args)
{
    struct timespec ts;

    // Sleep interval before checking database again
    ts.tv_sec = 1;
    ts.tv_nsec = 0;

    while(1)
    {
        // ************* LOCK *************
        pthread_mutex_lock(&mutex);

        /**
         * Go through every database index
         */
        for (int index = 0; index < NUM_COMPUTER; index++)
        {   
            if (database[index].active)
            {
                if (database[index].timer > 0)
                {
                    database[index].timer--;
                }
                else
                {
                    /**
                     * Clean up database index
                     */
                    memset(database + index, 0, sizeof database);
                }
            }
        }

        // ************* UNLOCK *************
        pthread_mutex_unlock(&mutex);

        /**
         * Sleep 1 sec before checking database again
         */
        nanosleep(&ts, NULL);
    }
}

Answer 1

如果計時器線程在pthread_mutex_lock()等待mutex解鎖； 它在main()中解鎖，我們是否知道計時器線程將是下一個鎖定mutex鎖的線程

不。

至少，不是一般的。 這是線程調度策略的問題，您的特定平台可能允許也可能不允許您調整。 pthreads API 在這方面不做任何保證。

或者可能main()太快以至於它再次鎖定它，因為pthread_mutex_unlock()和pthread_mutex_lock()之間沒有任務？

這不僅是可能的，而且很有可能至少在某些時候會發生。

我沒有使用條件變量的經驗，這可能是個好主意嗎？

條件變量是隨身攜帶的重要工具，但我認為沒有理由認為它們在這里會有特別的幫助。

您提供的代碼的主要問題是，兩個線程必須在它們處於活動狀態時基本上鎖定整個世界以供自己獨占使用。 因此，即使所有鎖定都按預期工作，您也不會有真正的並發性，因此多線程會增加復雜性而不會賦予任何實際優勢。

如果您想繼續在該模式下，那么我會放棄多線程，而是設置一個POSIX 計時器以每隔一秒（或您喜歡的任何間隔）引發一個標志。 然后，您的單線程程序可以在每次循環迭代的頂部檢查該標志，以確定是執行其正常工作還是執行一次超時管理。

如果您想要真正的並發，那么您可能需要縮小由互斥鎖保護的關鍵區域，或者從保護所有內容的單個互斥鎖更改為多個互斥鎖，每個互斥鎖保護所有事物的子集。 也許您可以替代地圍繞原子對象和操作而不是互斥體進行修改，但到目前為止我所看到的並沒有讓我對此充滿信心。