使用 pthread 库的线程间同步

Question

For example, we have 5 pieces of data.(assume we have a lot of space, different version of data will not overlap each others.)

DATA0, DATA1, DATA2, DATA3, DATA4.

We have 3 threads(less than 5) working on those data.

Thread 1, working on DATA1 (version 0), has accessed some data from both DATA0(version 0) and DATA2(version 0), and create DATA1(version 1).

Thread 2, working on DATA3 (version 0), has accessed some data from both DATA2(version 0) and DATA4(version 0), and create DATA3(version 1).

Thread 3, working on DATA2 (version 0), has accessed some data from both DATA1(version 0) and DATA3(version 0), and create DATA2(version 1).

Now, if thread 1 finishes first. It has several choices, it can work on DATA0 (to create DATA0 version 1) since DATA1(version 0) and DATA4 (version 0) is available (Assume DATA0 & DATA4 are neighbors). It can also work on DATA 2 if it finds out that both DATA1(version1) and DATA3(version1) are available and create DATA2(version 2).

The requirement is the next version of data can be processed once it's neighbor data is ready(in 1 lower version).

At last, I want all threads to exit when all data arrive at version 10.

Question: How to implement this scheme using pthread library.

Note: I want to have data in different versions at the same time, so to create a barrier and make sure all data reach the same version is not an option.

Answer 1

Lets discuss the implementation. To have all versions (0~10) stored we would need 5*11*sizeof(data) space. Let us create two arrays of size 5 x 11. First array is DATA such that DATA[i][j] is the j th version of data i. Second array is an 'Access Matrix' - A, it denotes the state of an index, it could be:

• Not started
• In Progress
• Completed

Algorithm: Each thread would search for an index [i][j] in the matrix such that, index [i-1][j-1] and [i+1][j-1] is 'Completed'. It would set A[i][j] to 'In Progress' while working on it. In case i=0, i-1 refers to n-1, if i=n-1, i+1 refers to 0. (like a circular queue). When all entries in the last column are 'Completed', the thread terminates. Otherwise it searches for a new data which is not completed.

Using pthread library to realize this:

Important variables: mutex, conditional variables.

pthread_mutex_t mutex= PTHREAD_MUTEX_INITIALIZER;

pthread_cond_t condvar= PTHREAD_COND_INITIALIZER;

mutex is a 'lock'. We use it when we need to make an operation atomic . Atomic operation refers to an operation that needs to be done in 1 step without breaking execution. 'condvar' is a condition variable. Using it a thread can sleep until a condition is reached, when it is reached, the thread is woken up. This avoids busy waiting using a loop.

Here, our atomic operation is updating A. Reason: If the threads simultaneously update A, it may lead to race conditions such as more than 1 thread working on a Data in parallel.

To realize this, we search and set A inside the lock. Once A is set, we release the lock and work on the data. But if no available data was found which could be worked on, we wait on the conditional variable - condvar . When we call wait on condvar, we also pass mutex. While inside the lock, wait function releases the mutex lock and waits for the conditional variable to be signaled. Once it is signaled, it requires the lock and proceeds with execution. While waiting process is in sleeping state and hence does not waste CPU time.

Whenever any thread finishes working on a piece of data, it may prepare 1 or more other samples for being worked on. Hence after a thread finishes work, it signals all other threads to check for a 'workable' Data before continuing the algorithm. Pseudo code for this is as follows:

Read the comments and function names. They describe in detail the working of pthread library. While compilation with gcc add -lpthread flag and for further details of the library looking up the man pages of these functions is more than sufficient.

void thread(void)
{
    //Note: If there are various threads in the line pthread_mutex_lock(&mutex)
    // each will wait till the lock is released and acquired. Until then it will sleep.
    pthread_mutex_lock(&mutex); //Do the searching inside the lock
    while(lastColumnNotDone){   //This will avoid previously searched indices being updated
    //Search for a workable index
        if(found)
        {   //As A has been updated and set to in progress, no need to hold lock. As we start work on the thread we release the lock so other process might use it.
            pthread_mutex_unlock(&mutex); //Note:
            //WORK ON DATA
            pthread_mutex_lock(&mutex); //Restore lock to in order to continue thread's execution safely.
            pthread_cond_broadcast(&condvar); //Sends a wake up signal to all threads which are waiting for the conditional variable 'condvar'.
        }
        else //No executable data found
            pthread_cond_wait(&condvar,&mutex); //While waiting, we pass the address of mutex as second parameter to wait function. This releases the lock on mutex while this function is waiting and tries to reacquire it once condvar is signaled.
    }
    pthread_mutex_unlock(&mutex);
}

Search and checking if all data is completed in the while loop condition can be optimized but that is a different algorithms question. Key idea here is use of pthread library and thread concept.

• A is a common access matrix. Do NOT update it outside of lock.
• While checking anything with respect to A, such as finding a process or checking if all data is done, lock must be held. Otherwise A can be changed by a different thread at the same time a thread is reading it.
• We acquire and release locks using the functions pthread_mutex_lock and pthread_mutex_unlock. Remember, these functions take pointers of the mutex and not it's value. It is a variable that needs to be accessed and updated.
  • Avoid holding the lock for long amounts of time. This will cause the threads to wait for a long time for small access needs.
  • When calling wait, be sure that lock is held. Wait unlocks the mutex held passed as the second parameter during the duration of it's wait. After receiving the signal to wake up it tries to acquire the lock once again.