FACULTAD DE CIENCIAS DE LA COMPUTACION PRIMER PARCIAL

FACULTAD DE CIENCIAS DE LA COMPUTACION
EXAMEN DE PROGRAMACION CONCURRENTE Y PARALELA
PRIMER PARCIAL
MATRICULA: 200319041
NOMBRE: ALBERTO LEON APARICIO
I.
Contesta las siguientes preguntas
1. tenemos un sistema basado en varios procesos indica cuales serian los posibles estados que
tendría un proceso y especifica que instrucción crea un proceso.
El proceso en un principio es creado bajo la instrucción new del metodo thread,
posteriormente entra en un estado de listo con la ayuda de la instrucción Start(), y espera a
que el Scheduler le de la oportunidad de ponerse en ejecución y si no acaba antes de que
termine su tiempo se pone en estado bloqueado bajo la instrucción sleep(); y una vez
terminado de ejecutarse por completo es terminado.
2. explica la diferencia entre un programa concurrente, paralelo y distribuido.
La programación concurrente es la ejecución de dos procesos o más, simultáneamente con
lapsos de tiempo entre cada uno de ellos que le da el procesador, la paralela es la ejecución de
estos procesos pero para cada proceso hay un procesador y la distribuida es similar a la
paralela pero sus memorias comunes están interconectadas y no comparten una memoria en
común.
3. cuales son los tipos de arquitectura de hardware que se puede ejecutar un programa concurrente.
Los programas concurrentes pueden ser ejecutados en arquitecturas tanto monoprocesadores
como los de tipo multiprocesadores.
4. cuales son las propiedades que debe cumplir un programa concurrente efectivo.
Debe cumplir además de sus especificaciones funcional las propiedades de seguridad que
asegura que nada malo va a pasar durante la ejecución del programa y viveza que asegura que
algo bueno pasara eventualmente durante su ejecución del programa
II.
Responde cual de las siguientes afirmaciones es concreta
a. Un hilo puede solo crearse en java utilizando la clase Thread.
Correcto
b. Los procesos tienen mas elementos que los hilos por eso pesan mas en el momento del
procesamiento.
Correcto
c. El cambio de contexto produce un cambio de estado.
Falso
d. Todos los hilos se ejecutan del modo supervisor o núcleo.
Correcto
e. Los programas concurrentes utilizan instrucciones que se intercalan para ejecutar su
código
Correcto
f. La aportación de la arquitectura de Von Neuman fue relevante para la programación
concurrente.
Correcto
g. Los programas concurrentes son totalmente deterministicos.
Falso
h. Java es el único lenguaje que permite el manejo de hilos.
Falso
III.
Aplica las condiciones de Beristein para las siguientes instrucciones y obtener:
a) conjunto de lectura y escritura
b) grafo
c) par cobegin/end
S1: p = r + t
S2: h = x – 1
S3: j = y + 1
S4: w = m + p
S5: z = j + x + h
S6: o = w + z
L(S1) ∩ E(S2) = ∅
E(S1) ∩ L(S5) = ∅
E(S1) ∩ E(S2) = ∅
L(S1) ∩ E(S3) = ∅
E(S1) ∩ L(S3) = ∅
E(S1) ∩ E(S3) = ∅
L(S1) ∩ E(S4) = {p} ≠ ∅
E(S1) ∩ L(S4) = ∅
E(S1) ∩ E(S4) = ∅
L(S1) ∩ E(S5) = ∅
E(S1) ∩ L(S5) = ∅
E(S1) ∩ E(S5) = ∅
L(S1) ∩ E(S6) = ∅
E(S1) ∩ L(S6) = ∅
E(S1) ∩ E(S6) = ∅
L(S2) ∩ E(S3) = ∅
E(S2) ∩ L(S3) = ∅
E(S2) ∩ E(S3) = {1} ≠ ∅
L(S2) ∩ E(S4) = ∅
E(S2) ∩ L(S4) = ∅
E(S2) ∩ E(S4) = ∅
L(S2) ∩ E(S5) = {h} ≠ ∅
E(S2) ∩ L(S5) = ∅
E(S2) ∩ E(S5) = {x} ≠ ∅
L(S2) ∩ E(S6) = ∅
E(S2) ∩ L(S6) = ∅
E(S3) ∩ E(S6) = ∅
L(S3) ∩ E(S4) = ∅
E(S3) ∩ L(S4) = ∅
E(S3) ∩ E(S4) = ∅
L(S3) ∩ E(S5) = {j} ≠ ∅
E(S3) ∩ L(S5) = ∅
E(S3) ∩ E(S5) = ∅
L(S3) ∩ E(S6) = ∅
E(S3) ∩ L(S6) = ∅
E(S3) ∩ E(S6) = ∅
L(S4) ∩ E(S5) = ∅
E(S4) ∩ L(S5) = ∅
E(S4) ∩ E(S5) = ∅
L(S4) ∩ E(S6) = {w} ≠ ∅
E(S4) ∩ L(S6) = ∅
E(S4) ∩ E(S6) = ∅
L(S5) ∩ E(S6) = {z} ≠ ∅
E(S5) ∩ L(S6) = ∅
E(S5) ∩ E(S6) = ∅
S1 S2 S3
S4
S5
S6
no si
si
S1 -
si
si
S2 -
-
no si
no si
S3 -
-
-
si
no si
S4 -
-
-
-
si
no
S5 -
-
-
-
-
no
S6 -
-
-
-
-
-
begin
cobegin
S1;
S2;
coend
S1
cobegin
S3;
S4;
coend
S5;
S6;
S2
S4
S3
S5
End
S1
IV.
Dado el siguiente código corregir e implementar con interfaz Runnable y decir que
imprime este programa
class A extend Trhead
{
public A (String nombre)
{ super (nombre); }
public void rum
{system.out println(“nombre=”+getName( ));}
Class B
{
public static void main (String[] args)
{
A a=new A (Mi hilo);
A b=new A( );
b.setName(“Otro Hilo”);
a.star ( );
b.star( );
}
class A extends Thread
{
public A (String nombre)
{ super (nombre); }
public void run()
{System.out.println("nombre = "+getName());}
}
class B
{
public static void main (String[] args)
{
A a = new A("Mi hilo");
A b = new A("");
b.setName("Otro Hilo");
a.start( );
b.start( );
}
}
El programa al ejecutarse muestra en la pantalla el mensaje Mi hilo que es de el proceso padre y
posteriormente Otro hilo que es de el proceso hijo, después terminan los dos procesos creados del
programa.