bloqueo mutex
Si el valor del semáforo es como máximo
1
, en realidad equivale a que un recurso compartido tenga como máximo una línea en cualquier momento.
proceso al que se accede, esta lógica se denomina "exclusión mutua". En este momento, existe una herramienta más conveniente y semánticamente precisa para satisfacer
Según esta lógica, es un bloqueo mutex.
"Cerrar" es una forma muy vívida de decirlo: así como una habitación sólo puede acomodar a una persona, cualquiera que entre la cerrará.
La puerta queda cerrada con llave y nadie más puede entrar hasta que la persona que entra vuelve a abrir la cerradura, lo que libera el recurso de cerradura.
fin.
Las operaciones sobre bloqueos mutex no son más que: inicialización, bloqueo, desbloqueo y destrucción. El siguiente código muestra dos hilos por
Cómo utilizar un bloqueo mutex para proporcionar acceso mutuamente excluyente a la salida estándar.
#include<stdio.h>
#include <semaphore.h>
#include <pthread.h>
#include <stdlib.h>
#include <unistd.h>
char *mem_map=NULL;
pthread_mutex_t lock;
void *function(void *arg)
{
char *msg=(char *)arg;
printf("线程号：%ld 收到参数：%s\n",pthread_self(),msg);
while (1)
{
printf("\nfunction等待锁 \n");
pthread_mutex_lock(&lock);
printf("function获取资源 已上锁\n ");
printf("msg:%s\n",mem_map);
sleep(1);
pthread_mutex_unlock(&lock);
}
}
int main(int argc, char const *argv[])
{
pthread_mutex_init(&lock,NULL);
mem_map=calloc(1,32);
pthread_t thread;
pthread_create(&thread, NULL,function, "Hello Gz123");
while (1)
{
printf("main 等待资源....\n ");
pthread_mutex_lock(&lock);
printf("main获取资源 以上锁 \n");
printf("main获取成功发送数据：");
fgets(mem_map,32,stdin);
sleep(1);
printf("main 释放资源\n");
pthread_mutex_unlock(&lock);
}
pthread_join(thread,NULL);
return 0;
}
bloqueo de lectura-escritura
La ineficiencia de los bloqueos mutex es que no existe una distinción más detallada entre cómo acceder a los recursos compartidos y el acceso único está disponible en cualquier momento.
Solo se permite que un subproceso acceda a recursos compartidos, pero el hecho es que las operaciones de lectura se pueden realizar al mismo tiempo y solo las operaciones de escritura se requieren entre sí.
Exclusión, por lo que si puede agregar bloqueos de lectura (se pueden agregar repetidamente) o bloqueos de escritura (solo
Permitir uno a la vez) puede mejorar en gran medida la eficiencia (especialmente cuando hay una gran cantidad de operaciones de lectura).
El funcionamiento del bloqueo de lectura y escritura es casi el mismo que el del bloqueo mutex, la única diferencia es que puede elegir agregar lectura o escritura al bloquear.
Lock, el siguiente código muestra cómo usarlo:
#include<stdio.h>
#include <semaphore.h>
#include <pthread.h>
#include <stdlib.h>
#include <unistd.h>
//定义线程间共享资源
//定义一个指针作用与线程之间的共享内存
char *mem_map=NULL;
pthread_rwlock_t rwlock;
void *function(void *arg)
{
char *msg=(char *)arg;
while (1)
{
pthread_rwlock_rdlock(&rwlock);
printf("线程%s号：%s \n",msg,mem_map);
pthread_rwlock_unlock(&rwlock);
sleep(2);
}
}
int main(int argc, char const *argv[])
{
pthread_rwlock_init(&rwlock,NULL);
mem_map=calloc(1,32);
pthread_t thread1;
pthread_t thread2;
pthread_t thread3;
pthread_t thread4;
pthread_create(&thread1, NULL,function, "1");
pthread_create(&thread2, NULL,function, "2");
pthread_create(&thread3, NULL,function, "3");
pthread_create(&thread4, NULL,function, "4");
while (1)
{
printf("main 等待上写锁....\n ");
pthread_rwlock_wrlock(&rwlock);
printf("main获取资源成功上写锁 \n");
fgets(mem_map,128,stdin);
pthread_rwlock_unlock(&rwlock);
printf("解除写锁....\n");
sleep(5);
}
pthread_join(thread1,NULL);
pthread_join(thread2,NULL);
pthread_join(thread3,NULL);
pthread_join(thread4,NULL);
return 0;
}