Lab06 SO

UNIVERSIDAD NACIONAL DE SAN AGUSTIN
FACULTAD DE INGENIERÍA DE PRODUCCIÓN Y SERVICIOS

ESCUELA PROFESIONAL DE INGENIERÍA DE SISTEMA
Formato: Guía de Práctica de Laboratorio / Talleres / Centros de Simulación

Aprobación: 2022/03/01 Código: GUIA-PRLE-001 Página: 1
INFORME DE LABORATORIO
INFORMACIÓN BÁSICA
ASIGNATURA: Laboratorio de Sistemas Operativos - C
TÍTULO DE LA
Threads en C - PTHREADS
PRÁCTICA:
NÚMERO DE NRO.
06 AÑO LECTIVO: 2023 VI
PRÁCTICA: SEMESTRE:
FECHA DE HORA DE
18/10/2023
PRESENTACIÓN PRESENTACION
ALUMNO:
Llaique Chullunquia Angie Carolina NOTA:
DOCENTE(s):
Apaza Aceituno Roni Guillermo
SOLUCIÓN Y RESULTADOS
I. EJERCICIOS RESUELTOS POR EL DOCENTE
Ejercicio 1.
Crear un simple thread usando la librería pthread:
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h> //cabecera para usar sleep().
#include <pthread.h>
// Una función normal de c que es ejecutadad en un thread
// cuando es nombrada, es especificada como pthread_create()
void *myThreadFun(void *vargp)
{
sleep(1);
printf("Imprimiendo ejemplo Thread \n");
return NULL;
}
int main()
{
pthread_t thread_id;
printf("Antes del Thread\n");
pthread_create(&thread_id, NULL, myThreadFun, NULL);

pthread_join(thread_id, NULL);
printf("Despues del Thread\n");
exit(0);
}
Para compilar este programa utilizamos el siguiente comando en línea de comandos
$ gcc -w ejercicio01.c -lpthread -o ejercicio01
Ejercicio 2.
Escribir el siguiente thread, después compílelo y ejecutelo:
// Importando la librería Pthread
// Importando la librería para usar printf
#include <stdio.h>
// Esta función tomo en un puntero
void * ThreadFunction(void *arguments)
{
printf("Thread Running\n");
return NULL;
}
int main() {

// Creando la locación donde el ID del thread recientemente creado recientemente

// el thread será alojado
pthread_t thread1;
printf("Llamando al thread \n");
// Creando el thread
pthread_create(&thread1, NULL, ThreadFunction, NULL);
return 0;
}
$ gcc -w ejercicio02.c -lpthread -o ejercicio02
Ejercicio 3.
Crear el siguiente programa en c, que hace referencia a un programa que escribe, llamelo writer.c, compílelo
#include <stdio.h>
#include <stdlib.h>
void *print_message_function( void *ptr );
main()
{
pthread_t thread1, thread2;
char *message1 = "Thread 1";

char *message2 = "Thread 2";

int iret1, iret2;
/* Creamos threads independientes cada uno con su fusión excecute */
iret1 = pthread_create( &thread1, NULL, print_message_function, (void*) message1);
iret2 = pthread_create( &thread2, NULL, print_message_function, (void*) message2);
/* Esperamos hasta que los threads son completados antes de que la función main continue, a menos de
que nosotros */
/* esperemos correremos el riesgo de ejecutar son un exit el cual terminará */
/* el proceso y todos los threads antes de que los threads sean completados. */
pthread_join( thread1, NULL);
pthread_join( thread2, NULL);
printf("Thread 1 returns: %d\n",iret1);
printf("Thread 2 returns: %d\n",iret2);
exit(0);
}
void *print_message_function( void *ptr )
{
char *message;
message = (char *) ptr;
printf("%s \n", message);
}
$ gcc ejercicio03.c -lpthread -o ejercicio03

Ejercicio 4.
Crear el siguiente programa en c, que creará tres hilos usando un bucle for, compílelo
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
// Permite crear una variable global para cambiarlo in los threads
int g = 0;
// La función será ejecutada por todos los threads
void *myThreadFun(void *vargp)
{
// Aloja el valor del argumento pasado por el thread
int *myid = (int *)vargp;
// Permite crear una variable estatic para observar los cambios
static int s = 0;
// Cambia la variable global y estatica
++s; ++g;
// Imprime los argumentos de las variables global y estaticas
printf("Thread ID: %d, Static: %d, Global: %d\n", *myid, ++s, ++g);
}
int main()
{
int i;
pthread_t tid;
// Nos permtie crear tres threads
for (i = 0; i < 3; i++)
pthread_create(&tid, NULL, myThreadFun, (void *)&tid);
pthread_exit(NULL);
return 0;
}

Ejercicio 5.
Crear el siguiente programa en c, compílelo con el nombre ejercicio05.c
# include < stdio.h >
# include < stdlib.h >
# include < string.h >
# include < unistd.h >
# include < pthread.h >
void * slowprintf ( void * arg ) {
char * msg ;
int i;
msg = ( char *) arg ;

for ( i = 0 ; i < strlen ( msg ) ; i ++ ) {

printf (" %c" , msg [ i ]) ;
fflush ( stdout ) ;
usleep (1000000) ;
}
}
int main ( int argc , char * argv []) {
pthread_t h1 ;
pthread_t h2 ;
char * hola = " Hola ";
char * mundo = " mundo ";
pthread_create (& h1 , NULL , slowprintf , ( void *) hola ) ;
pthread_create (& h2 , NULL , slowprintf , ( void *) mundo );
pthread_join ( h1 , NULL ) ;
printf ( " Fin \n ");
}

Ejercicio 6.
Crear el siguiente programa en c, que hace el paso de parámetros usando una estructura, llamelo ejercicio06.c,
compílelo
# include < stdio .h >
# include < stdlib .h >
# include < string .h >
# include < unistd .h >
# include < pthread .h >
struct parametros {
int id ;
float escalar ;
float matriz [3][3];
};
void init ( float m [3][3]) {
int i;
int j;
for ( i = 0 ; i < 3 ; i ++ ) {
for ( j = 0 ; j < 3 ; j ++ ) {
m[i ][ j ] = random () *100;
}
}
}
void * matrizporescalar ( void * arg ) {
struct parametros * p;
int i;
int j
p = ( struct parametros *) arg ;
for ( i = 0 ; i < 3 ; i ++ ) {
printf (" Hilo %d multiplicando fila %d \n" , p -> id , i );
for ( j = 0 ; j < 3 ; j ++ ) {
p -> matriz [ i ][ j] = p -> matriz [ i ][ j] * p -> escalar ;
usleep (100000) ;
}
}
}
int main ( int argc , char * argv []) {
pthread_t h1 ;
pthread_t h2 ;
struct parametros p1 ;
struct parametros p2 ;
p1 . id = 1;
p1 . escalar = 5.0;
init ( p1 . matriz );
p2 . id = 2;

p2 . escalar = 10.0;
init ( p2 . matriz );
pthread_create (& h1 , NULL , matrizporescalar , ( void *) & p1);
pthread_create (& h2 , NULL , matrizporescalar , ( void *) & p2);
printf ( " Fin \n ");
}

Ejercicio 7
Crear el siguiente programa en c, que cancela la ejecución de un thread usando la función cancel(), llamelo
ejercicio07.c, compílelo
// Un programa en C para demostrar la cancelación de un thread propio
// usando el id del thread
#include <stdio.h>
#include <stdlib.h>
void* calls(void* ptr)
{
printf("Cancelado");
// Para salir del actual thread
// pthread_self() devuelve el valor del id del thread
pthread_cancel(pthread_self());
return NULL;
}
int main()
{
// NULL cuando no hay atributo
pthread_t thread;
// Llamada a funciíon
pthread_create(&thread, NULL, calls, NULL);
// Esperando cuando el thread es completado
pthread_join(thread, NULL);
return 0;
}
Para compilar este programa utilizamos el siguiente comando en linea de comandos

Ejercicio 8.
Crear el siguiente programa en c, que cancela varios threads, llamelo ejercicio08.c, compílelo
// Programa en C para demostrar la cancelación de los threads
// usando el id del thread
#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
// To Count
int counter = 0;
// temporalmente el thread será
// almacenando el id del segundo thread
pthread_t tmp_thread;
// thread_uno llama a func
void* func(void* p)
{
while (1) {
printf("thread numero uno\n");
sleep(1); // duerme por 1 segundo
counter++;
// para salir si el contadore es 5
if (counter == 2) {

// para cancelar desde thread_dos

pthread_cancel(tmp_thread);
// Para finalizar desde el thread_uno
pthread_exit(NULL);
}
}
}
// thread_two llama a la función func2
void* func2(void* p)
{
//alojando el id del thread_two en tmp_thread
tmp_thread = pthread_self();
while (1) {
printf("thread numero dos ");
sleep(1); // dormir por 1 segundo
}
}
int main()
{
// declarando dos threads
pthread_t thread_one, thread_two;
// creando el thread 1
pthread_create(&thread_one, NULL, func, NULL);
// creando el trhread 2
pthread_create(&thread_two, NULL, func2, NULL);
// esperando cuando el thread 1 es completado
pthread_join(thread_one, NULL);
// esperando cuando el thread 2 es completado
pthread_join(thread_two, NULL);
}
$ gcc ejercicio08.c -pthread -o ejercicio08

Ejercicio 9
Crear el siguiente programa en c, que compara dos threads, llamelo ejercicio09.c, compílelo
// Programa en C para demostrar como trabaja pthread_equal()
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
void* func_one(void* ptr)


{
// en este camplo comparamos los threads
// pthread_self da un id del thread actual
if (pthread_equal(tmp_thread, pthread_self())) {
printf("son iguals\n");
} else {
printf("no son iguales\n");
}
}
// driver code
int main()
{
// thread uno
pthread_t thread_one;
// asignando el id al thread uno temporalmente

// mientras que el thread declara la variable global r
tmp_thread = thread_one;
// creando el thread
pthread_create(&thread_one, NULL, func_one, NULL);
// esperando por el thread

}
$ gcc ejercicio09.c -lpthread -o message_send

Ejercicio 10
Crear el siguiente programa en c, que compara dos threads, llamelo ejercicio10.c, compílelo
// Programa en C para demostrar como trabaja pthread_equal()
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
// la variable global pthread_t es declarada
void* func_one(void* ptr)
{
tmp_thread = pthread_self(); // assign the id of thread one in
// temporalmente el thread declara la variable global
}
void* func_two(void* ptr)
{

pthread_t thread_two = pthread_self();

// compara dos thread
if (pthread_equal(tmp_thread, thread_two)) {
printf("igual\n");
} else {
printf("no igual\n");
}
}
int main()
{
pthread_t thread_one, thread_two;
// creando el thread uno
pthread_create(&thread_one, NULL, func_one, NULL);
// creando el thread dos
pthread_create(&thread_two, NULL, func_two, NULL);
// esperando por el thread uno
// esperando por el thread dos
pthread_join(thread_two, NULL);
}

II. SOLUCIÓN DE EJERCICIOS PROPUESTOS
Ejercicio 1. Implemente la suma de los elementos de un arreglo usando threads
El programa divide el trabajo en múltiples threads, cada uno suma una porción del arreglo y
luego se acumulan los resultados en la variable suma_total. El resultado final se imprime
correctamente al final del programa.
#include <stdio.h>
#define NUM_THREADS 4
#define ARRAY_SIZE 100
int mi_arreglo[ARRAY_SIZE]; // Arreglo de entrada

int suma_total = 0; // Variable global para almacenar la suma

void *sumar_segmento(void *arg) {

int id_thread = *(int *)arg;
int inicio = id_thread * (ARRAY_SIZE / NUM_THREADS);
int fin = inicio + (ARRAY_SIZE / NUM_THREADS);
int suma_local = 0;
// Sumar los elementos del segmento asignado al thread

for (int i = inicio; i < fin; i++) {
suma_local += mi_arreglo[i];
}
// Agregar la suma local al total utilizando un mecanismo de exclusión mutua

(mutex)
suma_total += suma_local;
pthread_exit(NULL);
}
int main() {
pthread_t threads[NUM_THREADS];
int ids_threads[NUM_THREADS];
// Inicializar el arreglo
for (int i = 0; i < ARRAY_SIZE; i++) {
mi_arreglo[i] = i;
}
// Crear threads
for (int i = 0; i < NUM_THREADS; i++) {
ids_threads[i] = i;
pthread_create(&threads[i], NULL, sumar_segmento, &ids_threads[i]);
}
// Esperar a que todos los threads terminen
pthread_join(threads[i], NULL);
}
// Imprimir el resultado
printf("Suma total: %d\n", suma_total);
return 0;
}
Código

Ejecución

Ejercicio 2. Cree 100 hilos y compárelos con la creación de 100 procesos
Para crear hilos, se puede utilizar la biblioteca pthread.h, que proporciona funciones para la
creación y gestión de hilos. Por otro lado, para crear procesos, se puede utilizar la función
fork(), que crea un proceso hijo idéntico al proceso padre. Cada proceso tiene su propio
espacio de memoria y no comparte recursos con otros procesos, lo que puede ser útil para
evitar problemas de concurrencia. La elección entre hilos y procesos depende del problema
que se esté tratando y de los recursos disponibles. Si se necesita compartir información entre
los hilos, puede ser más conveniente utilizar hilos, mientras que si se necesita aislar los
procesos para evitar problemas de concurrencia, puede ser más conveniente utilizar procesos.
Observamos que los hilos comparten el mismo espacio de memoria y recursos, mientras que
los procesos tienen su propio espacio de memoria y recursos. La creación de hilos suele ser
más eficiente en términos de recursos que la creación de procesos debido a esta compartición
de recursos.
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/wait.h>
#define NUM_THREADS 100

#define NUM_PROCESSES 100
void *thread_function(void *arg) {

printf("Hilo creado-> %ld\n", (long)pthread_self());
pthread_exit(NULL);
}
int main() {
pthread_t hilos[NUM_THREADS];
pid_t procesos[NUM_PROCESSES];
// Crear 100 hilos

printf("Creando de 100 hilos:\n");
pthread_create(&hilos[i], NULL, thread_function, NULL);
}
// Esperar a que los hilos terminen

pthread_join(hilos[i], NULL);
}
// Crear 100 procesos

printf("Creando de 100 procesos:\n");

for (int i = 0; i < NUM_PROCESSES; i++) {

pid_t child_pid = fork();
if (child_pid == 0) {
printf("Proceso hijo creado-> %d\n", getpid());
exit(0);
}
}
// Esperar a que los procesos terminen

for (int i = 0; i < NUM_PROCESSES; i++) {
wait(NULL);
}
return 0;
}
Código

Ejecución

Es importante tener en cuenta que la creación de procesos implica más sobrecarga debido a la
duplicación del espacio de memoria del proceso padre, mientras que los hilos comparten la
misma memoria del proceso padre. La elección entre hilos y procesos depende de los
requisitos y limitaciones de tu aplicación.

Ejercicio 3. Demostrar que el thread creado en una función de un proceso es el mismo que
es usado en la función principal main
Esto se debe a que los threads se crean, ejecutan y mueren dentro de los procesos, y son
capaces de compartir información entre ellos. Además, un thread es la unidad más pequeña a
la cual un procesador puede asignar tiempo. Por lo tanto, el thread creado en una función de
un proceso es parte del mismo proceso que la función principal main y, por lo tanto, es el
mismo thread.
Se imprime el identificador de hilo (pthread_t) tanto en la función main como en la función
thread_function, y se demuestra que estos identificadores son los mismos.
El identificador de hilo se obtiene utilizando pthread_self(), y al imprimirlo en ambas partes

del código, muestras que se refiere al mismo hilo en ambas ubicaciones. La salida del
programa mostrará que el identificador de hilo en la función principal es igual al identificador
del hilo en la función thread_function, lo que demuestra que el hilo creado en la función es el
mismo que se utiliza en la función principal.
En el contexto de hilos en un programa, los hilos comparten el mismo espacio de memoria del
proceso que los creó. Por lo tanto, el contexto del hilo creado en una función de un proceso es
el mismo que el contexto del proceso principal, incluido el espacio de memoria. Esto significa
que las variables y datos creados en el proceso principal pueden ser accedidos y compartidos
por los hilos que se crean dentro de ese proceso.
#include <stdio.h>
#include <stdlib.h>
void *thread_function(void *arg) {

printf("Identificador del hilo creado: %ld\n", (long) pthread_self());
return NULL;
}
int main() {
pthread_t thread_id;
printf("Identificador del hilo principal: %ld\n", (long) pthread_self());
pthread_create(&thread_id, NULL, thread_function, NULL);
pthread_join(thread_id, NULL);
return 0;
}

Código
Ejecución

III. SOLUCIÓN DEL CUESTIONARIO
1. ¿Qué hace la función pthread_detach de la librería pthread?
La función pthread_detach() de la librería pthread se utiliza para marcar un hilo como desvinculado[3].
Cuando un hilo desvinculado termina, sus recursos se liberan automáticamente sin necesidad de que otro
hilo se una al hilo terminado[4].
Es importante tener en cuenta que si un hilo ya ha terminado antes de llamar a pthread_detach(), la

función no tendrá ningún efecto[5].
En otras palabras, la función marca el hilo como "desconectado" o "desvinculado" y permite que los
recursos asociados con el hilo se liberen automáticamente cuando el hilo termina, sin necesidad de que
otro hilo se una al hilo terminado.
La función pthread_detach se utiliza de la siguiente manera:

pthread_detach(pthread_t thread);
Donde thread es el identificador del hilo que se desea marcar como desprendido.
En resumen, la función pthread_detach se utiliza para marcar un hilo como "desconectado" y permitir que
los recursos asociados con el hilo se liberen automáticamente cuando el hilo termina. Es importante tener
en cuenta que una vez que un hilo ha sido desconectado, no se puede volver a unir con pthread_join o
hacerlo unible de nuevo. La función se utiliza comúnmente en conjunción con pthread_create para crear
hilos que se ejecutan de forma independiente y no necesitan ser unidos con otros hilos, o para liberar
recursos asociados con hilos que ya no son necesarios.
2. ¿ Qué hace la función pthread_kill de la librería pthread?
La función pthread_kill() de la librería pthread se utiliza para enviar una señal a un hilo específico[6]. La
señal se envía de forma asíncrona al hilo especificado. Si el argumento sig es 0, no se envía ninguna señal,
pero se realiza la verificación de errores[7].
Es importante tener en cuenta que pthread_kill() no termina el hilo receptor, sino que envía una señal a él.
El comportamiento del hilo receptor depende de la señal y los manejadores de señales[8].
Por ejemplo, si se envía la señal SIGTERM a un hilo, el hilo puede terminar o puede ser manejado por un
manejador de señales personalizado que realice una acción diferente
La función pthread_kill se utiliza de la siguiente manera:

int pthread_kill(pthread_t thread, int sig);
thread: Es el identificador del hilo al que deseas enviar la señal.

sig: Es el número de la señal que deseas enviar al hilo.

En resumen, la función pthread_kill se utiliza para enviar una señal a un hilo específico en el proceso que
llama. La señal enviada puede ser cualquier señal definida en signal.h, excepto la señal 0. Es importante
tener en cuenta que la señal enviada no necesariamente terminará el hilo, y dependerá de la señal y los
manejadores de señales lo que suceda después. La función se utiliza comúnmente en conjunción con
manejadores de señales personalizados para controlar el comportamiento de los hilos en respuesta a
señales específicas, o para enviar señales a hilos específicos para indicarles que realicen una acción
específica.
REFERENCIAS Y BIBLIOGRAFÍA
[1] Z. Stefano. 2015 Programmation Système Cours 9 POSIX Threads an introduction: online, Available:
https://upsilon.cc/~zack/teaching/1415/progsyst/cours-09-pthreads.pdf
[2] D.Fernando. 2017/03/13], Threads POSIX: online, Avalible: https://www.embarcados.com.br/threadsposix/
[3] POSIX Threads - Universidad Técnica Federico Santa María.
http://profesores.elo.utfsm.cl/~agv/elo330/2s08/lectures/POSIX_Threads.html.
[4] pthread_detach - detach a thread - pubs.opengroup.org.
https://pubs.opengroup.org/onlinepubs/9699919799/functions/pthread_detach.html.
[5] pthread_detach(3) - Linux manual page - man7.org.
https://man7.org/linux/man-pages/man3/pthread_detach.3.html.
[6] Ubuntu Manpage: pthread_kill - send a signal to a thread.
https://manpages.ubuntu.com/manpages/jammy/man3/pthread_kill.3.html.
[7] pthread_kill(3) — manpages-dev — Debian bullseye — Debian Manpages.
https://manpages.debian.org/bullseye/manpages-dev/pthread_kill.3.en.html.
[8] When to use pthread_cancel and not pthread_kill?.
https://stackoverflow.com/questions/3438536/when-to-use-pthread-cancel-and-not-pthread-kill.

Lab06 SO

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Lab06 SO

Cargado por

Copyright:

Formatos disponibles

UNIVERSIDAD NACIONAL DE SAN AGUSTIN

FACULTAD DE INGENIERÍA DE PRODUCCIÓN Y SERVICIOS

Formato: Guía de Práctica de Laboratorio / Talleres / Centros de Simulación

Formato: Guía de Práctica de Laboratorio / Talleres / Centros de Simulación

Formato: Guía de Práctica de Laboratorio / Talleres / Centros de Simulación

// Creando la locación donde el ID del thread recientemente creado recientemente

Formato: Guía de Práctica de Laboratorio / Talleres / Centros de Simulación

char *message2 = "Thread 2";

Formato: Guía de Práctica de Laboratorio / Talleres / Centros de Simulación

Formato: Guía de Práctica de Laboratorio / Talleres / Centros de Simulación

Formato: Guía de Práctica de Laboratorio / Talleres / Centros de Simulación

for ( i = 0 ; i < strlen ( msg ) ; i ++ ) {

Formato: Guía de Práctica de Laboratorio / Talleres / Centros de Simulación

Formato: Guía de Práctica de Laboratorio / Talleres / Centros de Simulación

Formato: Guía de Práctica de Laboratorio / Talleres / Centros de Simulación

Formato: Guía de Práctica de Laboratorio / Talleres / Centros de Simulación

Formato: Guía de Práctica de Laboratorio / Talleres / Centros de Simulación

// para cancelar desde thread_dos

Formato: Guía de Práctica de Laboratorio / Talleres / Centros de Simulación

void* func_one(void* ptr)

Formato: Guía de Práctica de Laboratorio / Talleres / Centros de Simulación

// asignando el id al thread uno temporalmente

// esperando por el thread

Formato: Guía de Práctica de Laboratorio / Talleres / Centros de Simulación

Formato: Guía de Práctica de Laboratorio / Talleres / Centros de Simulación

pthread_t thread_two = pthread_self();

Formato: Guía de Práctica de Laboratorio / Talleres / Centros de Simulación

II. SOLUCIÓN DE EJERCICIOS PROPUESTOS

Ejercicio 1. Implemente la suma de los elementos de un arreglo usando threads

int mi_arreglo[ARRAY_SIZE]; // Arreglo de entrada

Formato: Guía de Práctica de Laboratorio / Talleres / Centros de Simulación

void *sumar_segmento(void *arg) {

// Sumar los elementos del segmento asignado al thread

// Agregar la suma local al total utilizando un mecanismo de exclusión mutua

Formato: Guía de Práctica de Laboratorio / Talleres / Centros de Simulación

Formato: Guía de Práctica de Laboratorio / Talleres / Centros de Simulación

Ejercicio 2. Cree 100 hilos y compárelos con la creación de 100 procesos

#define NUM_THREADS 100

void *thread_function(void *arg) {

// Crear 100 hilos

// Esperar a que los hilos terminen

// Crear 100 procesos

Formato: Guía de Práctica de Laboratorio / Talleres / Centros de Simulación

for (int i = 0; i < NUM_PROCESSES; i++) {

// Esperar a que los procesos terminen

Formato: Guía de Práctica de Laboratorio / Talleres / Centros de Simulación

Formato: Guía de Práctica de Laboratorio / Talleres / Centros de Simulación

Formato: Guía de Práctica de Laboratorio / Talleres / Centros de Simulación

El identificador de hilo se obtiene utilizando pthread_self(), y al imprimirlo en ambas partes

void *thread_function(void *arg) {

Formato: Guía de Práctica de Laboratorio / Talleres / Centros de Simulación

Formato: Guía de Práctica de Laboratorio / Talleres / Centros de Simulación

III. SOLUCIÓN DEL CUESTIONARIO

1. ¿Qué hace la función pthread_detach de la librería pthread?

Es importante tener en cuenta que si un hilo ya ha terminado antes de llamar a pthread_detach(), la

La función pthread_detach se utiliza de la siguiente manera:

2. ¿ Qué hace la función pthread_kill de la librería pthread?

La función pthread_kill se utiliza de la siguiente manera:

thread: Es el identificador del hilo al que deseas enviar la señal.

Formato: Guía de Práctica de Laboratorio / Talleres / Centros de Simulación

También podría gustarte

void sumar_segmento(void arg) {

void thread_function(void arg) {

void thread_function(void arg) {