UNIVERSIDAD ANDINA DEL CUSCO

ESCUELA PROFESIONAL DE INGENIERIA DE SISTEMAS

PROGRAMACION CONCURRENTE Y PARALELA
1ra Práctica 1ra Unidad
2017-II
Estudiantes: Habrahan Solis Garcia
Leo Eduardo Mujica Luque
1. ¿Cuál es la diferencia entre notify () y notifyAll ()? ¿Cuándo es seguro sustituir uno con el
otro? (5)
 notify () si todos sus hilos de espera  notifyAll () para otros casos en los
son intercambiables (el orden en que los subprocesos en espera
que se despiertan no importa), o si pueden tener diferentes propósitos y
sólo tiene un hilo de espera. Un deberían poder ejecutarse
ejemplo común es un grupo de simultáneamente. Un ejemplo es una
subprocesos utilizado para ejecutar operación de mantenimiento en un
trabajos desde una cola - cuando se recurso compartido, donde varios
agrega un trabajo, se notifica uno de subprocesos están esperando a que
los subprocesos para que se se complete la operación antes de
despierte, ejecute el siguiente acceder al recurso.
trabajo y vuelva a dormir.

public class Pistola {

private int cartucho;
private boolean enposicion = true;

public synchronized void disparar(int cartucho) {

while (enposicion == false) {
try {
// Esperar a apuntar
wait();
} catch (InterruptedException e) { }
}
enposicion = false;
notifyAll();
}

public synchronized void apuntar() {

while (enposicion == true) {
try {
// Esperar a disparar
wait();
} catch (InterruptedException e) { }
}
 enposicion = true;
notifyAll();
}

2. Nombrar y explicar tres formas de sincronización utilizadas en Java Threads. (5)

Synchronized. wait(), notify() y notifyAll()

Cuando se llama al método Synchronized , el hilo que llama ingresa al monitor de

objeto, que entonces bloquea el objeto. Mientras está bloqueado ningún otro hilo
puede ingresar al método, ni ingresar algún otro método sincronizado definido por
el objeto.

class SumArray {
private int sum;

synchronized int SumArray(int nums[]){

sum=0; //inicializa sum

for (int i=0;i<nums.length;i++){

sum= nums[i];
System.out.println ("Ejecucion total para" + Thread.currentThread().getName() + "
es " + sum);

try{
Thread.sleep(10); //permite el suicheo de tareas
}
catch (InterruptedException exc){
System.out.println ("Hilo principal interrumpido ");
}
}
return sum;
}
}
class MyThread implements Runnable{
Thread thrd;
static SumArray sa=new SumArray();
int a[];
int answer;

/ /contruye un nuevo hilo

MyThread(String name,int nums[]){
thrd= new Thread (this,name);
thrd.start(); //arranca el hilo
a= nums;
}

//inicia la ejecucion del nuevo hilo

 public void run(){
int sum;
System.out.println ("Suma para " + thrd.getName() + " es " + answer);
System.out.println (thrd.getName() + "terminando");
}

}
class Sync{
public static void main (String[] args) {
int a[]={1,2,3,4,5};

MyThread mt1= new MyThread ("Hijo #1",a);

MyThread mt2= new MyThread ("Hijo #2",a);
}
}

Los métodos wait (), notify () y notify all () son parte de todos los objetos porque
están implementados por la clase Object. Estos métodos sólo pueden ser
llamados desde el interior de un método Synchronized.

class TickTock {
synchronized void tick ( boolean running ) {
if ( !running ) { //para el reloj
notify ( ); // notifica una espera para el hilo
return:
}
System.out.println ( "Tic ");
notify ( ); // permite la ejecución del tock ()
try {
wait ( ); // espera que tock ( ) se complete
}
catch ( InterruptedException exc ) {
System.out.println ( "del Hilo interrumpido ");
}
}
synchronized void tock ( boolean running ) {
if (!running) { //para el reloj
notify ( ); // notifica una espera para el hilo
return;
}
System.out.println ( "Toc");
notify ( );
try {
wait ( ); // espera que tick ( ) se complete
}
catch ( InterruotedException exc ) {
System.out.println ( "Hilo interrumpido");
}
 }
}

class MyThread implements Runnable {

Thread thrd;
TickTock ttOb;

// construye un nuevo hilo

MyThread ( String name.TickTock tt ) {
thrd= new Thread ( this.name );
ttOb= tt;
thrd.start ( ); // arranca el hilo
}
//inicia la ejecución del nuevo hilo
public void main ( ) { // El hilo comienza a ejecutarse aquí
if ( thrd.getName ( ).compareTo ( "Tick") == 0 ) {
for ( int i=0; i<5; i++ ) ttOb.tick ( true );
ttOb.tock ( false );
}
else {
for ( int i=0; i<5; i++ ) ttOb.tock ( true );
ttOb.tock ( false );
}
}
}

class ThreadCom {
public static void main ( String args [ ]) {
TickTock t1= new TickTock ( );
MyThread mt1= new MyThread ( "Tick",tt );
MyThread mt2= new MyThread ( "Tock",tt );
try {
mt1.thrd.join ( );
mt2.thrd.join ( );
} catch ( InterruptedException exc ) {
System.out.println ( "Procedimiento interrumpido ");
}
}
}

3. Debe implementar un controlador para un dispositivo al que se puede acceder con la

siguiente interfaz: (10)

Escribir una clase Controlador en Java Threads que pueden consultar los sensores
simultáneamente para ejecutar el dispositivo. Debe implementar su método run () de tal
manera que inicie el dispositivo examinando los nuevos valores del sensor. El controlador
apaga el dispositivo si el sensor de calor excede el valor 70 o el sensor de presión el valor
100. También complete el método run () en la clase Sensor que llama updateValue ()
continuamente y señala al controlador si su valor ha cambiado.
package sensor;
import java.io.*;
import static java.lang.Thread.sleep;

public class Controlador extends Thread{

private Dispositivo dis;
public Controlador(Dispositivo dis)
{
this.dis=dis;
}
public void run()
{
for(int i=0;i<10;i++)
{
dis.Inicio();
dis.Apagar();
System.out.println("EL valor del sensor de Calor es: "+dis.impCalor());
System.out.println("EL valor del sensor de Presion es: "+dis.impPresion());
try{
sleep((int)(Math.random()*1000));
}catch(InterruptedException e){}
}
try{
sleep(100);
}catch(InterruptedException e){
}
System.out.println("Sensores Apagados");
}
}

package sensor;

public class Dispositivo {

private int calor;
private int presion;
 public Dispositivo()
{
calor=60;
presion=90;
}

public void Inicio() {

calor++;
presion++;
}
public void Apagar() {
if(calor>70){

try {
System.out.println("EL valor del sensor de Calor Exedio el valor de 70 ");
wait();
} catch (Exception e) {
notify();
}
}
if( presion>100){

try {
System.out.println("EL valor del sensor de Presion Exedio el valor de 100 ");
wait();
} catch (Exception e) {
notify();
}
}

public int impCalor()

{
return calor;
}
public int impPresion()
{
return presion;
}
}
package sensor;
import java.io.*;

public class Sensor {

private Dispositivo con;
private Controlador d1;

public Sensor()
{
con=new Dispositivo();
d1=new Controlador(con);

public void inicia()

{
d1.start();
}
public static void main(String[] args) {
Sensor p=new Sensor();
p.inicia();