What are the knowledge points of Linux multi-thread programming?

Linux threads are divided into two categories: one is core-level support threads, and the other is user-level threads. Generally, they are user-level threads.

1. Several common functions of multi-threading

To create multi-threads, you must load the pthread.h file and the library file pthread. The thread identifier pthread_t is defined in the header file /usr/include/bits/pthreadtypes.h: typedef unsigned long int pthread_t

1. Create a thread:

int pthread_create(pthread_t *restrict thread ,
           const pthread_attr_t *restrict attr,
           void *(*start_routine)(void*), void *restrict arg);
参数:
      thread输出线程id
     attr 线程属性， 默认null
start_routine thread execution function
arg thread execution parameter
note: The function returns 0 successfully, otherwise it returns an error code

2. Wait for the end of the specified thread:

int pthread_join(pthread_t thread,void **value_ptr);
Parameters:
threadA valid thread id
value_ptr A pointer to receive the thread return value
note: The thread calling this function is in The specified thread will be in a suspended state or return directly with an error before exiting. If value_ptr is not null, value_ptr points to the pointer of the thread return value. The resources used by the specified thread will be released after the function succeeds.

3. Exit the thread:

int pthread_exit(void * value_ptr);
Parameters:
value_ptr thread return value pointer
note: ptrhead_exit ()Exit the thread that called this function and release the resources occupied by the thread.

4. Get the current thread id:

pthread_t pthread_self(void);
Parameters:      
note: Return the id of the current function

5. Mutex

Create a mutex:
int pthread_mutex_init(pthread_mutex_t *restrict mutex,
                        const pthread_mutexattr_t *restrict attr);
Parameters:
mutex output mutex id
attr mutex attribute, default null
note: The function returns 0 successfully, otherwise it returns an error code
Lock the mutex:
int pthread_mutex_lock(pthread_mutex_t *mutex);
Parameter:
mutex mutex id
note: If the specified mutex id has been locked, the calling thread will remain in a suspended state until the mutex id is fully unlocked, otherwise the mutex will be locked.
int pthread_mutex_trylock(pthread_mutex_t *mutex);
Parameters:
mutex mutex id
note: If the specified mutex id has been locked, an error will be returned directly. By judging this error Processed differently. pthread_mutex_trylock is similar to pthread_mutex_lock, except that pthread_mutex_trylock only blocks when the mutex is locked.
Unlock mutex:
int pthread_mutex_unlock(pthread_mutex_t *mutex);
Parameter:
mutex mutex id
note: If the specified mutex id has been locked, unlock it
Release mutex:
int pthread_mutex_destroy(pthread_mutex_t *mutex);
Parameters:
mutex mutex id
note: Release the resources occupied by the specified mutex.
The functions pthread_mutex_init and pthread_mutex_destroy are the constructor and destructor of the mutex lock respectively.

2. Multi-thread synchronization

1. Mutex

A mutex is equivalent to a lock and can guarantee the following three points:
◎Atomicity: If a thread locks a mutex, then all operations in the critical section will either be completed or none of them will be executed.
◎Uniqueness: If a thread locks a mutex, no other thread can lock the mutex until it unlocks it.
◎Non-busy waiting: If a thread has locked a mutex and a second thread tries to lock the mutex, the second thread will be suspended (without occupying any CPU resources) until the second thread until a thread unlocks the mutex.

2. Condition variable

Condition variable is a mechanism that allows threads (without consuming cpu) to wait for certain events to occur. Some threads may wait on a condition variable until some other thread sends a signal to the condition variable, at which time one of these threads will wake up and handle the event. But the condition variable does not provide locking, so it must be used with a mutex to provide the necessary locking when accessing this environment variable.
3. Semaphore
Dijkstra proposed the concept of semaphore. The semaphore is a special variable that can only take positive integer values. Only two operations can be taken on this positive integer: p operation (represents waiting) , off operation) and v operation (representing signal, on operation).
The p/v operation is defined as follows (assuming we have a semaphore sem):
p(sem): If the value of sem is greater than 0, then sem is reduced by 1; if the value of sem is 0, then the thread.
v(sem): If there are other processes suspended waiting for sem, let it resume execution; if no thread is suspended waiting for sem, sem is increased by 1.
Creation and opening of signal set
int semget(key_t key,int nsems,int flag);
Operation of semaphore
int semop(int semid,struct sembuf semoparray[],size_t nops );
Control of semaphores
int semctl(int semid,int semnum int cmd,union semun arg);
Attachment: The classic producer-consumer problem (producer-costomer) is a famous synchronization issues.

The above is the detailed content of What are the knowledge points of Linux multi-thread programming?. For more information, please follow other related articles on the PHP Chinese website!