Ho rifatto il tutto con un po' piu' di buon senso.
Allego il testo originale del prof. :
1. Definire la classe SortedLinkedList che estende la classe LinkedList e che mantiene ordinata la lista:
ridefinire il metodo add() affinché inserisca gli elementi in ordine.
Gli oggetti da inserire devono essere confrontabili e quindi devono implementare l’interfaccia Comparable.
Si ordini la lista in modo che il valore massimo sia in testa (first) e il valore minimo in coda (last).
Verificare la correttezza dell’implementazione: per esempio usando sequenze di stringhe in ordine, in ordine inverso,
casuali, uguali. Verificare con sequenze di 21 elementi Integer casuali, con valori compresi nell’intervallo [-30,30].
2. Sviluppare una classe Process che descriva un processo. Definire tre campi: un intero che
identifica il processo (pid), una stringa per il nome del processo e un intero per
l’occupazione di memoria. Definire il costruttore della classe e il metodo toString().
Implementare l’interfaccia Comparable: il confronto è fatto sulla memoria utilizzata.
3. Scrivere una classe (che contiene il main()) in cui creare un oggetto di tipo
SortedLinkedList, lista di oggetti Process. La sequenza di processi -in ingresso al sistema- è contenuta nel
file processes.txt: ogni riga contiene i dati di un processo, cioè il pid, il nome e la memoria occupata.
Eseguire le seguenti operazioni:
- Leggere una riga del file ed inserire il processo nella lista.
- Se la quantità di memoria utilizzata da tutti i processi supera un valore di soglia
(100000) eliminare dalla lista il processo che in quel momento occupa più memoria
(utilizzare gli iteratori, oggetti Iterator).
- Salvare su file il numero di processi presenti nel sistema e la quantità di memoria
utilizzata da tutti i processi in ogni istante (-ad ogni lettura di una riga-).
Fare i grafici dell’occupazione di memoria e del numero di processi (in ogni istante).
Commentare.
Valutare il costo computazionale per mantenere la lista ordinata e per eliminare il processo che occupa più memoria.
per chiarezza allego anche la classe SortedLinkedList:
Codice:
Codice:
import java.util.*;
public class SortedLinkedList extends LinkedList
{
private static int elementi;
public static void main ( String []args )
{
if(args.length > 0)
elementi = Integer.parseInt(args[0]);
else
elementi = 21;
System.out.println( "Prova su " + elementi + "elementi." );
SortedLinkedList l = new SortedLinkedList();
// riempi la lista di numeri a caso tra -30 e +30
ListIterator it_aggiunta = l.listIterator();
Random generatore=new Random();
for ( int i = 0; i < elementi; i++ )
{
int segno=generatore.nextInt(2);// 0 o 1
int n=generatore.nextInt(31);
if(segno==0)
l.add(new Integer(- n ));
else
l.add(new Integer(n));
}
// stampa tutti i valori
System.out.println( "Collezione completa:" );
stampaCollezione( l );
}
private static void stampaCollezione
( Collection c )
{
Iterator i = c.iterator();
while ( i.hasNext() )
{
System.out.println( i.next() );
}
}
@Override
public boolean add(Object o){
Comparable c=(Comparable)o;//bisogna usare il cast a Comparable
ListIterator it=listIterator();
Comparable c2=null;
if(it.hasNext())
c2=(Comparable)it.next();
else{
it.add(c);
return true;
}
while(it.hasNext() && c2.compareTo(c)>0) //<0 x ordine crescente
c2=(Comparable)it.next();
//uscito dal while ho raggiunto la posizione di inserimento perchè il compareTo() non da più <0
//ora posso usare per inserire in questa posizione il metodo add di ListIterator ma bisognerebbe
//tornare indietro di una posizione per essere sicuri che l'inserimento sia in ordine se il compareTo() >0
if(c2.compareTo(c)<0)//>0 x ordine crescente
it.previous();
it.add(c);
return true;
}
} Questa e' la classe Processo con la classe EsProcesso col main
Codice:
import java.util.*;
import java.lang.*;
import java.io.*;
import javax.swing.JOptionPane;//utility pannello di dialogo
class Processo implements Comparable{
private int pid;
private String name;
private int memoria;
public Processo(int pid,String name,int mem){
this.pid=pid;
this.name=name;
memoria=mem;
}
public int compareTo(Object o){
Processo p=(Processo)o;
return this.memoria-p.memoria;//ordina in base alla quantità di memoria in ordine crescente
}
public String toString(){
return ""+pid+" "+name+" "+memoria;
}
public int GetMemoria(){
return this.memoria;
}
public void RemoveMaggiore(){
SortedLinkedList lista=new SortedLinkedList();
Iterator it1=lista.iterator();// in questa riga ho creato un nuovo
//l'oggetto iterator it1 che agisce sull'oggetto list di sortedlinkedlist (idem come sopra)
Processo p = (Processo) it1.next(); // ottengo il processo
memoria -= p.memoria; // aggiorno la memoria occupata
// rimuovo il processo dalla lista
}
}
public class EsProcesso{
public static void main(String[] args) throws IOException
{
//String nomeFile=JOptionPane.showInputDialog("Digita il nome del file da leggere");
//altro modo di input file diretto da codice
String nomeFile="processes.txt";
BufferedReader fileLettura=null;
SortedLinkedList lista=new SortedLinkedList();
try {
try{
fileLettura = new BufferedReader(new FileReader(nomeFile));
String linea=fileLettura.readLine();
while(linea!=null) {
String[] tmp=linea.split("\t");
Processo p=new Processo(Integer.parseInt(tmp[0]),tmp[1],Integer.parseInt(tmp[2]));
lista.add( p);
linea=fileLettura.readLine();//per far girare il ciclo
}
}finally{ fileLettura.close();}
}catch(FileNotFoundException e) {// gestisco le eccezioni
System.out.println("Il file "+nomeFile + " non esiste o non puo' essere aperto");
}catch(IOException e) {
System.out.println("errore di lettura "+e);
}
Iterator it=lista.iterator();
while(it.hasNext())
System.out.println((Processo)it.next());//cosi puoi vedere tutta la lista
// e stampare a video
}
Processo p1= new Processo();// creo nuovo oggetto Processo
// sembra che richieda di implementare il costruttore dell'oggetto
// ma non e' gia' istanziato come public nella classe processo?
// sembra che non riconosca i 2 metodi seguenti
while(p1.GetMemoria()>100000){ //che dovrebbe incrementare il metodo GetMemoria()
// rimuovi il processo che occupa più memoria
p1.RemoveMaggiore(); //che dovrebbe incrementare il metodo RemoveMaggiore()
}
}
Questo e' uno stralcio del file di testo processes.txt
1 init 272
2 migratio 0
3 ksoftirq 0
4 watchdog 0
5 migratio 0
6 ksoftirq 0
7 watchdog 0
8 events/0 0
9 events/1 0
10 khelper 0
11 kthread 0
14 kacpid 0
104 kblockd/ 0
105 kblockd/ 0
108 khubd 0
162 pdflush 0
163 pdflush 0
165 aio/0 0
164 kswapd0 0
166 aio/1 0
259 kseriod 0
417 ata/0 0
418 ata/1 0
424 scsi_eh_ 0
425 scsi_eh_ 0
446 kjournal 0
999 udevd 240
I primi 2 esercizi e parte del 3° li ho completati ma mi manca l'ultima parte ed ho problemi a richiamare i metodi GetMemoria() e RemoveMaggiore().
Scusate la lunghezza.
Saluti