Docsity
Docsity

Prepara tus exámenes
Prepara tus exámenes

Prepara tus exámenes y mejora tus resultados gracias a la gran cantidad de recursos disponibles en Docsity


Consigue puntos base para descargar
Consigue puntos base para descargar

Gana puntos ayudando a otros estudiantes o consíguelos activando un Plan Premium


Orientación Universidad
Orientación Universidad


hilos estructurados programacion, Ejercicios de Tecnologías de la Información y la Comunicación

ejercicios estructurados de hilos

Tipo: Ejercicios

2022/2023

Subido el 31/10/2023

gregori-hurtado-bones
gregori-hurtado-bones 🇪🇨

1 documento

1 / 9

Toggle sidebar

Esta página no es visible en la vista previa

¡No te pierdas las partes importantes!

bg1
Implementación de Hilos con Semáforos Binarios:
Casos de Uso Real: Un caso de uso común para semáforos binarios es la gestión de recursos
compartidos. Imagina una aplicación donde múltiples hilos intentan acceder a un recurso
compartido, como una base de datos. Los semáforos binarios pueden garantizar que solo un
hilo acceda al recurso a la vez, evitando conflictos y asegurando la consistencia de los datos.
Ejemplo de Implementación en Java:
import java.util.concurrent.Semaphore;
class SharedResource {
private static Semaphore semaphore = new Semaphore(1);
public void accessResource() {
try {
semaphore.acquire();
System.out.println("Thread " + Thread.currentThread().getId() + " is accessing the shared
resource.");
// Realizar operaciones en el recurso compartido
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
semaphore.release();
}
}
}
class WorkerThread implements Runnable {
private SharedResource resource;
public WorkerThread(SharedResource resource) {
this.resource = resource;
}
public void run() {
resource.accessResource();
}
pf3
pf4
pf5
pf8
pf9

Vista previa parcial del texto

¡Descarga hilos estructurados programacion y más Ejercicios en PDF de Tecnologías de la Información y la Comunicación solo en Docsity!

Implementación de Hilos con Semáforos Binarios: Casos de Uso Real: Un caso de uso común para semáforos binarios es la gestión de recursos compartidos. Imagina una aplicación donde múltiples hilos intentan acceder a un recurso compartido, como una base de datos. Los semáforos binarios pueden garantizar que solo un hilo acceda al recurso a la vez, evitando conflictos y asegurando la consistencia de los datos. Ejemplo de Implementación en Java: import java.util.concurrent.Semaphore; class SharedResource { private static Semaphore semaphore = new Semaphore(1); public void accessResource() { try { semaphore.acquire(); System.out.println("Thread " + Thread.currentThread().getId() + " is accessing the shared resource."); // Realizar operaciones en el recurso compartido } catch (InterruptedException e) { e.printStackTrace(); } finally { semaphore.release(); } } } class WorkerThread implements Runnable { private SharedResource resource; public WorkerThread(SharedResource resource) { this.resource = resource; } public void run() { resource.accessResource(); }

public class Main { public static void main(String[] args) { SharedResource sharedResource = new SharedResource(); Thread thread1 = new Thread(new WorkerThread(sharedResource)); Thread thread2 = new Thread(new WorkerThread(sharedResource)); thread1.start(); thread2.start(); } } Salida de Ejecución: Thread 10 is accessing the shared resource. Thread 11 is accessing the shared resource. Implementación de Hilos con Semáforos con Número de Threads en Zona Crítica:

public WorkerThread(ConnectionPool connectionPool) { this.connectionPool = connectionPool; } public void run() { connectionPool.getConnection(); } } public class Main { public static void main(String[] args) { ConnectionPool connectionPool = new ConnectionPool(); Thread[] threads = new Thread[5]; for (int i = 0; i < threads.length; i++) { threads[i] = new Thread(new WorkerThread(connectionPool)); threads[i].start(); } } } Implementación de Hilos con Semáforos Binarios: Casos de Uso Real: Un caso de uso común para semáforos binarios es la gestión de recursos compartidos. Imagina una aplicación donde múltiples hilos intentan acceder a un recurso compartido, como una base de datos. Los semáforos binarios pueden garantizar que solo un hilo acceda al recurso a la vez, evitando conflictos y asegurando la consistencia de los datos. Ejemplo de Implementación en Java:

java Copy code import java.util.concurrent.Semaphore; class SharedResource { private static Semaphore semaphore = new Semaphore(1); public void accessResource() { try { semaphore.acquire(); System.out.println("Thread " + Thread.currentThread().getId() + " is accessing the shared resource."); // Realizar operaciones en el recurso compartido } catch (InterruptedException e) { e.printStackTrace(); } finally { semaphore.release(); } } } class WorkerThread implements Runnable { private SharedResource resource; public WorkerThread(SharedResource resource) { this.resource = resource; } public void run() { resource.accessResource();

import java.util.concurrent.Semaphore; class ConnectionPool { private static final int MAX_CONNECTIONS = 3; private static Semaphore semaphore = new Semaphore(MAX_CONNECTIONS); public void getConnection() { try { semaphore.acquire(); System.out.println("Thread " + Thread.currentThread().getId() + " has acquired a connection."); // Realizar operaciones con la conexión Thread.sleep(2000); // Simulando el uso de la conexión } catch (InterruptedException e) { e.printStackTrace(); } finally { System.out.println("Thread " + Thread.currentThread().getId() + " has released the connection."); semaphore.release(); } } } class WorkerThread implements Runnable { private ConnectionPool connectionPool; public WorkerThread(ConnectionPool connectionPool) { this.connectionPool = connectionPool; } public void run() { connectionPool.getConnection();

public class Main { public static void main(String[] args) { ConnectionPool connectionPool = new ConnectionPool(); Thread[] threads = new Thread[5]; for (int i = 0; i < threads.length; i++) { threads[i] = new Thread(new WorkerThread(connectionPool)); threads[i].start(); } } } Salida de Ejecución: Thread 11 has acquired a connection. Thread 10 has acquired a connection. Thread 12 has acquired a connection. Thread 11 has released the connection. Thread 13 has acquired a connection. Thread 12 has released the connection. Thread 10 has released the connection. Thread 14 has acquired a connection. Thread 13 has released the connection. Thread 14 has released the connection. En este ejemplo, hay un máximo de 3 conexiones disponibles en el pool. Los hilos solicitan y liberan conexiones, pero solo un máximo de 3 hilos pueden tener acceso simultáneamente debido al semáforo con número de threads en zona crítica.