Calling the pthread _ exit () function is used only to join threads because it
does not release the flow resources - this is the responsibility of the
threaded joiner.
Waiting For Completion Of Threads
To await completion of threads, use the pthread _ join () function. It has the
following syntax:
int pthread_join (pthread_t the ,, void ** status);
This function blocks the thread where it was called until the thread
specified by the handle deserves its execution.
If the status is not a null
pointer, it will point to the data returned by the stream after the call
(argument pthread _ exit ()). If the thread is already complete by the time
the pthread _ join () function is called, its information should be read
immediately.
Conclusions
❖
Processes and threads are the active resources of computer systems
that implement code execution. The
thread is called a set of
sequentially executed processor commands. A process is a collection
of one or more threads and the protected address space in which they
are executed. Streams in the same address space can share data
together, and for streams of different processes without special means,
this is not possible. In traditional systems, each process can execute
only one thread code execution of processes.
Modern operating
systems support the concept of multithreading.
❖
Using threads in an application means paralleling it - the ability to
perform actions simultaneously with different snippets of
code. Program parallelism reflects the asynchronous nature of the
outside world, its sources being code execution on multiple
processors, I /
O operations, user interaction, and client application
requests. Bahatopotokovist allows applications to implement this
course and achieve parallelism and efficiency.
❖
There are user threads running in the slugger mode in the process
address space, and the kernel threads
with which the OS kernel
works. The relationship between them determines the scheme of
implementation of the flow model. In practice, they often use the 1: 1
scheme, when each thread of the user corresponds to one thread of the
kernel, and the kernel itself is responsible for managing the threads of
the user.
❖
The flow can be in different states (execution, expectations,
readiness, etc.). The principles of moving from one state to another
depending on the principles of flow
planning and processor time
planning. Moving the process from execution state to any other state
is about switching the context - transferring control from one thread to
another while preserving the state of the processor.
❖
Each process and flow in the system corresponds to its control unit
- a data structure containing all the necessary information. During the
creation process (usually by the system call fork ()) create one control
unit, allocate memory and launch the mainstream. Creating flow is
faster and easier because they do not need to allocate memory to the
new address.
