[ESERCIZIO] - Produttore/Consumatore in rete
Clicca QUI per vedere il messaggio nel forum |
| futurbaggio |
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) { }
}
}
Roberto |
| dagarlas |
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... |
| citrus |
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 |
| futurbaggio |
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 |
| papousek |
| 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.... |
| futurbaggio |
...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 :evil:
Roberto |
| citrus |
non avevo nemmeno visto il post di darglass.....
:eek: |
| badPenguin |
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. |
| futurbaggio |
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 |
| mayetta |
Originally posted by futurbaggio
Io voto per la presentazione a lezione così anche chi non legge spesso sul forum può avvantaggiarsi della tua spiegazione...
:approved: |
| GinoPilotino |
| concordo pienamente con futurbaggio e mayetta :) |
| Dodo |
| io preferirei, se possibile, vedere già il codice in modo da averlo già stampato alla spiegazione, e poter aggiungere eventuali appunti |
| yeah |
A questo punto perchè non optare per entrambe le possibilità?
Messa a disposizione del codice sul sito (appena possibile) e spiegazione a lezione :) |
| GinoPilotino |
| in effetti così facendo sarebbe il massimo! |
| Dodo |
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..... :pensa: |
| gfp |
> RMI non c'è stato spiegato e quindi non va usato...
> non so nemmeno se rientra nel programma del corso.
Non ho la minima intenzione di parlare di RMI in un corso
propedeutico come Reti+Lab, se non - forse - per dire che
c'è e - a grandi linee - che fa. Ma in ogni caso non come
strumento in cui farvi sviluppare alcunché.
Invito tutti a evitare di fuorviare i comuni mortali con
post/commenti da "primo della classe". Caso mai, potete
istituire un thread (nel senso DSY, non Java) dal titolo
"primi della classe". Mi impegno formalmente a non
visitarlo mai.
I "primi della classe" in sede di esame potranno fare tutto
lo sfoggio di conoscenze che vorranno. Da parte mia mi
riserverò di adottare criteri di valutazione adeguati alla
loro smisurata cultura... ;-) |
|
|
|
