THREAD THREAD
Il modo piu’ semplice per creare un thread e’ ereditare la classe Thread che contiene il metodo run(), il quale andra’ sovrascritto con il codice che verra’ eseguito contemporaneamente con gli altri eventuali thread.
ClassThread.start() = lancia il metodo run() del Thread.
Si puo’ impostare la propieta’dei vari thread con il metodo setProperty()
Se e’ presente sleep() (per ritardare l’esecuzione) bisogna catturare l’eccezione InterruptedException
Es.
Public void go() {
While(true) {
try {
Thread.currentThread().sleep(100);
} catch(InterruptedException e) { }
}
}
}
Esempio
//: TestThread.java
class Contatore extends Thread {
public int threadNum;
public int contNum = 0;
public Contatore(int threadNum) {
this.threadNum = threadNum;
}
public void run() {
while(true) {
System.out.println("Thread ("+threadNum+") = "+contNum);
contNum++;
if(contNum == 10) return;
}
}
}
public class TestThread {
public static void main(String args[]) {
Thread t1 = new Contatore(1);
Thread t2 = new Contatore(2);
t1.start();
t2.start();
}
}
Un Thread puo’ essere integrato nella classe principale con l’interfaccia Runnable.
Lanciando tale classe si crea un oggetto che e’ Runnable, e il Thread dovra’ essere lanciato esplicitamente.
Es.
Publi class myThreadClass implements Runnable {
….
thread myThread = new myThreadClass();
myThread.start();
Il metodo start crea le risorse di sistema necessarie, schedula il thread e chiama i metodi run del thread
Esempio:
//: TestRunnable.java
public class TestRunnable implements Runnable {
public int threadNum;
public int contNum = 0;
public TestRunnable(int threadNum) {
this.threadNum = threadNum;
}
public void run() {
while(true) {
System.out.println("Thread ("+threadNum+") = "+contNum);
contNum++;
if(contNum == 10) return;
}
}
public static void main(String args[]) {
Thread t1 = new Thread(new TestRunnable(1));
Thread t2 = new Thread(new TestRunnable(2));
t1.start();
t2.start();
}
}
Dopo che un thread e’ stato creato e inizializzato il sistema chiama il metodo run()
es loop per animazioni o operazioni che richiedono molto tempo come esecuzione di suoni o immagini)
il metodo run puo’ essere personalizzato in 2 modi:
1- facendo una sottoclasse della classe threads definita in java.lang e sovrascrivere il metodo run
2- fornire una classe che implementa l’interfaccia RUNNABLE (anchessa definita in java.lang.). L’oggetto runnable fornisce cosi’ il metodo run al thread
|
|newthread| ------ |
|runnable| |
-------|notrunnable| |
|
| |
||
|
|
|dead| |
|
newthreads
crea solamente un nuovo thread, non gli riserva risorse di sistemathread myThread = new MyThreadClass();
un thread in questo stato puo’ solamente essere avviato (start) o fermato (stop)
runnable
Un thread passa nello stato runnable quando viene chiamato il metodo start().
Es.
thread myThread = new myThreadClass();
myThread.start();
Il metodo start crea le risorse di sistema necessarie, schedula il thread e chiama i metodi run del thread
A questo punto il thread e’ considerato nello stato "runnable"
Un thread passa nello stato "notrunnable" quando si presenta uno dei seguenti eventi:
- viene invovato il metodo sleep o suspend
- il thread usa il metodo wait
dead un thread puo’ morire in 2 modi:
- per morte naturale (es alla fine di una serie di operazioni)
- rilasciandolo (es. myThread.stop());
IllegalTreadStateException
Si presenta quando viene chiamato un metodo di un thread il cui stato non e’ disponibile per quella chiamata
isAlive (metodo)
ritorna true se il thread e’ stato avviato e non stoppato, false se e’ un nuovo thread o e’ morto
Le propieta’ dei thread possono essere impostate/lette in qualsiasi momento tramite i metodo setPriority e getPriority (un intero compreso tra le costanti MIN_PRIORITY e MAX_PRIORITY definite nella classe thread)
In sistemi monoprocessore il thread con priorita’ maggiore puo’ occupare tutto il tempo di processore.
Sono utilizzati per semplificare operazioni che devono agire su piu’ Thread.
Ogni thread e’ membro di un gruppo anche se non esplicitamente dichiarato. Un gruppo di thread fornisce un meccanismo per collegare piu’ thread in un singolo oggetto e manipolare questi thread tutti insieme anziche’ individualmente
Dopo che un thread e’ stato creato non si puo’ spostarlo in un nuovo/diverso gruppo
- creando un thread senza specificare il gruppo viene inserito nel defaultthreadgroup che e’ chiamato in main
- Se si vuole inserire un thread in un gruppo che non sia quello di default va dichiarato il threadgroup esplicitamente quando viene creato il thread
i 3 costruttori della classe thread:
public thread (ThreadGroup group, Runnable target)
public thread (ThreadGroup group, String nome)
public thread (ThreadGroup group, Runnable target, String nome)
es ThreadGroup myThreadGroup = new ThreadGroup("My group of thread")
ThreadGroup myThreadGroup = new ThreadGroup("MyTreadGroup,, a thread for my group")
Per trovare in quale gruppo ub thread e’ inserito esiste il metodo getThreadGroup()
es. theGroup = myThread.getThreadGroup();
La classe ThreadGroup (gestisce gruppi di thread)
include i seguenti metodi:
- che operano sul gruppo
getMaxPriority, setMaxPriority
getDaemon, setDaemon
getName
getParent, parentOf
toString
- che operano su tutti i thread del gruppo
resume
stop
suspend
Quando un thread contiene tutti i dati e motodi per la sua esecuzione e’ chiamato asincrono
Quando invece piu’ thread condividono la stessa risorsa nasce il bisogno di sincronizzarli
Meccanismi per la sincronizzazione:
- Monitors (Il monitoraggio viene associato a una determianta variabile (es available) condivisa tra i 2 thread
Sincronozed – usato nei metodi per consentire un accesso alla volta da parte dei vari Thread (Es. syncronized void f() {/*……*/}
Daemon
I Thread daemon sono utilizzati per fornire un servizio un background.
Metodi:
isDaemon() = restituisce true se il Thread interrogato e’ daemon
setDaemon() = on/off – imposta un Thread daemon o meno