A very detailed explanation of Linux C++ multi-thread synchronization

Background question: In a specific application scenario, what problems will be caused by not synchronizing multiple threads?

Take multi-threaded simulation of multi-window ticket sales as an example:

#include <iostream>
#include<pthread.h>
#include <stdio.h>
#include<stdlib.h>
#include<string.h>
#include <unistd.h>

using namespace std;

int ticket_sum=20;
void *sell_ticket(void *arg)
{
    for(int i=0; i<20; i++)
    {
        if(ticket_sum>0)
        {
            sleep(1);
            cout<<"sell the "<<20-ticket_sum+1<<"th"<<endl;
            ticket_sum--;
        }
    }
    return 0;
}

int main()
{
    int flag;
    pthread_t tids[4];

    for(int i=0; i<4; i++)
    {
        flag = pthread_create (&tids[i], NULL, &sell_ticket, NULL);
        if(flag)
        {
            cout<<"pthread create error ,flag="<<flag<<endl;
            return flag;
        }
    }

    sleep(20);
    void *ans;
    for(int i=0; i<4; i++)
    {
        flag=pthread_join(tids[i],&ans);
        if(flag)
        {
            cout<<"tid="<<tids[i]<<"join erro flag="<<flag<<endl;
            return flag;
        }
        cout<<"ans="<<ans<<endl;
    }
    return 0;
}

Analysis: There are only 20 tickets in total, but 23 tickets have been sold. This is an obvious overbought and oversold problem. The root cause of this problem is that all threads can read and write ticket_sum at the same time!

ps:

1. In the case of concurrency, the order in which instructions are executed is determined by the kernel. Within the same thread, instructions are executed in order, but it is difficult to tell which instruction is executed first between different threads. If the result of the operation depends on the order in which different threads are executed, then a race condition will be formed. In this case, the result of the calculation is difficult to predict, so the formation of race conditions should be avoided as much as possible.

2. The most common way to resolve race conditions is to combine the two previously separated instructions into an indivisible atomic operation, and other tasks cannot be inserted into the atomic operation!

3. For multithreading, synchronization means that only one thread is allowed to access a resource within a certain period of time, and other threads are not allowed to access the resource during this period of time!

4. Common methods of thread synchronization: mutex locks, condition variables, read-write locks, semaphores

1. Mutex

It is essentially a special global variable with two states: lock and unlock. The unlocked mutex can be obtained by a thread. Once obtained, the mutex will be locked and changed to the locked state. After that, only the thread has the right to open the lock. If other threads want to obtain the mutex, they must wait until the mutex is opened again.

Use mutex locks to synchronize resources:

#include <iostream>
#include<pthread.h>
#include <stdio.h>
#include<stdlib.h>
#include<string.h>
#include <unistd.h>

using namespace std;

int ticket_sum=20;
pthread_mutex_t mutex_x=PTHREAD_MUTEX_INITIALIZER; //static init mutex

void *sell_ticket(void *arg)
{
    for(int i=0; i<20; i++)
    {
        pthread_mutex_lock(&mutex_x);//atomic operation through mutex lock
        if(ticket_sum>0)
        {
            sleep(1);
            cout<<"sell the "<<20-ticket_sum+1<<"th"<<endl;
            ticket_sum--;
        }
        pthread_mutex_unlock(&mutex_x);
    }
    return 0;
}

int main()
{
    int flag;
    pthread_t tids[4];

    for(int i=0; i<4; i++)
    {
        flag = pthread_create (&tids[i], NULL, &sell_ticket, NULL);
        if(flag)
        {
            cout<<"pthread create error ,flag="<<flag<<endl;
            return flag;
        }
    }

    sleep(20);
    void *ans;
    for(int i=0; i<4; i++)
    {
        flag=pthread_join(tids[i],&ans);
        if(flag)
        {
            cout<<"tid="<<tids[i]<<"join erro flag="<<flag<<endl;
            return flag;
        }
        cout<<"ans="<<ans<<endl;
    }
    return 0;
}

Analysis: By adding a mutex lock to the core code segment of ticket sales, it becomes an atomic operation! Will not be affected by other threads

1. Initialization of mutex

The initialization of mutex is divided into static initialization and dynamic initialization

Static: pthread_mutex_t mutex_x=PTHREAD_MUTEX_INITIALIZER; //static init mutex

Dynamic: pthread_mutex_init function

ps: What is the difference between static initialization and dynamic initialization of a mutex?

To be supplemented. . . .

2. Related properties and classification of mutex locks

//Initialize mutex attributes pthread_mutexattr_init(pthread_mutexattr_t attr);

//Destroy the mutex attribute pthread_mutexattr_destroy(pthread_mutexattr_t attr);

//Used to obtain the mutex lock attribute int pthread_mutexattr_getpshared(const pthread_mutexattr_t *restrict attr, int *restrict pshared);

//Used to set mutex lock attributes int pthread_mutexattr_setpshared(pthread_mutexattr_t *attr, int pshared);

attr represents the attributes of the mutex

pshared represents the shared attribute of the mutex lock, and has two possible values:

1) PTHREAD_PROCESS_PRIVATE: The lock can only be used for mutual exclusion between two threads within a process (default)

2) PTHREAD_PROCESS_SHARED: The lock can be used for mutual exclusion of threads in two different processes. When using it, you also need to allocate a mutex in the process shared memory, and then specify the attributes for the mutex.

Classification of mutex locks:

//Get the mutex type int pthread_mutexattr_gettype(const pthread_mutexattr_t *restrict attr, int *restrict type);

//Set the mutex type int pthread_mutexattr_settype(const pthread_mutexattr_t *restrict attr, int type);

The parameter type indicates the type of the mutex lock, which has the following four types:

1.PTHREAD_MUTEX_NOMAL: standard mutex lock, the first lock succeeds, the second lock fails and blocks

2. PTHREAD_MUTEX_RECURSIVE: recursive mutex lock, the first lock is successful, the second lock will also be successful, it can be understood as an internal counter, each lock counter plus 1, unlock minus 1

3.PTHREAD_MUTEX_ERRORCHECK: Check the mutex lock. The first lock will succeed. The second lock will return an error message without blocking.

4.PTHREAD_MUTEX_DEFAULT: default mutex lock, the first lock will succeed, the second lock will fail

3. Test the lock function

int pthread_mutex_lock(&mutex): Test that the lock function returns EBUSY instead of hanging and waiting when the lock is already occupied. Of course, if the lock is not occupied, the lock can be obtained.

In order to clearly see the situation where two threads compete for resources, we make one function use the test lock function to lock, and the other use the normal lock function to lock

#include <iostream>
#include<pthread.h>
#include <stdio.h>
#include<stdlib.h>
#include<string.h>
#include <unistd.h>
#include <errno.h>
using namespace std;

int ticket_sum=20;
pthread_mutex_t mutex_x=PTHREAD_MUTEX_INITIALIZER; //static init mutex

void *sell_ticket_1(void *arg)
{
    for(int i=0; i<20; i++)
    {
        pthread_mutex_lock(&mutex_x);
        if(ticket_sum>0)
        {
            sleep(1);
            cout<<"thread_1 sell the "<<20-ticket_sum+1<<"th ticket"<<endl;
            ticket_sum--;
        }
        sleep(1);
        pthread_mutex_unlock(&mutex_x);
        sleep(1);
    }
    return 0;
}

void *sell_ticket_2(void *arg)
{
    int flag;
    for(int i=0; i<10; i++)
    {
        flag=pthread_mutex_trylock(&mutex_x);
        if(flag==EBUSY)
        {
            cout<<"sell_ticket_2:the variable is locked by sell_ticket_1"<<endl;
        }
        else if(flag==0)
        {
            if(ticket_sum>0)
            {
                sleep(1);
                cout<<"thread_2 sell the "<<20-ticket_sum+1<<"th ticket"<<endl;
                ticket_sum--;
            }
            pthread_mutex_unlock(&mutex_x);
        }
        sleep(1);
    }
    return 0;
}
int main()
{
    int flag;
    pthread_t tids[2];

    flag = pthread_create (&tids[0], NULL, &sell_ticket_1, NULL);
    if(flag)
    {
        cout<<"pthread create error ,flag="<<flag<<endl;
        return flag;
    }

    flag = pthread_create (&tids[1], NULL, &sell_ticket_2, NULL);
    if(flag)
    {
        cout<<"pthread create error ,flag="<<flag<<endl;

        return flag;
    }

    void *ans;
    sleep(30);
    flag=pthread_join(tids[0],&ans);
    if(flag)
    {
        cout<<"tid="<<tids[0]<<"join erro flag="<<flag<<endl;
        return flag;
    }
    else
    {
        cout<<"ans="<<ans<<endl;
    }

    flag=pthread_join(tids[1],&ans);
    if(flag)
    {
        cout<<"tid="<<tids[1]<<"join erro flag="<<flag<<endl;
        return flag;
    }
    else
    {
        cout<<"ans="<<ans<<endl;
    }

    return 0;
}

Analysis: By testing the lock function, we can clearly see the situation where two threads compete for resources.

2. Condition variables

Mutexes are not omnipotent. For example, if a thread is waiting for a condition to occur in shared data, it may need to repeatedly lock and unlock the data object (polling). However, such polling is very time-consuming and resource-intensive, and very inefficient, so mutex locks are not suitable for this situation.

We need a method that puts the thread to sleep while it is waiting for a certain condition to be met, and once the condition is met, switches the thread that is sleeping while waiting for a specific condition to be met.

If we can implement such a method, the efficiency of the program will undoubtedly be greatly improved, and this method is the conditional variable!

Example:

#include <iostream>
#include<pthread.h>
#include <stdio.h>
#include<stdlib.h>
#include<string.h>
#include <unistd.h>
#include <errno.h>
using namespace std;

pthread_cond_t qready=PTHREAD_COND_INITIALIZER; //cond
pthread_mutex_t qlock=PTHREAD_MUTEX_INITIALIZER; //mutex

int x=10,y=20;

void *f1(void *arg)
{
  cout<<"f1 start"<<endl;
  pthread_mutex_lock(&qlock);
  while(x<y)
  {
    pthread_cond_wait(&qready,&qlock);
  }
  pthread_mutex_unlock(&qlock);
  sleep(3);
  cout<<"f1 end"<<endl;
  return 0;
}

void *f2(void *arg)
{
  cout<<"f2 start"<<endl;
  pthread_mutex_lock(&qlock);
  x=20;
  y=10;
  cout<<"has a change,x="<<x<<" y="<<y<<endl;
  pthread_mutex_unlock(&qlock);
  if(x>y)
  {
    pthread_cond_signal(&qready);
  }
  cout<<"f2 end"<<endl;
  return 0;
}

int main()
{
  pthread_t tids[2];
  int flag;

  flag = pthread_create (&tids[0], NULL, f1, NULL);
  if(flag)
  {
    cout<<"pthread 1 create error "<<endl;
    return flag;
  }

  sleep(2);

  flag = pthread_create (&tids[1], NULL, f2, NULL);
  if(flag)
  {
    cout<<"pthread 2 create erro "<<endl;
    return flag;
  }

  sleep(5);
  return 0;
}

Analysis: Thread 1 is blocked because the condition is not met, then Thread 2 runs and changes the condition. Thread 2 issues a condition change notification to Thread 1, then Thread 2 ends, then Thread 1 continues to run, then Thread 1 ends. To ensure that Thread 1 executes first, we sleep for 2 seconds before creating Thread 2.

ps:

1. Condition variables make up for the shortcomings of mutex locks by blocking the running thread and waiting for another thread to send a signal. They are often used together with mutex locks. When used, condition variables are used to block a thread. When the condition is not met, the thread often unlocks the corresponding mutex lock and waits for the condition to change. Once another thread changes the condition variable, it will notify the corresponding condition variable to switch lines. One or more threads that are blocked by this condition variable will relock the mutex lock and retest whether the condition is met.

1. Related functions of conditional variables

1) Create

Static method: pthread_cond_t cond PTHREAD_COND_INITIALIZER

Dynamic method: int pthread_cond_init(&cond,NULL)

The condition variables implemented by Linux thread do not support attributes, so NULL (cond_attr parameter)

2) Logout

int pthread_cond_destory(&cond)

The condition variable can be deregistered only if there is no thread on the condition variable, otherwise EBUSY is returned.

Because the condition variables implemented by Linux do not allocate any resources, the logout action only includes checking whether there are waiting threads! (Please refer to the underlying implementation of condition variables)

3) Wait

Conditional wait: int pthread_cond_wait(&cond,&mutex)

Timed wait: int pthread_cond_timewait(&cond,&mutex,time)

1. If the condition is not met before the given time, ETIMEOUT is returned and the wait ends.

2. Regardless of the waiting method, there must be a mutex lock to prevent multiple threads from requesting pthread_cond_wait at the same time to form a race condition!

3. The thread must lock before calling pthread_cond_wait

4) Stimulation

Stimulate a waiting thread: pthread_cond_signal(&cond)

Stimulate all waiting threads: pthread_cond_broadcast(&cond)

The important thing is that pthread_cond_signal will not have the thundering herd effect, that is, it will send a signal to at most one waiting thread, and will not send a signal to all threads to wake them up and then ask them to compete for resources themselves!

pthread_cond_signal determines which waiting thread to trigger based on the priority and waiting time of the waiting thread.

Let's look at a program and find the problems with it.

#include <iostream>
#include<pthread.h>
#include <stdio.h>
#include<stdlib.h>
#include<string.h>
#include <unistd.h>
#include <errno.h>
using namespace std;

pthread_cond_t taxi_cond=PTHREAD_COND_INITIALIZER; //taxi arrive cond
pthread_mutex_t taxi_mutex=PTHREAD_MUTEX_INITIALIZER; // sync mutex

void *traveler_arrive(void *name)
{
    cout<<"Traveler:"<<(char*)name<<" needs a taxi now!"<<endl;
    pthread_mutex_lock(&taxi_mutex);
    pthread_cond_wait(&taxi_cond,&taxi_mutex);
    pthread_mutex_unlock(&taxi_mutex);
    cout<<"Traveler:"<<(char*)name<<" now got a taxi!"<<endl;
    pthread_exit((void*)0);
}

void *taxi_arrive(void *name)
{
    cout<<"Taxi:"<<(char*)name<<" arriver."<<endl;
    pthread_cond_signal(&taxi_cond);
    pthread_exit((void*)0);
}

int main()
{
    pthread_t tids[3];
    int flag;

    flag = pthread_create (&tids[0], NULL, taxi_arrive, (void*)("Jack"));
    if(flag)
    {
        cout<<"pthread_create error:flag="<<flag<<endl;
        return flag;
    }
    cout<<"time passing by"<<endl;
    sleep(1);

    flag = pthread_create(&tids[1],NULL,traveler_arrive,(void*)("Susan"));
    if(flag)
    {
        cout<<"pthread_create error:flag="<<flag<<endl;
        return flag;
    }
    cout<<"time passing by"<<endl;
    sleep(1);

    flag = pthread_create (&tids[2], NULL, taxi_arrive, (void*)("Mike"));
    if(flag)
    {
        cout<<"pthread_create error:flag="<<flag<<endl;
        return flag;
    }
    cout<<"time passing by"<<endl;
    sleep(1);

    void *ans;
    for(int i=0; i<3; i++)
    {
        flag=pthread_join(tids[i],&ans);
        if(flag)
        {
            cout<<"pthread_join error:flag="<<flag<<endl;
            return flag;
        }
        cout<<"ans="<<ans<<endl;
    }
    return 0;
}

Analysis: The program consists of a conditional variable to remind passengers that a taxi has arrived, and a synchronization lock. After the passenger arrives, she waits for the car (conditional variable). After the taxi arrives, the passenger is notified. We can see that after passenger Susan arrived, she did not take Jack's car, which arrived first, but waited until Mike's car arrived before taking Mike's car. Jack's car was idle. Why did this happen? Let's analyze the code: we find that after Jack's taxi arrives, it calls pthread_cond_signal(&taxi_cond) and finds that there are no passengers, so it ends the thread directly. . . .

The correct operation should be: Jack, who arrived first, found that there were no passengers, and then waited for passengers. If passengers arrived, he would leave directly, and we should count the number of passengers.

Make the following improvements:

1. Add a passenger counter so that the taxi can leave directly after a passenger arrives, instead of waiting for other passengers (dead thread)

2. Add a while loop to the taxi arrival function. When there are no passengers, it will wait until the passenger arrives.

#include <iostream>
#include<pthread.h>
#include <stdio.h>
#include<stdlib.h>
#include<string.h>
#include <unistd.h>
#include <errno.h>
using namespace std;

pthread_cond_t taxi_cond=PTHREAD_COND_INITIALIZER; //taxi arrive cond
pthread_mutex_t taxi_mutex=PTHREAD_MUTEX_INITIALIZER; // sync mutex


void *traveler_arrive(void *name)
{
    cout<<"Traveler:"<<(char*)name<<" needs a taxi now!"<<endl;
    pthread_mutex_lock(&taxi_mutex);
 
    pthread_cond_wait(&taxi_cond,&taxi_mutex);
    pthread_mutex_unlock(&taxi_mutex);
    cout<<"Traveler:"<<(char*)name<<" now got a taxi!"<<endl;
    pthread_exit((void*)0);
}

void *taxi_arrive(void *name)
{
    cout<<"Taxi:"<<(char*)name<<" arriver."<<endl;
    
    pthread_exit((void*)0);
}

int main()
{
    pthread_t tids[3];
    int flag;

    flag = pthread_create (&tids[0], NULL, taxi_arrive, (void*)("Jack"));
    if(flag)
    {
        cout<<"pthread_create error:flag="<<flag<<endl;
        return flag;
    }
    cout<<"time passing by"<<endl;
    sleep(1);

    flag = pthread_create(&tids[1],NULL,traveler_arrive,(void*)("Susan"));
    if(flag)
    {
        cout<<"pthread_create error:flag="<<flag<<endl;
        return flag;
    }
    cout<<"time passing by"<<endl;
    sleep(1);

    flag = pthread_create (&tids[2], NULL, taxi_arrive, (void*)("Mike"));
    if(flag)
    {
        cout<<"pthread_create error:flag="<<flag<<endl;
        return flag;
    }
    cout<<"time passing by"<<endl;
    sleep(1);

    void *ans;
    for(int i=0; i<3; i++)
    {
        flag=pthread_join(tids[i],&ans);
        if(flag)
        {
            cout<<"pthread_join error:flag="<<flag<<endl;
            return flag;
        }
        cout<<"ans="<<ans<<endl;
    }
    return 0;
}

3. Read-write lock

Multiple threads can read at the same time, but multiple threads cannot write at the same time

1. Read-write locks are more applicable and parallel than mutex locks

2. Read-write locks are most suitable for situations where the number of read operations on data structures exceeds the number of write operations!

3. When the lock is in read mode, it can be shared by threads, but when the lock is in write mode, it can only be exclusive, so the read-write lock is also called a shared-exclusive lock.

4. There are two strategies for read-write locks: strong read synchronization and strong write synchronization

In strong read synchronization, readers are always given higher priority. As long as writers are not performing write operations, readers can obtain access rights.

In strong write synchronization, writers are always given higher priority, and readers can only read after all waiting or executing writers have completed.

Different systems use different strategies. For example, the flight booking system uses strong write synchronization, while the library reference system uses strong read synchronization.

Adopt different strategies according to different business scenarios

1) Initialized destruction of read-write lock

Static initialization: pthread_rwlock_t rwlock=PTHREAD_RWLOCK_INITIALIZER

Dynamic initialization: int pthread_rwlock_init(rwlock, NULL), NULL means the read-write lock uses the default attributes

Destroy the read-write lock: int pthread_rwlock_destory(rwlock)

Before releasing the resources of a read-write lock, you need to clean up the read-write lock through the pthread_rwlock_destory function. Releases resources allocated by the pthread_rwlock_init function

If you want the read-write lock to use non-default attributes, attr cannot be NULL and you must assign a value to attr

int pthread_rwlockattr_init(attr), initialize attr

int pthread_rwlockattr_destory(attr), destroy attr

2) Acquire the lock in write mode, acquire the lock in read mode, and release the read-write lock

int pthread_rwlock_rdlock(rwlock), acquire the lock in read mode

int pthread_rwlock_wrlock(rwlock), acquire the lock in write mode

int pthread_rwlock_unlock(rwlock), release the lock

The above two ways of acquiring locks are both blocking functions, that is, if the lock cannot be acquired, the calling thread does not return immediately, but blocks execution. When a write operation is required, this blocking way of acquiring locks is very bad. Think about it, I need to write, not only did I not get the lock, I have to wait here, which greatly reduces efficiency.

So we should acquire the lock in a non-blocking way:

int pthread_rwlock_tryrdlock(rwlock)

int pthread_rwlock_trywrlock(rwlock)

Example of a read-write lock:

#include <iostream>
#include<pthread.h>
#include <stdio.h>
#include<stdlib.h>
#include<string.h>
#include <unistd.h>
#include <errno.h>
using namespace std;

int num=5;
pthread_rwlock_t rwlock;

void *reader(void *arg)
{
  pthread_rwlock_rdlock(&rwlock);
  cout<<"reader "<<(long)arg<<" got the lock"<<endl;
  pthread_rwlock_unlock(&rwlock);
  return 0;
}

void *writer(void *arg)
{
  pthread_rwlock_wrlock(&rwlock);
  cout<<"writer "<<(long)arg<<" got the lock"<<endl;
  pthread_rwlock_unlock(&rwlock);
  return 0;
}

int main()
{
  int flag;
  long n=1,m=1;
  pthread_t wid,rid;
  pthread_attr_t attr;

  flag=pthread_rwlock_init(&rwlock,NULL);
  if(flag)
  {
    cout<<"rwlock init error"<<endl;
    return flag;
  }

  pthread_attr_init(&attr);
  pthread_attr_setdetachstate(&attr,PTHREAD_CREATE_DETACHED);//thread sepatate

  for(int i=0;i<num;i++)
  {
    if(i%3)
    {
      pthread_create(&rid,&attr,reader,(void *)n);
      cout<<"create reader "<<n<<endl;
      n++;
    }else
    {
      pthread_create(&wid,&attr,writer,(void *)m);
      cout<<"create writer "<<m<<endl;
      m++;
    }
  }

  sleep(5);//wait other done
  return 0;
}

Analysis: 3 read threads, 2 write threads, more read threads than write threads

When the read-write lock is in the write state, all threads attempting to lock the lock will be blocked before the lock is unlocked.

When the read-write lock is in read state, before the lock is unlocked, all threads that attempt to lock it in read mode can gain access, but threads that attempt to lock it in write mode will be blocked.

So the read-write lock is in strong read mode by default!

4. Semaphore

The difference between a semaphore (sem) and a mutex lock: a mutex lock only allows one thread to enter the critical section, while a semaphore allows multiple threads to enter the critical section

1) Semaphore initialization

int sem_init(&sem,pshared,v)

pshared is 0, indicating that this semaphore is a local semaphore of the current process.

pshared is 1, which means that this semaphore can be shared among multiple processes.

v is the initial value of the semaphore

Returns 0 if successful, -1 if failed

2) Addition and subtraction of signal values

int sem_wait(&sem): decrements the value of the semaphore by 1 in an atomic operation

int sem_post(&sem): adds 1 to the semaphore value in an atomic operation

3) Clean up the semaphore

int sem_destory(&sem)

Use semaphores to simulate the process of serving 2 windows and 10 guests

Example:

#include <iostream>
#include<pthread.h>
#include <stdio.h>
#include<stdlib.h>
#include<string.h>
#include <unistd.h>
#include <errno.h>
#include <semaphore.h>
using namespace std;


int num=10;
sem_t sem;

void *get_service(void *cid)
{
  int id=*((int*)cid);
  if(sem_wait(&sem)==0)
  {
     sleep(5);
     cout<<"customer "<<id<<" get the service"<<endl;
     cout<<"customer "<<id<<" done "<<endl;
     sem_post(&sem);
  }
  return 0;
}

int main()
{
  sem_init(&sem,0,2);
  pthread_t customer[num];
  int flag;

  for(int i=0;i<num;i++)
  {
    int id=i;
    flag=pthread_create(&customer[i],NULL,get_service,&id);
    if(flag)
    {
      cout<<"pthread create error"<<endl;
      return flag;
    }else
    {
      cout<<"customer "<<i<<" arrived "<<endl;
    }
    sleep(1);
  }

  //wait all threads done
  for(int j=0;j<num;j++)
  {
    pthread_join(customer[j],NULL);
  }
  sem_destroy(&sem);
  return 0;
}

Analysis: The value of the semaphore represents an idle service window. Each window can only serve one person at a time. If there is an idle window, the semaphore is -1 before the service starts, and the semaphore is +1 after the service is completed.

Summary: Four ways of Linux C++ thread synchronization: mutex locks, conditional variables, read-write locks, semaphores

This concludes this article on the super detailed explanation of Linux C++ multi-threaded synchronization methods. For more relevant Linux C++ multi-threaded synchronization content, please search for previous articles on 123WORDPRESS.COM or continue to browse the following related articles. I hope everyone will support 123WORDPRESS.COM in the future!