Shulou(Shulou.com)06/03 Report--

This article introduces the knowledge of "what is linux multithreaded programming". In the operation of actual cases, many people will encounter such a dilemma, so let the editor lead you to learn how to deal with these situations. I hope you can read it carefully and be able to achieve something!

Thread classification

According to its scheduler, threads can be divided into user-level threads and core-level threads.

(1) user-level thread

User-level thread mainly solves the problem of context switching, and its scheduling algorithm and scheduling process are all decided by the user, and do not need specific kernel support at run time. Here, the operating system often provides a user-space thread library, which provides thread creation, scheduling, revocation and other functions, while the kernel still only manages the process. If a thread in a process calls a blocked system call, the process, including all other threads in the process, is also blocked. The main disadvantage of this user-level thread is that it can not take advantage of multiprocessors in the scheduling of multiple threads in a process.

(2) Core level thread

This kind of thread allows threads in different processes to be scheduled according to the same relative priority scheduling method, so that they can take advantage of the concurrency of multiprocessors.

Nowadays, most systems adopt the method of coexistence of user-level thread and core-level thread. A user-level thread can correspond to one or more core-level threads, that is, an one-to-one or many-to-one model. This can not only meet the needs of multiprocessor systems, but also minimize the scheduling overhead.

The threading implementation of Linux is done outside the core, and what is provided in the core is the interface do_fork () that creates the process. The kernel provides two system calls, clone () and fork (), which end up calling API in the do_fork () kernel with different parameters. Of course, it is impossible to implement threads without core support for shared data segments by multiple processes (actually lightweight processes), so do_fork () provides a lot of parameters, including CLONE_VM (shared memory space), CLONE_FS (shared file system information), CLONE_FILES (shared file descriptor table), CLONE_SIGHAND (shared signal handle table) and CLONE_PID (shared process ID, only for in-kernel processes. That is, process 0 is valid. When using the fork system call, the kernel call do_fork () does not use any shared properties, and the process has an independent running environment, and when you use pthread_create () to create a thread, all these properties are finally set to call _ _ clone (), and all these parameters are passed to do_fork () in the kernel, so that the created "process" has a shared running environment, and only the stack is independent, passed in by _ _ clone ().

Linux threads exist in the form of lightweight processes in the core and have independent process table items, while all creation, synchronization, deletion and other operations are carried out in the out-of-core pthread library. The pthread library uses a management thread (_ _ pthread_manager (), each process is independent and unique) to manage thread creation and termination, assigns thread ID to the thread, and sends thread-related signals (such as Cancel), while the caller of the main thread (pthread_create ()) pipelines the request information to the management thread.

Main function description

1. Creation and exit of threads

Pthread_create thread creation function

Int pthread_create (pthread_t * thread_id,__const pthread_attr_t * _ _ attr,void * (* _ _ start_routine) (void *), void * _ restrict _ _ arg)

The first parameter of the thread creation function is the pointer to the thread identifier, the second parameter is used to set the thread properties, the third parameter is the starting address of the thread running function, and the last parameter is the parameter of the running function. Here, our function thread takes no arguments, so the last parameter is set to a null pointer. We also set the second parameter to a null pointer, which will generate the thread of the default property. When the thread is created successfully, the function returns 0. If it is not 0, the thread creation failed. The common error return codes are EAGAIN and EINVAL. The former indicates that the system restricts the creation of new threads, such as too many threads; the latter indicates that the value of the thread property represented by the second parameter is illegal. After the thread is created successfully, the newly created thread runs the function determined by parameters 3 and 4, and the original thread continues to run the next line of code.

The pthread_join function to wait for the end of a thread.

Function prototype is: int pthread_join (pthread_t _ _ th, void * * _ thread_return)

The first parameter is the identifier of the waiting thread, and the second parameter is a user-defined pointer that can be used to store the return value of the waiting thread. This function is a thread blocking function, and the function that calls it will wait until the end of the waiting thread, and when the function returns, the resources of the waiting thread will be reclaimed. The thread can only be terminated by one thread and should be in the joinable state (not detached).

Pthread_exit function

There are two ways to end a thread. One is that when the function that the thread runs ends, so does the thread that calls it.

Another way is through the function pthread_exit. Its function prototype is: void pthread_exit (void * _ retval) the only argument is the function return code, as long as the second parameter thread_return in pthread_join is not NULL, this value will be passed to thread_return. Finally, a thread cannot be waited by multiple threads, otherwise the first thread that receives the signal returns successfully, and the rest of the threads that call pthread_join return the error code ESRCH.

2. Thread properties

The property of the thread, the second parameter of the pthread_create function. Set this value to NULL, that is, using the default property, and multiple properties of the thread can be changed. These attributes mainly include binding attributes, detaching attributes, stack address, stack size, and priority. The default properties of the system are unbound, non-detached, default 1m stack, and priority at the same level as the parent process. First of all, we will explain the basic concepts of binding and separation properties.

Binding properties: Linux uses a "one-to-one" threading mechanism, that is, one user thread corresponds to one kernel thread. Binding attribute means that a user thread is permanently assigned to a kernel thread, because the scheduling of CPU time slices is oriented to kernel threads (that is, lightweight processes), so threads with binding attributes can ensure that there is always a kernel thread corresponding to it when needed. In contrast, the unbound attribute means that the relationship between the user thread and the kernel thread is not always fixed, but is controlled by the system.

Detach attributes: detach attributes are used to determine how a thread terminates itself. In the case of non-separation, when a thread ends, the system resources it occupies are not released, that is, there is no real termination. Only when the pthread_join () function returns can the created thread release the system resources it occupies. In the case of separating attributes, a thread releases the system resources it occupies immediately when it ends.

One thing to note here is that if you set the detach property of a thread, and the thread runs very fast, it is likely to terminate before the pthread_create function returns, and after it terminates, it may hand over the thread number and system resources to other threads, and the thread calling pthread_create gets the wrong thread number.

Set the binding properties:

Int pthread_attr_init (pthread_attr_t * attr)

Int pthread_attr_setscope (pthread_attr_t * attr, int scope)

Int pthread_attr_getscope (pthread_attr_t * tattr, int * scope)

Scope:PTHREAD_SCOPE_SYSTEM: binding, this thread competes with all threads in the system PTHREAD_SCOPE_PROCESS: unbound, this thread competes with other threads in the process

Set the detach properties:

Int pthread_attr_setdetachstate (pthread_attr_t * attr, int detachstate)

Int pthread_attr_getdetachstate (const pthread_attr_t * tattr,int * detachstate)

Detachstate PTHREAD_CREATE_DETACHED: separate PTHREAD_CREATE_ JOINABLE: non-detach

Set the scheduling policy:

Int pthread_attr_setschedpolicy (pthread_attr_t * tattr, int policy)

Int pthread_attr_getschedpolicy (pthread_attr_t * tattr, int * policy)

Policy SCHED_FIFO: first-in, first-out SCHED_RR: circular SCHED_OTHER: implementation of the defined method

Set the priority:

Int pthread_attr_setschedparam (pthread_attr_t * attr, struct sched_param * param)

Int pthread_attr_getschedparam (pthread_attr_t * attr, struct sched_param * param)

3. Thread access control

1) Mutex (mutex)

The synchronization between threads is realized through the lock mechanism. Only one thread is allowed to execute a critical part of the code at a time.

1 int pthread_mutex_init (pthread_mutex_t * mutex,const pthread_mutex_attr_t * mutexattr)

2 int pthread_mutex_lock (pthread_mutex_t * mutex)

3 int pthread_mutex_unlock (pthread_mutex_t * mutex)

4 int pthread_mutex_destroy (pthread_mutex_t * mutex)

(1) initialize lock init () or static assignment pthread_mutex_t mutex=PTHREAD_MUTEX_INITIALIER first

(2) Lock is added. Lock,trylock,lock blocks and waits for lock. Trylock returns EBUSY immediately.

(3) when unlocked, the unlock needs to be in the locked state and unlocked by the locking thread

(4) clear the lock, destroy (lock must be unlock at this time, otherwise EBUSY is returned)

Mutex is divided into recursive (recursive) and non-recursive (non-recursive), this is the name of POSIX, another name is Reentrant and non-reentrant. There is no difference between the two mutex as synchronization tools for inter-thread. The only difference is that the same thread can lock the recursive mutex repeatedly, but not the non-recursive mutex.

The preferred non-recursive mutex is definitely not for performance, but for design intent. There is not much difference in performance between non-recursive and recursive, because the former is only slightly faster with one less counter. Locking non-recursive mutex multiple times in the same thread immediately leads to deadlocks, which I think is an advantage that can help us think about code's expectations for locks and find problems early (in the coding phase). There is no doubt that recursive mutex is easier to use because you don't have to worry about a thread locking itself, which I guess is why Java and Windows provide recursive mutex by default. (the intrinsic lock that comes with the Java language is reentrant, and so is the CRITICAL_SECTION that provides ReentrantLock,Windows in its concurrent library. None of them seem to provide lightweight non-recursive mutex. )

2) conditional variable (cond)

A mechanism for synchronization using global variables shared between threads.

1 int pthread_cond_init (pthread_cond_t * cond,pthread_condattr_t * cond_attr)

2 int pthread_cond_wait (pthread_cond_t * cond,pthread_mutex_t * mutex)

3 int pthread_cond_timedwait (pthread_cond_t * cond,pthread_mutex_t * mutex,const timespec * abstime)

4 int pthread_cond_destroy (pthread_cond_t * cond)

5 int pthread_cond_signal (pthread_cond_t * cond)

6 int pthread_cond_broadcast (pthread_cond_t * cond); / / unblock all threads

(1) initialization. Init () or pthread_cond_t cond=PTHREAD_COND_INITIALIER; property is set to NULL

(2) waiting for the conditions to be established. Pthread_cond_wait,pthread_cond_timedwait.

Wait () releases the lock and blocks waiting for the condition variable to be true

Timedwait () sets the wait time, but still does not signal, and returns ETIMEOUT (lock guarantees that there is only one thread wait)

(3) Activation condition variable: pthread_cond_signal,pthread_cond_broadcast (activate all waiting threads)

(4) clear the condition variable: destroy; wireless wait, otherwise return EBUSY

The code is as follows:

Int pthread_cond_wait (pthread_cond_t * cond, pthread_mutex_t * mutex)

Int pthread_cond_timedwait (pthread_cond_t * cond, pthread_mutex_t * mutex, const struct timespec * abstime)

These two functions must be used within the locked area of the mutex.

When you call pthread_cond_signal () to release a thread that is blocked by a condition, calling pthread_cond_signal () does not work if no thread is blocking based on the condition variable. For Windows, when calling SetEvent triggers the Event condition of Auto-reset, if there is no thread blocked by the condition, then the function still works and the condition variable is in the triggered state.

Producer-consumer issues under Linux (using mutexes and condition variables):

The code is as follows:

# include

# include

# include

# include "pthread.h"

# define BUFFER_SIZE 16

Struct prodcons

{

Int buffer[BUFFER _ SIZE]

Pthread_mutex_t lock; / / mutex ensuring exclusive access to buffer

Int readpos,writepos; / / position for reading and writing

Pthread_cond_t notempty; / / signal when buffer is notempty

Pthread_cond_t notfull; / / signal when buffer is notfull

}

/ / initialize a buffer

Void init (struct prodcons* b)

{

Pthread_mutex_init (& b-> lock,NULL)

Pthread_cond_init (& b-> notempty,NULL)

Pthread_cond_init (& b-> notfull,NULL)

B-> readpos = 0

B-> writepos = 0

}

/ / store an integer in the buffer

Void put (struct prodcons* b, int data)

{

Pthread_mutex_lock (& b-> lock)

/ / wait until buffer is not full

While ((b-> writepos+1)% BUFFER_SIZE = = b-> readpos)

{

Printf ("wait for not full\ n")

Pthread_cond_wait (& b-> notfull,&b- > lock)

}

B-> buffer [b-> writepos] = data

B-> writepos++

B-> writepos% = BUFFER_SIZE

Pthread_cond_signal (& b-> notempty); / / signal buffer is notempty

Pthread_mutex_unlock (& b-> lock)

}

/ / read and remove an integer from the buffer

Int get (struct prodcons* b)

{

Int data

Pthread_mutex_lock (& b-> lock)

/ / wait until buffer is not empty

While (b-> writepos = = b-> readpos)

{

Printf ("wait for not empty\ n")

Pthread_cond_wait (& b-> notempty,&b- > lock)

}

Data=b- > buffer [b-> readpos]

B-> readpos++

B-> readpos% = BUFFER_SIZE

Pthread_cond_signal (& b-> notfull); / / signal buffer is notfull

Pthread_mutex_unlock (& b-> lock)

Return data

}

# define OVER-1

Struct prodcons buffer

Void * producer (void * data)

{

Int n

For (nasty 0; noccupied, 0,0)

Sem_init (& b-> empty,0, BSIZE)

Sem_init (& b-> pmut, 0,1)

Sem_init (& b-> cmut, 0,1)

B-> nextin = b-> nextout = 0

}

Void producer (buffer_t * b, char item)

{

Sem_wait (& b-> empty)

Sem_wait (& b-> pmut)

B-> BUF [b-> nextin] = item

B-> nextin++

B-> nextin% = BSIZE

Sem_post (& b-> pmut)

Sem_post (& b-> occupied)

}

Char consumer (buffer_t * b)

{

Char item

Sem_wait (& b-> occupied)

Sem_wait (& b-> cmut)

Item = b-> BUF [b-> nextout]

B-> nextout++

B-> nextout% = BSIZE

Sem_post (& b-> cmut)

Sem_post (& b-> empty)

Return item

}

This is the end of "what is linux multithreaded programming". Thank you for reading. If you want to know more about the industry, you can follow the website, the editor will output more high-quality practical articles for you!

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.