1.Multiproceso
Los subprocesos tienen un conjunto completo de llamadas a bibliotecas de funciones relacionadas con ellos, y la mayoría de los nombres de sus funciones comienzan con pthread_ . Para utilizar estas llamadas a la biblioteca, debemos definir la macro _REENTRANT , incluir el archivo de encabezado pthread.h en el programa y vincular la biblioteca de subprocesos con la opción -lpthread al compilar el programa.
-L especifica la ubicación de almacenamiento de la biblioteca.
-l especifica el nombre de la biblioteca
Paralelo: operación concurrente especial, operación sincrónica, que requiere múltiples procesadores
Concurrencia: ejecución alterna durante un período de tiempo, un solo procesador puede
Nota: Tener varios procesadores no es necesariamente paralelo o simultáneo.
2. Sincronización de hilos
Todos los subprocesos de un proceso comparten el mismo espacio de direcciones y otros recursos, como archivos abiertos. Cualquier modificación de un recurso por parte de un subproceso afectará el entorno de otros subprocesos en el mismo proceso. Por lo tanto, las actividades de varios subprocesos deben sincronizarse para que no interfieran entre sí y no destruyan las estructuras de datos. Por ejemplo, si dos subprocesos intentan agregar un elemento a una lista doblemente enlazada al mismo tiempo, es posible que se pierda un elemento o que se destruya la estructura de la lista enlazada.
La sincronización de subprocesos significa que cuando un subproceso está operando en un determinado recurso crítico, ningún otro subproceso puede operar en este recurso. Hasta que el subproceso complete la operación, otros subprocesos pueden operar, es decir, a un ritmo coordinado, lo que permite que los subprocesos operen en un ritmo predeterminado. orden Ejecutar en secuencia. Hay cuatro métodos de sincronización de subprocesos: bloqueos mutex, semáforos, variables de condición y bloqueos de lectura y escritura.
2.1 Bloqueo mutex
int pthread_mutex_init(pthread_mutex_t *mutex,pthread_mutexattr_t
*attr);//attr:锁的属性,不需要传空即可
int pthread_mutex_lock(pthread_mutex_t *mutex);//加锁
int pthread_mutex_unlock(pthread_mutex_t *mutex);//解锁
int pthread_mutex_destroy(pthread_mutex_t *mutex);//销毁锁
//注意,互斥锁mutex都需要传地址,因为要改变它;2.2 Cantidad de señal
int sem_init(sem_t *sem, int pshared, unsigned int value);
//信号量的初始化
//sem_init（）在sem指向的地址初始化未命名的信号量。这个value参数指定信号量的
初始值(第三个参数)。
//pshared:设置信号量是否在进程间共享,Linux不支持,一般给0; (非0为共享)
int sem_wait(sem_t *sem);
//P操作,wait表示等待,相当于是等待获取资源,那么就是P操作
int sem_post(sem_t *sem);
//V操作
int sem_destroy(sem_t *sem);
//销毁信号2.3 Variables de condición
#include <pthread.h>
int pthread_cond_init(pthread_cond_t *cond, pthread_condattr_t
*attr);
int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t
*mutex);
//将条件变量添加到等待队列中,阻塞,等待被唤醒;第一个参数是条件变量的地址,第二个参
数是互斥锁;
//也就是说条件变量往往伴随着互斥锁的使用;
int pthread_cond_signal(pthread_cond_t *cond); //唤醒单个线程
int pthread_cond_broadcast(pthread_cond_t *cond); //唤醒所有等待的
线程
int pthread_cond_destroy(pthread_cond_t *cond);//销毁条件变量2.4 Bloqueo de lectura-escritura
Lectores y lectores comparten recursos, lectores y escritores son mutuamente excluyentes; escritores y escritores son mutuamente excluyentes, y escritores y lectores son mutuamente excluyentes.
#include <pthread.h>
int pthread_rwlock_init(pthread_rwlock_t
*rwlock,pthread_rwlockattr_t *attr);
//第一个参数是锁的地址,第二个参数是锁的属性
int pthread_rwlock_rdlock(pthread_rwlock_t *rwlock);//加读锁
int pthread_rwlock_wrlock(pthread_rwlock_t *rwlock);//加写锁
int pthread_rwlock_unlock(pthread_rwlock_t *rwlock);//解锁,不管加的
是读锁还是写锁,都用unlock解锁
int pthread_rwlock_destroy(pthread_rwlock_t *rwlock);//销毁3. Seguridad del hilo (punto clave)
La seguridad de los subprocesos significa que cuando se ejecutan varios subprocesos, independientemente del orden de programación de los subprocesos, el resultado final es el mismo y correcto. Entonces se dice que estos hilos son seguros.
Para garantizar la seguridad del hilo es necesario:
1) La sincronización de subprocesos garantiza que solo un subproceso acceda a recursos críticos al mismo tiempo.
2) Utilice funciones seguras para subprocesos (funciones reentrantes) en subprocesos múltiples. Las llamadas funciones seguras para subprocesos se refieren a: si una función puede ser llamada por varios subprocesos al mismo tiempo sin una condición de carrera, entonces la llamamos hilo seguro.
En términos generales: la versión de una función con _r es la versión reentrante de la función.
Función reentrante: Reentrada significa entrada repetida. En primer lugar, significa que esta función se puede interrumpir. En segundo lugar, significa que no depende de ningún entorno (incluido el estático), excepto el uso de variables en su propia pila. Dicha función es código puro. (Código puro) es reentrante, lo que permite que se ejecuten múltiples copias de la función sin interferir entre sí porque usan pilas separadas. Si realmente necesita acceder a variables globales (incluidas las estáticas), asegúrese de implementar la exclusión mutua. Las funciones reentrantes son muy importantes en un entorno de ejecución paralela, pero generalmente existe cierta penalización en el rendimiento al acceder a variables globales.
Nota: En subprocesos múltiples, tenga cuidado cuando los subprocesos utilicen variables globales (estáticas), porque todos los subprocesos compartirán estas variables y es mejor que los subprocesos utilicen sus propias variables locales.
Los subprocesos también tienen ID (Linux tiene una forma única de implementar subprocesos. El kernel no tiene el concepto de subprocesos múltiples y trata los subprocesos como procesos. El PID del subproceso principal es el PID del proceso y los otros subprocesos PID+1)
Método de visualización: ps -eLf