free-PREGUNTAS TEORIA PCTR PDF

PREGUNTAS TEORIA PCTR.
pdf
jvc93
Programación Concurrente y de Tiempo Real
3º Grado en Ingeniería Informática
Escuela Superior de Ingeniería

Universidad de Cádiz
Reservados todos los derechos.

No se permite la explotación económica ni la transformación de esta obra. Queda permitida la impresión en su totalidad.
PREGUNTAS PCTR
1. Dado el siguiente programa escrito en java, indique qué salida proporcionar á.
public class inconcurrente extends Thread {
private static int n = 0;
private int nIter;
public incConcurrente(int v) {nIter=v;}
public void run(){

for(int i=1;i<=nIter;i++) n++;
}
public static void main(String[] args) throws InterruptedException {
int p = 10;
incConcurrente[] h = new incConcurrente[p];
for(int i=0;i<h.length;i++)h[i] = new incConcurrente(1000);
for(int i=0;i<h.length;i++)h[i].start();
for(int i=0;i<h.length;i++)h[i].join();

System.out.print(n);
}
}
Escriba aquí su respuesta:

El código devolverá un número aproximado a 10000 ya que no hay ningún
control sobre la variable local a la que se accede.
2. Dado el siguiente programa escrito en java, indique qué salida produce.

Justifique su respuesta.
class Animal{
public void move(){
System.out.println("Los animales se mueven");
}
}
class Perro extends Animal{
public void move(){
System.out.println("Los perros andan y corren");
}
}
public class PruebaPerro{
public static void main(String args[]){
Animal a = new Animal();
Animal b = new Perro();
a.move();
b.move();
}
}

Los animales se mueven.
Los perros andan y corren.
a64b0469ff35958ef4ab887a898bd50bdfbbe91a-188990
3. Dado el siguiente programa escrito en java, indique qué salida produce.
Razone su respuesta.
import java.util.concurrent.locks.*;
public class examen implements Runnable{
public static Integer p = new Integer(0);

public static ReentrantLock r = new ReentrantLock();
public int vMax;
public examen(int v) {vMax = v;}
public void run(){
Object q=p;
for(int cont=0;cont<vMax; cont++){
r.lock(); p++; r.unlock();
synchronized(q){try{q.wait();}
catch(InterruptedException e){}}}
}
public static void main(String[] args)throws InterruptedException{

Thread [] h = new Thread[10];
for(int i=0;i<h.length;i++)h[i]=new Thread(new examen(100));
for(int i=0;i<h.length;i++)h[i].start();
Thread j = Thread.currentThread();
j.sleep(1000);

p++;
System.out.print(p);
}
}

El programa no termina su ejecución ya que se hace un wait() para bloquear el
proceso, pero no se pone el proceso en estado de listo de nuevo. Imprime el
valor 11 debido a que todos los hilos entran en el bucle for pero son bloqueado
pero antes aumenta el valor de la variable p en uno siendo un total de 10 y
antes de imprimir el valor de p se incrementa de nuevo por lo que p tendrá el
valor 11 y será imprimido por pantalla sin terminar su ejecución.
4. Defina el concepto de exclusión mutua.

Consiste en evitar la condición de concurso sobre un recurso compartido
forzando la ejecución atómica de las secciones críticas de las entidades
concurrentes que lo usan. Elimina el entrelazado.
Consigue tu certificado de inglés Aptis en un tiempo record y a un precio inmejoroable ¡Clic aquí!
5. Describa el resultado de ejecutar el siguiente programa. Razone su respuesta.
import java.util.concurrent.*;
public class ej1 implements Runnable {

public static int n = 0;
public static ReentrantLock k = new ReentrantLock();
public ej1() {}
public void run(){
try{k.lock();
n++;
}finally{k.unlock();}
}
public static void main(String[] args) {
ThreadPoolExecutor tp= new ThreadPoolExecutor(10,10,2000L,
TimeUnit.MILLISECONDS,
new LinkedBlockingQueue<Runnable>());
tp.prestartAllCoreThreads();
ej1[] tareas = new ej1[5];
for(int k=0; k<tareas.length; k++){
tareas[k] = new ej1();
tp.execute(tareas[k]);
}

tp.shutdown();
System.out.println(n);
}
}

Accede a la variable n en exclusión mutua ya que tenemos definido una
variable del tipo ReentrantLock y la incrementa 5 veces, siendo el valor
imprimido por pantalla.
Obtén tu B2 de Inglés en el Instituto Europeo

6. El siguiente diagrama modela el API básico de java para creación y
manipulación de Threads. Complételo con la información que crea
oportuna, y justifique la información añadida en el espacio
habilitado para ello: [0.5 puntos]
Através de la interfaz Runnable, se crea un objeto que implemente de la interfaz y se
redefine el método run. Para que actúe como hilo, la clase Thread posee un
constructor que genera un objeto de tipo Thread a partir de un Objeto Runnable. El
objeto Thread creado será nuestro hilo del objeto Runnable.
7. Cuál es la diferencia entre una región crítica y un monitor?

[0.5 puntos] Escriba aquí su respuesta:
Una región crítica es una sección crítica cuya ejecución bajo exclusión mutua está
garantizada, mientras que un monitor es una mejora de una región crítica, ya que
además de garantizar la exclusión mutua resuelve el problema de sincronización. El
monitor es de más alto nivel que una región crítica.
8. ¿Qué diferencia a los threads estándar de los threads-RT ?

[0.5 puntos] Escriba aquí su respuesta:
Que el Thread-RT es más conveniente de usar que el Threads, debido a que en java no
existe la herencia múltiple por lo que Threads hipoteca nuestra clase para que no
pueda heredar el comportamiento de ninguna clase. Y con el Thread-RT podemos
hacer que el método run() de uan clase se ejecute en un hilo y además pueda heredar
el comportamiento de otra clase.

9. Considere el conocido problema de encontrar números primos en
un rango dado, y una solución muti-core al mismo que utiliza un
pool de Threads. Conforme aumen- tamos el tamaño del pool, el
tiempo de cálculo cambia de acuerdo a siguiente curva: [0.5
puntos]

Se muestra en la gráfica que a mayor número de hilos, menor tiempo de
procesamiento. Viendo el problema vemos que el Cb=0 y que el rendimiento va en
aumento porque nos vamos acercando al número de núcleos que tiene el procesador.
Llegará un momento en el que los tiempos vuelvan a elevarse porque haya más hilos
que núcleos, pero esto no se muestra ya en la gráfica.
10. La siguiente, es una solución al problema de la exclusión mutua que emplea

variables compartidas. Discuta la corrección parcial de esta solución. Si es
correcta, indique por qué y si no lo es, describa escenarios de ejecución que
indiquen los entre- lazados que llevan a condiciones patológicas: [1 punto]
Procedure Pi
Begin
Repeat
Turno:=i;
While Turno<>i Do;
Sección_Crítica_i;
Turno:=j;
Forever
End;
No es correcta, ya que estamos asignando el valor del hilo propio para acceder a la
sección crítica, con lo cual la sentencia (While Turno <>i Do;) no tendrá sentido porque
acabamos de darle el valor de i a Turno. El hilo se queda dando vueltas en el while.
11. Considere el siguiente programa concurrente. Estudie su corrección total,
y diga si es o no totalmente correcto. Justifique su respuesta. [1 punto]
public class Correc extends Thread{
public static int nH = 10;
public static int n = 0;
public static ReentrantLock 1 = new ReentrantLock();
public Condition v;
public Correc() {v = 1.newCondition();}
public void run()
{
1.lock();try{
try{v.await();} catch(InterruptedException e){}
n++;
}finally {1.unlock();}
}

Correc [] h = new Correc[nH];
for(int i=0; i<h.length;i++)
{h[i]=new Correc(); h[i].start();}
for(int i=0; i<h.length;i++)

{h[i]=new Correc(); h[i].join();}
n++;
System.out.pr
int(n);
}
}
Justifique su respuesta:
No es correcto. El programa nunca terminará. Esto es debido a que se produce un
interbloqueo. Al llegar los hilos, se bloquea por el Condition, pero en ningún
momento se le despierta con lo cual, tenemos el hilo bloqueado y esperando a que
llegue la condición para despertar que nunca llega. Solo se mostrará el valor del hilo
principal por pantalla que es el único no bloqueado.

12. Describa el resultado de ejecutar el siguiente programa. Razone
su respuesta. [1 punto]
public class E17 extends Thread {
static int x = 0;
Semaphore cerrojo = new Semaphore(1);
int t;
public E17(int t){this.t=t;}
public void run(){
switch(t){
case 0:{try{cerrojo.acquire();}
catch(InterruptedException e){}
x++;cerrojo.release();}
case 1:{try{cerrojo.acquire();}
catch(InterruptedException e){}
x--;cerrojo.release();}
}
}
public static void main(String[] args) throws Exception{

E17[] lista = new E17[10000];
for(int i=0;i<lista.length;i++){
lista[i] = new E17(1);
lista[i].start();
}
lista[i].join();
}
System.out.print(x);
}
}
Escriba y razone aquí su respuesta:

El valor esperado de salida es -10000, pero no será el que se muestre, ya que nos
devolverá un valor indeterminado, esto es debido a que el uso del semáforo no es el
correcto. La manera de implementar los semáforos correcta en Java es creando el
semáforo en el método principal y pasando el semáforo en el constructor. Al no estar
bien implementado, el resultado del programa no es el esperado.

17. [2 puntos] Un método de tipo Monte Carlo para calcular de forma aproximada el
valor de PI es inscribir un círculo en un cuadrado según se muestra en la figura y
generar puntos aleatorios.
Si p es el número de punto inscritos en el círculo dividido por el número de puntos
inscritos en el cuadrado, se sabe que PI=4xp y que a mayor número de puntos
generados se obtiene una aproximación a PI de mayor precisión. Se desea escribir un
programa multihebrado en Java que permita estimar PI con la precisión deseada. Para
ello, de determinar y explicar:
* ¿Qué coeficiente Cb de bloqueo cree que tiene un problema? ¿Por qué?

Coeficiente es 0. No hay una variable compartida a la que acceder.
* Si se sabe que Nnd=4, y en función de lo anterior, ¿Cuántos hilos Nt debería de tener
su programa?
Siguiendo la función de Subramanian Nt=Nnd/(1-Cb), sabiendo que Nnd es 4 y el Cb es
0, sabemos que tendremos que tener 4 hilos en el programa.
* ¿Cómo va a particionar el problema para lograr paralelismo multi-core?
El número de puntos a calcular entre los cuatros hilos.
18. [0.5 puntos] El siguiente diagrama modela el API de Java-RT para creación y
manipulación de objetos Schedulabe. Complételo con la información que crea
oportuna, y justifique la información añadida en el espacio habilitado para ello:

19. [0.5 puntos] ¿Qué categoría establece la taxonomía de Flynn? ¿Qué relaciones
guardan estas categorías con las siguientes arquitecturas? Procesadores Multicore,
Sistemas Distribuidos, Cluster de Procesadores, Procesador GPU. Escriba aquí su
respuesta y las relaciones que propone, y justifíquelas:
SISD: Single Instruction, Singlue Data.
Características del Modelo SISD:
La CPU procesa únicamente una instrucción por cada ciclo de reloj, únicamente un
dato es procesado en cada ciclo de reloj. Es el modelo más antiguo de computadora y
el más extendido.
SIMD: Single Instructión, Multiple Data.
Características de Modelo SIMD:
Todas las unidades ejecutan la misma instrucción, cada unidad procesa un dato
distinto, todas las unidades operan simultáneamente.
Procesador GPU.

MISD: Multiple Instruction, Single Data.
Características de Modelo MISD:
Cada unidad ejecuta una instrucción distinta, cada unidad procesa el mismo dato,
aplicación muy limitada en la vida real.
MIMD: Multiple Instruction, Multiple Data.
Características del modelo MIMD:
Cada unidad ejecuta una instrucción distinta, cada unidad procesa un dato distinto,
todas las unidades operan simultáneamente.
Cluster de procesadores, sistemas distribuidos, procesadores multicore.
20. [1 puntos] ¿Es posible implantar regiones críticas como primitiva de control de la
concurrencia en C++11? Escriba y justifique su respuesta; proponga también un
ejemplo en caso positivo:
Si es posible implantarlas simulándolas con mutex.
Struct Contador{
Std:mutex mutex;
Int valor;
Contador():valor(0){}
Void incremento()
{
Mutex.lock();
++valor;
mutex.unlock();
}
};
21. [0.5 puntos] ¿Qué sucede cuando una CPU lanza un kernel sobre una GPU nVidia
que actúa como coprocesador? Escriba aquí su repuesta razonada:
GPU es un coprocesador dedicado al procesamiento de gráficos u operaciones de coma
flotante, para aligera la carga de trabajo del procesador central en aplicaciones. De
esta forma, mientras gran parte de lo relacionado con los gráficos se procesa en la
GPU, la unidad central de procesamiento (CPU) puede dedicarse a otro tipo de
cálculos.
22. [1 puntos] Considere el siguiente programa. Indique la salida –si la hay- que
produce y el comportamiento que tiene. Justifique su respuesta.
public class E131402 extends Thread{
public static Object[] locks;
public static Integer n= new Integer(0);
private int id;
public E131402(int id){

this.id=id;
}
public void run(){
synchronized(locks[id]){

n++;
if(id%2==0)
try{locks[id].wait();
}catch(InterruptedException e){}
System.out.println(n);
}
}
public static void main(String[] args){
locks = new Object[4];
for(int i=0; i<4; i++)
locks[i] = new Object();
for(int i=0; i<4; i++)
new E131402(i).start();
}
}
Indique aquí la salida y el comportamiento, justificando ambos:
El programa deja bloqueado los hilos que tienen como índice el número 0 y el 2, ya
que son números pares. Los dos hilos restantes pasaran la condición e imprimirán que
tiene n en ese momento. El resultado puede ser desde 1 hasta 4 ya que no hay un
control de acceso a la variable a causa de que cada uno posee su propio cerrojo por lo
que todos entran a la vez en la sección crítica.

23. [1 punto] Considere el siguiente programa. Indique la salida –si la hay- que produce
y el comportamiento que tiene. Justifique su respuesta.
import java.util.*;
import java.util.concurrent.atomic.*;
public class E131401 implements Runnable{
private static AtomicInteger s = new AtomicInteger();
private static ReentrantLock l = new ReentrantLock();
private static int p = 2000;
private static ArrayList<Condition> c = new ArrayList<Condition>();
private int n;
public E131401(int n){

this.n=n;
c.add(n, l.newCondition());
}
public void run(){

int j;
for(int i=0; i<1000; i++);
l.lock();
try{ j=s.incrementAndGet();
c.get(0).signalAll();
try{c.get(n).await();
}finally{l.unlock();}
}
public static void main(String[] args){
ExecutorService ept = Executors.newCachedThreadPool();
for(int i=0; i<2000; i++)
ept.submit(new E131401(i));
ept.shutdown();
System.out.print(s);
}
}
Indique aquí la salida y el comportamiento, justificando ambas:
El programa imprime 2000 ya que se incrementa una variable a la que se accede en
exclusión mutua mediante un cerrojo. Pero el programa no termina ya que todos los
hilos se bloquean al llegar a la sentencia await, todos menos uno, el que tiene el id=0
que es el único que se despierta mediente el singalAll.

24. [1 punto] La siguiente curva ilustra el comportamiento temporal de una aplicación
paralela con latencia de red para diferentes valores del coeficiente de bloqueo:
Podemos observar en el gráfico de los tiempos
de la aplicación son menores en un intervalo
determinado por el coeficiente de bloqueo.
Esto es debido que para esos valores del
coeficiente se cran los hilos necesarios para el
funcionamiento óptimo de la aplicación, ni en
exceso ni por defecto. De ahí que cuando nos
salimos de ese intervalo de valores del
coeficiente de bloqueo se produce un
aumento del tiempo.
25. [1 punto] Considere el siguiente programa escrito en C++11. Indique la salida –si la
hay- que produce y el comportamiento que tiene. Justifique su respuesta.
#include <thread>
#include <mutex>
#include <iostream>
struct Comun {

std::mutex clang;
int q;
Comun() : q(0) {}
void oper_A(int x){
std::lock_guard<std::mutex> cerrojo(clang);
q -= x;
}
void oper_B(int x){
q++;
}
void oper_C(int x, int y){
oper_B(33);
oper_A(56);
}
};
int main(){
Comun ref;
ref.oper_B(5);
ref.oper_C(6, 6);
std::cout<<"Spock dice: Larga vida y prosperidad...";
return 0;
}

El programa se queda bloqueado porque no puede coger dos veces el mismo cerrojo,
para que funcione correctamente se debería usar recursive_mutex, para así tener
cerrojos reentrantes.
26. [0.5 puntos] Como es sabido, un monitor garantiza por construcción la exclusión
mutua de todos los procedimientos que define. Sin embargo, ¿deberían ser también
reentrantes por construcción? Justifique su respuesta.
El sistema de ejecución de Java permite que un Thread re-adquiera el monitor que ya
posee realmente porque los monitores Java son re-entrantes. Los monitores
re-entrantes son importantes porque eliminan la posibilidad de que un solo Thread
ponga en punto muerto un monitor que ya posee.
27. [0.5 puntos] Se desea pasar un semáforo como parámetro, y el lenguaje de

soporte que se utiliza permite pasos por valor y referencia. ¿Como debería de

pasarse? Justifique su respuesta.
Por Referencia. Un semáforo se usará como medio de sincronización o de control de
la exclusión mutua. Si lo pasásemos por valor estaríamos realizando una copia del
semáforo, por lo que todos los cambios realizados en él no tendrían ningún efecto
sobre el externo.
28. [0.5 puntos] ¿Cuál es el principal inconveniente del uso de monitores en términos
de rendimiento? Justifique su respuesta.
Un monitor se encarga de que siempre se acceda en exclusión mutua a las variables.
Eso está bien cuando la variable es de escritura, pero si es de lectura, entonces se está
perdiendo tiempo al leer en exclusión mutua cuando no haría falta ya que no se está
modificando la variable.
29. [1.0 puntos] Analice la corrección del algoritmo para control de la exclusión
mutua expresado a continuación.
program em
var C1, C2: integer;

Process P1 Process P2
begin begin
repeat repeat
repeat C1:=1-C2 repeat C2:=1-C1
until C2<>0; until C1<>0;
Critica_1; Critica_2;
C1:=1; C2:=1;
Resto_1; Resto_2;
Forever forever
end; end;
begin (*principal*)
C1:=1; C2:=1;
cobegin
P1; P2;
coend;
end.
La solución a este problema de la exclusión mutua no es correcta, puesto que, primero
los 2 procesos intentan acceder a 2 variables conjuntas al mismo tiempo, cosa que
daría problemas a la hora de elegir quien accede a la sección crítica. Entonces el
problema que tenemos es que dependemos de quien llega primero al bucle que
modifica las variables c para saber quién accede a la sección critica, y aunque un
proceso acceda a la sección critica antes que el otro, este otro al repetir el bucle
accederá a la sección critica, cosa que provocaría conflictos de sincronización. Una
solución al problema se podría resolver de la siguiente manera:
Procedure P1 Procedure P2;
Begin Begin
Repeat Repeat
Resto_código Resto_código;
if c2 == 1 if c1 == 1
Sección_Crítica; Sección_Crítica;
c1:=1; c2:=1;
end end
Forever Forever;

End;
End;
Begin
c1:=0; // Para dar permiso al primer proceso.
c2:=1;
cobegin
P1;P2
coend;
End;
Cuando el proceso que accede a la sección critica hasta que no la abandona no da

permiso al siguiente proceso a que acceda a él, mientras tanto el proceso que no tiene
permiso se queda a la espera repitiendo el bucle hasta que es su turno de acceder a la
sección crítica.

30. [1.0 puntos] Estudie el siguiente código en Java desde el punto de vista de la
corrección parcial. Justifique si es o no parcialmente correcto.
static int x = 0;
final static Lock cerrojo = new ReentrantLock();
static Condition condicion = cerrojo.newCondition();
public void run(){
cerrojo.lock();
try{
while(x<5){ condicion.await(); }
x++;
}
catch(Exception ex){} finally { cerrojo.unlock(); }
}
E24[] lista = new E24[5];
lista[i] = new E24();
lista[i].start();
}

lista[i].join();
}
System.out.print("Resultado: " + x);
}
}
El programa queda bloqueado debido a que se bloquean los hilos que pasan por el run
mientras que la condición sea x menor que 5, y x=0 por tanto se bloquean todo los
hilos y no llega a incrementar n.

31. [1.0 puntos] ¿Cuál es la salida impresa del siguiente código Java?
import java.util.concurrent.CyclicBarrier;
import java.util.concurrent.atomic.AtomicInteger;
static AtomicInteger x = new AtomicInteger(0);
static CyclicBarrier barrera = new CyclicBarrier(5);
public void run(){
System.out.print(x.incrementAndGet());
try{ barrera.await(); } catch(Exception ex){}
System.out.print("a");
}

E23[] lista = new E23[5];
lista[i] = new E23();
lista[i].start();
}
lista[i].join();
}
}
}

Una posible solución del programa seria 12345 ya que estos valores cambian de forma
aleatoria, y a continuación aaaaa.
Los hilos llegan a una barrera, se detienen, y cuando lleguen todos, se reactivan todos
los hilos sin saber el orden en el que se ejecutan cada uno.
32. [1.0 puntos] Considere el siguiente código, que crea cuatro hilos, y observe el
cuerpo del bucle de cada tipo de hilo, formado por una instrucción de asignación
simple. Determine, de forma rigurosa y formal, que tipos de hilos se pueden ejecutar
concurrentemente y cuáles no.
public class ejecEntrelazada extends Thread{

public static int a,b,c,w;
public static int x, y, z;
private int tipoHilo;
public ejecEntrelazada(int tipoHilo){this.tipoHilo=tipoHilo;}
public void run(){
switch(tipoHilo){
case 0:{for(int i=0; i<100000; i++){a=x+y;}; break;}
case 1:{for(int j=0; j<100000; j++){b=z-1;};break;}
case 2:{for(int k=0; k<100000; k++){c=a-b;};break;}
case 3:{for(int h=0; h<100000; h++){w=c+1;};break;}
}
}
a=0; b=0; c=0; w=0; x=1; y=1; z=1;
ejecEntrelazada[] h = new ejecEntrelazada[4];
for(int i=0; i<h.length;i++) h[i]=new ejecEntrelazada(i);
for(int i=0; i<h.length;i++) h[i].start();

for(int i=0; i<h.length;i++) h[i].join();
}
}
Para determinar si un conjunto de instrucciones se pueden ejecutar concurrente
utilizaremos las condiciones de Bernstein. Dado un conjunto de escritura E y un
conjunto de lectura L, tenemos que:
L(Si) intersección E(Sj)
E(Si) intersección E(Sj)
E(Si) intersección L(Sj)
L(S1)={x,y} E(S1)={a}
L(S2)={z} E(S2)={b}
L(S3)={a,b} E(S3)={c}
L(S4)={c} E(S4)={w}

Por lo tanto podríamos ejecutar de forma concurrente: S1 y S2, S1 y S4, S2 y S4.
33. [1.0 puntos] Considere el siguiente código e indique cual es la salida impresa que
produce.
private static Integer i = new Integer(1);
private static int j=0;
private E30 h;
public E30(){j++;}
public void run(){
if(j<500){
h=new E30();
synchronized(i){i++;}
h.start();
try{h.join();}catch (InterruptedException e){}
}
}
E30 h = new E30();
h.start();
h.join();
System.out.println(i.toString());
}
}
El programa imprime 500, ya que se crea un hilo que incrementa la variable j. Mientras
que j sea mayor que 500, se crea otro hilo que seguirá incrementando j hasta que esta
sea mayor o igual que 500 que acabara el programa. A su vez todos los hilos creados
incrementan en exclusión mutua la variable i que será la que muestre su valor al final
del programa.
34. [0.5 puntos] ¿Como funciona el multihebrado en el lado del servidor de una
arquitectura RMI ? Justifique su respuesta.
35. [0.5 puntos] ¿Cuantas métricas de prioridad emplean los objetos de clase
NoHeapRealTimeThread? ¿Por que?
28 niveles de prioridad fijas porque los objetos planificables no cambian su prioridad
y expulsivas porque el sistema puede expulsar al objeto en ejecución que posee la
CPU.
36. [0.5 puntos] ¿Cuál es el principal inconveniente del modelo de regiones críticas?
Justifique su respuesta.
Las Regiones Críticas no permiten que varios procesos lean simultáneamente una
variable, aun en el caso de que este acceso pueda llevarse a cabo. En segundo lugar,
sirven para sincronizar (Se soluciona con las Regiones Críticas Condicionales).
37. [0.5 puntos] Complete el siguiente diagrama relativo a la arquitectura RMI. Debe
rellenar los recuadros y las líneas horizontales con la información que crea adecuada.

38. [0.5 puntos] La clase E35 que sigue no es un monitor. Reescríbala utilizando el API
estándar para que lo sea, de forma que se verifiquen las condiciones de
sincronización siguientes:
valor nunca puede exceder de VMAX

valor nunca puede disminuir de VMIN
public class E35 {

private static final int VMAX = 10;
private static final int VMIN = 0;
private static int valor = 0;
public int incremento(){
return (valor++);
}
public int decremento(){
return (valor--);
}
}

Escriba aquí la nueva versión de la clase E35:
public class E35 {
private static final int VMAX=10;
private static final int VMIN=0;
private static int valor=0;
public synchronized void incrementar(){
while(valor==VMAX){
try{wait();}catch(InterruptedException e){}
}
valor++;
notifyAll();
}
public synchronized void decrementar(){
while(valor==VMIN){
try{wait();}catch(InterruptedException e){}
}
valor--;
notifyAll();
}
}
39. [1.0 puntos] ¿Cuál es la salida impresa del siguiente código Java?
public class E33 implements Runnable{

public static Integer val = new Integer(0);
public int s;
public static ReentrantLock lock = new ReentrantLock();
public E33(int s) {this.s = s;}
public void run(){
Object val2=val;
for(int i=0;i<s; i++){
lock.lock();
val++;
lock.unlock();
synchronized(val2){
try{
val2.wait();
}
}
}

E33 [] h = new E33[10];
for(int i=0;i<h.length;i++)h[i]=new E33(100);
int nP = Runtime.getRuntime().availableProcessors();
ThreadPoolExecutor ept = new ThreadPoolExecutor(
nP*4, nP*4,1000L,TimeUnit.MILLISECONDS,
ept.prestartAllCoreThreads();
for(int i=0; i<h.length; i++) ept.execute(h[i]);

ept.shutdown();
do{} while(!ept.isTerminated());
val++;
System.out.print(val);
}

}
El programa queda en interbloqueo ya que hace un wait() para bloquear los hilos pero
no se hace nada para despertarlos de nuevo.
40. [1.0 puntos] ¿Cuál es la salida impresa y el comportamiento del siguiente código
Java?
private String s;
private static Object o = new Object();
public E34(String s){this.s = s;}
public void run(){
synchronized(o){
switch(this.s){
case "ping":
for(int i=0; i<10; i++){
System.out.print(this.s+" ");
o.notify();
try{o.wait();}catch(InterruptedException e){}
}
case "pong":
for(int i=0; i<5; i++){
try{o.wait();}catch(InterruptedException e){}

System.out.print(this.s+" ");
o.notify();
}
}
}
}

E34 Lendl = new E34("pong");
E34 McEnroe = new E34("ping");
Lendl.start();
McEnroe.start();
Lendl.join();
McEnroe.join();
}
}
Hay un interbloqueo. El hilo Lendl acabara su ejecución debido a que tiene menos iteraciones,
pero el hilo McEnroe, al tener más iteraciones se quedara esperando en el wait() a que el otro
hilo, el cual ya ha terminado, lo libere. Cosa que nunca pasará.
41. [1.0 puntos] Considere el siguiente código e indique cual es la salida impresa que
produce.

private static Integer i = new Integer(1);
private static Integer j = new Integer(1);
private static int k=0;
private E31 mi_thread;
public E31(){k++;}
public void run(){
if(k<800){
mi_thread=new E31();
synchronized(j){i--;}
mi_thread.start();
try{mi_thread.join();}catch (InterruptedException e){}
}

}
E31 otro_thread = new E31();
otro_thread.start();
otro_thread.join();
System.out.println(i.toString());
}
}
El programa lanza un hilo que al crearse incrementara la variable K con valor inicial =
0.Mientras que K sea menor que 800, se creara un hilo que incrementara K y a su vez
decrementará i, que tiene valor inicial 1. Como se crean 799 hilos en total, el valor de
la variable i al final del programa será -798.
El acceso a la variable i es seguro ya que se utiliza un bloque sincronizado.
42. [1.0 puntos] ¿En qué se diferencian las variables de condición de un monitor
Hoare del wait-set asociado a los objetos Java?
Cada variable de condición tiene asociada una cola FIFO para los procesos que están
bloqueados y ofrece dos operaciones atómicas básicas wait() y signal(), mientras que
wait-set es una cola de procesos bloqueados a nivel de objeto que está asociado con
el lock del objeto, utiliza wait(), notify() y notifyAll().
43. [1.0 puntos] ¿Es posible implantar monitores C++11 como primitiva de control de
la concurrencia equivalentes a los monitores Hoare? Escriba y justifique su
respuesta.
Si es posible implantarlos simulandolos mediante mutex.
struct Contador{
std::mutex mutex;
int valor;
Contador():valor(0){}
void incremento(){
mutex.lock();
++valor;
mutex.unlock();
}
};
44. [0.5 puntos] ¿Qué sucede cuando una CPU lanza un kernel sobre una CPU nVidia
que actúa como coprocesador? Escriba aquí su respuesta razonada:
GPU es un coprocesador dedicado al procesamiento de gráficos u operaciones de coma

flotante, para aligerar la carga de trabajo del procesador central en aplicaciones.
De esta forma, mientras gran parte de lo relacionado con los gráficos se procesa en la
GPU, la unidad central de procesamiento (CPU) puede dedicarse a otro tipo de
cálculos.
45. [1.0 puntos] Considere el siguiente programa. Indique la salida -si la hay- que
class Task implements Runnable{
public static int cont = 0;
private boolean tHilo;
public Task(boolean tHilo){this.tHilo=tHilo;}
public void run(){
if(tHilo)
for(int i=0; i<1000000; i++) cont++;
else for(int i=0; i<1000000; i++) cont--;
}
}
public class E131406{
ThreadPoolExecutor ejecutor = new ThreadPoolExecutor(
1, 1, 60000L,
TimeUnit.MILLISECONDS,
ejecutor.execute(new Task(true));
ejecutor.execute(new Task(false));
ejecutor.shutdown();
while(!ejecutor.isTerminated()){}
System.out.println(Task.cont);
}
}
El programa devuelve 0 ya que se lanzan dos hilos del pool de Threads que uno suma
y el otro resta. Pero al ser de un pool, el segundo hilo espera a que el primero acabe
su ejecución, por tanto no hay entrelazado.
46. [1.0 puntos] Considere el siguiente programa. Indique la salida -si la hay- que
public class E131408 extends Thread
{
Integer I;
public E131408(Integer I) {this.I=I;}
public void run(){
System.out.println(this.getName());
synchronized(I){
try{I.wait();}catch (InterruptedException e){}
System.out.println(this.getName()+" diCE: Hola...");}

}
public void m1(){synchronized (I){I.notify();}}
public void m2(){synchronized (I){I.notifyAll();}}
public static void main(String[] args) throws InterruptedException{

Integer I = new Integer(0);
E131408 [] AliBaba = new E131408[10];
for(int i=0; i<10;i++){
AliBaba[i]=new E131408(I); AliBaba[i].start();}
AliBaba[5].m1();
Thread SpeedyGonzalez = currentThread();
SpeedyGonzalez.sleep(2000);
AliBaba[5].m2();
System.out.print("Todos terminaron...");
}
}
El programa lanza 10 hilos que escriben su nombre. Después llama al método m1 que
despierta a un hilo aleatorio que escribirá Hola. A continuación se crea un hilo que se
manda a dormir 2 segundos. Más tarde se despiertan a todos los hilos bloqueados (los
9 restantes) que escribirán Hola. Y por último se imprime "Todos terminaron...". El
orden de impresión es aleatorio.

47. [1.0 puntos] La siguiente curva ilustra el comportamiento en términos de
rendimiento de una aplicación paralela donde las diferentes tareas utilizan
contenedores de datos sincronizados para realizar los intercambios de información
que necesitan. La misma versión del código se ha ejecutado con una instancia de la
clase HashMap sincronizada de forma estándar (synchronized) y con una instancia de
la clase ConcurrentHashMap, para un procesador multinúcleo de 8 cores.
La versión concurrente obtendrá un mayor rendimiento a medida que aumenten los
hilos, ya que habrá entrelazado y se ejecutarán todas las tareas a la vez, mientras que
la otra versión se hará en exclusión mutua por lo que se ejecutaran las tareas de una
en una consiguiendo así que se tarde más en completar todas las tareas y teniendo 3
de los cuatros núcleos ociosos cada vez.


free-PREGUNTAS TEORIA PCTR PDF

Cargado por

Información del documento

Descripción original:

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

free-PREGUNTAS TEORIA PCTR PDF

Cargado por

Copyright:

Formatos disponibles

PREGUNTAS TEORIA PCTR.

Programación Concurrente y de Tiempo Real

3º Grado en Ingeniería Informática

Escuela Superior de Ingeniería

Reservados todos los derechos.

public void run(){

Reservados todos los derechos.

Escriba aquí su respuesta:

2. Dado el siguiente programa escrito en java, indique qué salida produce.

Escriba aquí su respuesta:

public static Integer p = new Integer(0);

public static void main(String[] args)throws InterruptedException{

Reservados todos los derechos.

Escriba aquí su respuesta:

4. Defina el concepto de exclusión mutua.

public class ej1 implements Runnable {

Reservados todos los derechos.

Escriba aquí su respuesta:

Obtén tu B2 de Inglés en el Instituto Europeo

7. Cuál es la diferencia entre una región crítica y un monitor?

8. ¿Qué diferencia a los threads estándar de los threads-RT ?

Obtén tu B2 de Inglés en el Instituto Europeo

Reservados todos los derechos.

10. La siguiente, es una solución al problema de la exclusión mutua que emplea

public static void main(String[] args)throws InterruptedException{

Reservados todos los derechos.

Obtén tu B2 de Inglés en el Instituto Europeo

public E17(int t){this.t=t;}

public static void main(String[] args) throws Exception{

Reservados todos los derechos.

Escriba y razone aquí su respuesta:

Obtén tu B2 de Inglés en el Instituto Europeo

Reservados todos los derechos.

Obtén tu B2 de Inglés en el Instituto Europeo

Reservados todos los derechos.

public E131402(int id){

Reservados todos los derechos.

Obtén tu B2 de Inglés en el Instituto Europeo

public class E131401 implements Runnable{

public E131401(int n){

Reservados todos los derechos.

Obtén tu B2 de Inglés en el Instituto Europeo

Reservados todos los derechos.

Obtén tu B2 de Inglés en el Instituto Europeo

27. [0.5 puntos] Se desea pasar un semáforo como parámetro, y el lenguaje de

Reservados todos los derechos.

var C1, C2: integer;

Reservados todos los derechos.

Cuando el proceso que accede a la sección critica hasta que no la abandona no da

Obtén tu B2 de Inglés en el Instituto Europeo

Reservados todos los derechos.

Obtén tu B2 de Inglés en el Instituto Europeo

public static void main(String[] args) throws Exception{

Reservados todos los derechos.

public class ejecEntrelazada extends Thread{

Obtén tu B2 de Inglés en el Instituto Europeo

Reservados todos los derechos.

Reservados todos los derechos.

valor nunca puede exceder de VMAX

public class E35 {

Obtén tu B2 de Inglés en el Instituto Europeo

Reservados todos los derechos.