Utilice el lenguaje C para implementar un método de sincronización multiproceso para demostrar el problema "productor-consumidor" en Linux
El conocimiento requerido para este problema incluye principalmente:
1 Comunicación entre múltiples procesos
2 Uso de semáforo de sincronización (semáforo) y semáforo de exclusión mutua (mutex); para la protección de datos.
El código de referencia es el siguiente, puede consultar los comentarios para ayudar a comprenderlo: #include?lt; stdio.hgt;
#include?lt; /p>
# include?lt;unistd.hgt;
#include?lt;pthread.hgt;
#include?lt;semaphore.hgt;
#define?N?2//?El número de consumidores o productores
#define?M?10?//?El número de buffers
int?in ?=?0; ///?El lugar donde el productor coloca el producto
int?out?=?0;?//?El lugar donde el consumidor toma el producto
int?buff[M]?=?{0} ;?//?El búfer se inicializa a 0,?No hay ningún producto al principio
sem_t?empty_sem;?//?Sincronizar el semáforo ,?Cuando está lleno, impide que el productor coloque productos
sem_t?full_sem; // Semáforo sincrónico,? mutex;? //? Semáforo Mutex,? Solo un hilo puede acceder al búfer a la vez
pthread_mutex_t?mutex; p>
int?product_id?=?0;//id del productor
int?procase_id?=?0;?//id del consumidor
/*?print Situación de almacenamiento en búfer?*/
void?print()
{
int?i;
for(i?=?0 ;?i?lt;?M;?i )
printf( "d?",?buff[i]);
printf("\n");
p>
}
/*? ¿Método de productor?*/?
void?*product()
{
int?id?=? product_id;
while (1)
{
///?La cantidad de sueño se puede utilizar para ajustar la velocidad de producción y consumo. Fácil de observar
sueño (1).
//sleep(1);
?
sem_wait(y vacío_sem);
pthread_mutex_lock(y mutex); );
?
in?=?in??M
printf("producto? in?d.?like:?\t", ?id,?in);
?
buff[in]?=?1;?
print();?
en;
?
pthread_mutex_unlock(amp;mutex);
sem_post(amp;full_sem) ;?
}
}
/*?Método del consumidor?*/
void?*prochase()
{
int ?id?=? prochase_id;
while(1)
{
//Use La cantidad de sueño puede ajustar la velocidad de producción y consumo de observación fácil
dormir(1);
//dormir(1
?
sem_wait(amp;
full_sem);
pthread_mutex_lock(amp;mutex);
?
salida?=?salida??M;
printf( "comprado?en?d.?like:?\t",?id,?out);
?
buff[out]?=?0;
print();
salida
?
pthread_mutex_unlock(amp; mutex);
sem_post(amp; vacío_sem); );
}
}
int?main()
{
pthread_t?id1[N ];
pthread_t?id2[N];
int?i
int?ret[N]; ?Inicializar el semáforo de sincronización
int?ini1?=?sem_init(amp;empty_sem,?0,?M);?
int?ini2?=?sem_init(amp;full_sem ,?0,?0);?
if(ini1?amp;amp;?ini2?=?0)
{
printf(" sem ?init?failed?\n");
exit(1);
}?
//¿Inicializar el semáforo mutex?
int?ini3?=?pthread_mutex_init(amp;mutex,?NULL);
if(ini3?!=?0)
{
printf ("mutex?init?failed?\n");
exit(1);
}?
//Crear N producciones o hilo
for(i?=?0;?i?lt;?N;?i)
{
ret[i]?=? ;id1[i],?NULL,?producto,?(void?*)(amp;i));
if(ret[i]?!=?0)
{
printf("productd?creación?fallida?\n",?i
exit(1);
}
//Crear N hilos de consumo
for(i?=?0;?i?lt;?N;?i)
{
ret[i]?=?pthread_create(amp;id2[i],?NULL,?procase,?NULL);
if(ret[ i]?=? 0)
{
printf("¿prochada?creación?fallida?\n",?i);
salir(1 );
}
}
//Destruye el hilo
for(i?=?0;?i?lt;? N;?i )
{
pthread_join(id1[i], NULL);
pthread_join(id2[i]
], NULL);
}
exit(0);?
}
Al compilar en Linux, debe Agregar la opción -lpthread para compilar el comando para incluir soporte de subprocesos múltiples. Por ejemplo, el archivo C almacenado es demo.c y el archivo ejecutable que se generará es demo. Puede utilizar el comando:
gcc demo.c -o demo -lpthread
Para facilitar la observación, se utiliza sleep(1) en el programa para pausar la operación; para que pueda ver el resultado. Vea, el resultado se imprime cada segundo.