Pages (2): [1] 2 » Show 150 posts per page

La mia versione dell'esercizio sul produttore/consumatore.
Io l'ho interpretato in questo modo: c'è un produttore che ogni 10 secondi incrementa il contenuto del cassetto di un valore predefinito (cmq personalizzabile) e poi ci sono 1 o n Client che contattano il server produttore e consumano una quantità predefinita... se nn c'è niente nn si consuma niente.

code:

import java.io.*;
import java.net.*;

class Cassetto {
	private int contatore;
	
	public Cassetto(int val){
		contatore = val;
	}
	
	public synchronized void produci(int incremento){
		contatore = contatore + incremento;
	}
	
	public synchronized void consuma(int decremento){
		if(contatore > decremento){
		 	contatore = contatore - decremento;
		 } else {
		 	contatore = 0;
		 }
	}
	
	public int report(){
		return contatore;
	}
}

class Produttore extends Thread{
	static Cassetto cp;
	static ServerSocket ss;
	static Socket s;
	
	public Produttore(int porta, Cassetto c){
		try{
			cp = c;
			ss = new ServerSocket(porta);
		} catch (Exception e) {}
	}
	
	public void run(){
		// Ogni 10 secondi il produttore incrementa...
		while(true){
			try{
				Thread.sleep(10000);
			} catch(Exception e) {}
			// il valore 10 può essere cambiato a piacere
			cp.produci(10);
			System.out.println("Produco! Ora siamo a "+ cp.report());
		}
	}
	
	public static void main(String[] args){
		Produttore p = new Produttore(12000,new Cassetto(400)); 
		p.start();
		try{
			while(true){ 
					s = ss.accept();
					(new ClientManager(cp, s)).start();
			}
		} catch(Exception e) {}
	}
}

class ClientManager extends Thread {
	Cassetto ccm;
	Socket scm;
	
	public ClientManager(Cassetto c, Socket s){
		ccm = c;
		scm = s;
	}
	
	public void run(){
		try {
			InputStream ThreadIn = scm.getInputStream();
			OutputStream ThreadOut = scm.getOutputStream();
			int c;
		
			// Legge dal client quanto bisogna consumare
			String valore = "";
		   while ((c = ThreadIn.read()) != 10) {
		     valore = valore + (char)c;
			}			
			
			// Consuma
			ccm.consuma(Integer.valueOf(valore).intValue());
			System.out.println("Decremento di " + valore + ". Siamo a "+ ccm.report());
		
			// Riporta al client il valore attuale
			valore = "" + ccm.report()+ '\n';
			for (int i=0; i < valore.length(); i++) {
		  		ThreadOut.write((int)valore.charAt(i));
			}
		} catch(Exception e) {}	
	}
}

class Consumatore{	
	public static void main(String[] args){
		Socket s;
		OutputStream ClientOut;
		InputStream ClientIn;
		int decremento = 20; 
		
		try{	
			s = new Socket("localhost", 12000);
			ClientOut = s.getOutputStream();
			ClientIn = s.getInputStream();
			
			int c;
			String valore;
					
			// Comunica al server quanto bisogna consumare
			valore = "" + decremento + '\n';
			for (int i=0; i < valore.length(); i++) {
		  		ClientOut.write((int)valore.charAt(i));
			}
			System.out.println("Chiedo di decrementare di " + decremento);
						
			// Riceve dal server il valore attuale
			valore = "";
		   while ((c = ClientIn.read()) != 10) {
		     valore = valore + (char)c;
		   }
		   
			System.out.println("Nel cassetto ci sono per ora " + valore);  
		} catch(Exception e) { }	
	}
}

Ecco la mia soluzione. è strutturata un po diversamente rispetto a quella di futurbaggio. In particolare c'è un server centrale a cui è associato il contenitore degli oggetti; a questo possono collegarsi un numero indefinito di produttori e consumatori

code:

import java.net.*;

public class Server {
	
	
	static ClientAccess Client=null;
	static ServerSocket LISTENING=null;
	static Warehouse WAREHOUSE=new Warehouse();
	
	public static void main(String ARGS[]) throws Exception{
		
		//Creo una ServerSocket in attesa di connessioni sulla porta 4444
		LISTENING=new ServerSocket (4444,300);
		System.out.println("Server started; waiting for connections...");
		
		while(true){
			Client=new ClientAccess (LISTENING.accept(), WAREHOUSE);
			System.out.print("New client connected...");
			Client.start();
			System.out.println("thread started");
		}
		
	}

}

import java.io.*;
import java.net.*;

public class ClientAccess extends Thread{

	private OutputStream OUT_TO_CLIENT=null;
	private InputStream IN_FROM_CLIENT=null;
	private Socket SERVICE=null;
	//COMMAND=0 per produrre, COMMAND=1 per consumare
	private int COMMAND=0;
	private Warehouse WH=null;
	
	public ClientAccess (Socket SERV, Warehouse WAREHOUSE){
		this.SERVICE=SERV;
		this.WH=WAREHOUSE;
	}
	
	public void run(){
		
		try{
			
			this.IN_FROM_CLIENT=this.SERVICE.getInputStream();
			this.OUT_TO_CLIENT=this.SERVICE.getOutputStream();
			
			while(true){
				this.COMMAND=this.IN_FROM_CLIENT.read();
				//devo produrre
				if (this.COMMAND==0){
					if(this.WH.addItem()){
						//operazione avvenuta con successo
						OUT_TO_CLIENT.write(1);
					}else{
						OUT_TO_CLIENT.write(0);
					}
				//devo consumare
				}else{
					if(this.WH.getItem()){
						//operazione avvenuta con successo
						OUT_TO_CLIENT.write(1);
					}else{
						OUT_TO_CLIENT.write(0);
					}
				}
				System.out.println("There are "+this.WH.countItems()+" items");
				//sleep(5000);
			}
		}catch(Exception e){}
	}	
}

public class Warehouse {
	
	private static int ITEMS=0;
	private final static int MAX_ITEMS=10;
	private boolean SUCCESS=false;
	
	public synchronized boolean addItem(){
		
		this.SUCCESS=false;
		if (ITEMS<MAX_ITEMS){
			ITEMS++;
			this.SUCCESS=true;
		}
		return this.SUCCESS;
	}
	public synchronized boolean getItem(){
		
		this.SUCCESS=false;
		if (ITEMS>0){
			ITEMS--;
			this.SUCCESS=true;
		}
		return this.SUCCESS;
	}
	
	public int countItems(){

		return ITEMS;
	}
}

import java.io.*;
import java.net.*;

public class Consumer {
	
	static Socket SERVICE=null;
	
	static OutputStream OUT_TO_CLIENT=null;
	static InputStream IN_FROM_CLIENT=null;

	public static void main(String ARGS[]) throws Exception{
		
		SERVICE=new Socket ("localhost",4444);
		System.out.println("Connected to Server...starting production");
		
		while(true){
			OUT_TO_CLIENT=SERVICE.getOutputStream();
			//invio al server 1 che significa "consuma"
			OUT_TO_CLIENT.write(1);
			
			IN_FROM_CLIENT=SERVICE.getInputStream();
			if(IN_FROM_CLIENT.read()==1){
				System.out.println("One item consumed");
			}else{
				System.out.println("No more items to consume!");
			}
		}
	}
	
}

import java.io.*;
import java.net.*;

public class Producer {
	
	static Socket SERVICE=null;
	
	static OutputStream OUT_TO_CLIENT=null;
	static InputStream IN_FROM_CLIENT=null;

	public static void main(String ARGS[]) throws Exception{
		
		SERVICE=new Socket ("localhost",4444);
		System.out.println("Connected to Server...starting production");
		
		while(true){
			OUT_TO_CLIENT=SERVICE.getOutputStream();
			//invio al server 0 che significa "produci"
			OUT_TO_CLIENT.write(0);
			
			IN_FROM_CLIENT=SERVICE.getInputStream();
			if(IN_FROM_CLIENT.read()==1){
				System.out.println("One item produced");
			}else{
				System.out.println("Production stopped, limit reached!");
			}
		}
	}
}

le classi consumer e producer sono praticamente identiche fatta eccezione per l'azione che compiono...

---

Posted by citrus on 15-10-2004 23:44:

ciao Roberto...
bel lavoro!
io avevo pensato di usare uno stack (o magari un array di modo da creare un buffer limitato) di oggetti generici cmq praticamente è la stessa identica cosa...
l'uinca cosa è che praticamente è un "finto" produttore/consumatore perchè praticamente i consumatori veri e propri non risiedono in remoto ma in locale...
la simulazione è data dal fatto che per consumare devono attendere l'ordine del client che effettivamente è in remoto....
l'ideale sarebbe dare accesso ai metodi del cassetto ai client in remoto ma per quanto ne so io in java non si posso richiamre metodi da remoto con le socket...
bisogna usare il famoso RMI (remote method invocation)...
che sarebbe l'RPC di java....
dico bene?

ciauuuz
citrus

---

Posted by futurbaggio on 16-10-2004 08:39:

Originally posted by citrus

bisogna usare il famoso RMI (remote method invocation)...
che sarebbe l'RPC di java....
dico bene?

RMI non c'è stato spiegato e quindi non va usato... non so nemmeno se rientra nel programma del corso.
Cmq se vedi il mio codice e quello di dagarlas ti rendi conto di come aggirare il problema, in particolare io creo un thread per ciascun client che si connette e faccio inviare al server una quantità da consumare... chi effettivamente richiama il metodo consuma() dell'oggetto Cassetto è il server stesso.
Personalmente non mi era molto chiaro cosa si dovesse fare di preciso, quindi io ho interpretato...

Roberto

__________________
E lo sceriffo americano non lo sa / ma quando parla ride tutta la città / vile fellone vieni a singolar tenzone / unza unza umpappà troppe truppe mariscià.
Non ci voleva l'eruzione della lava / e due piccioni si contendono la fava / sposa bagnata, bambina svergognata / la questione è delicata / come bolle la patata.
Basta! E' finita la festa
[L'ovile delle vanità, Folkabbestia]

---

Posted by papousek on 16-10-2004 13:34:

beh...ma voi siete matti...come diavolo fate a scrivere kilometri di codice???..purtroppo la mia preparazione di java nn è ai vostri livelli...spero che nn sia il solo...altrimenti per reti mi ci vorranno ancora 20 anni...fino ad arrivare al limite del prof per l'eta della pensione....

__________________
Break Out

---

Posted by futurbaggio on 16-10-2004 13:49:

...il prof aveva accennatto a lezioni di recupero su Java (in generale), dovrebbero essere utili a chi è un po' indietro con la programmazione... cmq stai tranquillo di gente del III anno con questi problemi ce ne è in abbondanza

Roberto

__________________
E lo sceriffo americano non lo sa / ma quando parla ride tutta la città / vile fellone vieni a singolar tenzone / unza unza umpappà troppe truppe mariscià.
Non ci voleva l'eruzione della lava / e due piccioni si contendono la fava / sposa bagnata, bambina svergognata / la questione è delicata / come bolle la patata.
Basta! E' finita la festa
[L'ovile delle vanità, Folkabbestia]

---

Posted by citrus on 16-10-2004 14:09:

non avevo nemmeno visto il post di darglass.....

---

Posted by badPenguin on 16-10-2004 15:31:

Ragazzi tranquilli!!!! Aiuto non fate crescere questo thread kilometri di codice vi prego!!!!

Allora io ho pensato in questo modo:

I thread consumatore e produttore sono in esecuzione sulla macchina Server.

La macchina client visualizza solamente in output il risultato dell'esecuzione sincronizzata della macchina server.

Ho visto qualcuno che parlava di RMI, è giustissimo (con questa tecnica gestiamo la sincronizzazione distribuita, ma in questo corso la sincronizzazione va verificata solo sulla macchina server).

Pensavo di presentarvi qualcosa di RMI (fuori programma d'esame) a fine corso per vedere qualcosa.

Dovrei postare il codice sul mio sito, ma preferivo spiegarvi la mia soluzione a lezione.. Fatemi sapere voi se volete vedere il codice o volete aspettare che ve lo spiego a lezione..

Saluti..

Eugenio Cassiano.

---

Posted by futurbaggio on 16-10-2004 15:43:

Originally posted by badPenguin
Fatemi sapere voi se volete vedere il codice o volete aspettare che ve lo spiego a lezione..

Io voto per la presentazione a lezione così anche chi non legge spesso sul forum può avvantaggiarsi della tua spiegazione...

Roberto

__________________
E lo sceriffo americano non lo sa / ma quando parla ride tutta la città / vile fellone vieni a singolar tenzone / unza unza umpappà troppe truppe mariscià.
Non ci voleva l'eruzione della lava / e due piccioni si contendono la fava / sposa bagnata, bambina svergognata / la questione è delicata / come bolle la patata.
Basta! E' finita la festa
[L'ovile delle vanità, Folkabbestia]

---

Posted by mayetta on 16-10-2004 16:01:

Originally posted by futurbaggio
Io voto per la presentazione a lezione così anche chi non legge spesso sul forum può avvantaggiarsi della tua spiegazione...

---

Posted by GinoPilotino on 16-10-2004 17:22:

concordo pienamente con futurbaggio e mayetta

---

Posted by Dodo on 16-10-2004 19:45:

io preferirei, se possibile, vedere già il codice in modo da averlo già stampato alla spiegazione, e poter aggiungere eventuali appunti

__________________
E' meglio essere ottimisti ed avere torto piuttosto che pessimisti ed avere ragione.

Albert Einstein

---

Posted by yeah on 16-10-2004 20:51:

A questo punto perchè non optare per entrambe le possibilità?
Messa a disposizione del codice sul sito (appena possibile) e spiegazione a lezione

__________________
?

---

Posted by GinoPilotino on 16-10-2004 23:11:

in effetti così facendo sarebbe il massimo!

---

Posted by Dodo on 17-10-2004 14:14:

Originally posted by yeah
A questo punto perchè non optare per entrambe le possibilità?
Messa a disposizione del codice sul sito (appena possibile) e spiegazione a lezione

infatti io intedevo questo, e penso pure badPenguin.....

__________________
E' meglio essere ottimisti ed avere torto piuttosto che pessimisti ed avere ragione.

Albert Einstein

---

Powered by: vBulletin Version 2.3.1
Copyright © Jelsoft Enterprises Limited 2000 - 2002.