Thread: definizione

Un thread (di controllo) è una lista di istruzioni eseguite sequenzialmente da un programma. I thread di un programma condividono uno stesso spazio di indirizzamento. Pur avendo stack e variabili locali separate, condividono le variabili globali. I thread sono "leggeri", nel senso che la creazione, distruzione e sincronizzazione sono relativamente economiche grazie alla condivisione dello spazio di indirizzamento. Le ragioni per organizzare un programma in un certo numero di thread possono essere molteplici:

I/O non bloccante

Una delle motivazioni forti per la programmazione concorrente mediante thread è l'ottenimento di servizi non bloccanti per Input/Output. Quando l'applicazione ha necessità di effettuare un I/O, è opportuno che non si blocchi, in modo da consentire che altre operazioni non dipendenti da quell'I/O possano essere effettuate. Una tecnica di gestione dell'I/O non bloccante, utilizzata ad esempio nei microcontrollori usati nelle board per il physical computing, è il polling, cioè la verifica ciclica dell'accadimento di eventi su un insieme di dispositivi di input. La ciclicità del polling è gestita da un timer. L'I/O non bloccante si può realizzare mediante i thread. La lettura di un certo dispositivo si può assegnare ad un certo thread il quale si blocca in attesa dei dati. Gli altri thread, che non dipendono dalla lettura del dato, possono però procedere in maniera concorrente.

Diagrammi di attivazione

Il codice Processing seguente invoca il metodo stampa() sull'oggetto cl della classe Classe1.

class Classe1 {
 void stampa() {
   for (int i=0; i< 100; i++) println("yep");
 } 
}

void setup() {
 Classe1 cl = new Classe1();
 cl.stampa(); 
}

	

Figura 1: Diagramma di attivazione a thread singolo

class Classe2 extends Thread{
 void run() {
   for (int i=0; i< 100; i++) println("yep");
 } 
}

void setup() {
 Classe2 cl = new Classe2();
 cl.start(); 
}

	

Figura 2: Diagramma di attivazione a doppio thread

Thread: utilizzazione

class TimerThread extends Thread{
  int timediff; // quanto temporale
  color col;  
  
  TimerThread(color c, int td) {
   timediff = td;
   col = c;
  }
  
 void run() {
   while(true) {
     fill(col);
     try {
       ellipse(int(random(100)), int(random(100)), 
         int(random(20)), int(random(20)));  
       sleep(timediff);
     } catch (Exception e) {println("Exception in sleep");}
   }
 } 
}

void setup() {
 TimerThread tt1 = new TimerThread(color(120,120,0),1000);
 TimerThread tt2 = new TimerThread(color(0,120,120),1300);
 tt1.start(); 
 tt2.start();
}

void draw() {
}


	

I/O non bloccante basato su thread

Quando l'oggetto interattivo ha bisogno di leggere o scrivere da/su file, dispositivi, o network socket, è opportuno che essa non si blocchi completamente in attesa dei dati. Con i thread, ciò viene risolto elegantemente attivando un thread separato che gestisce I/O asincrono, e si blocca laddove è necessario.

StringBuffer stdin;
boolean linea;
color colore;

void keyReleased() {
  char c = key;
  if (c!='\n') {
    stdin.append(c);
  }
  else linea=true;
}

class ColorInput extends Thread {
  String results;
  char c;
 
  void run()  {
     while(true) {
       if (linea) {
            println(stdin);
            results=stdin.toString();
            stdin.setLength(0);	    
            linea = false;
            if (results.equals("rosso")) {
                colore = color(255, 0, 0);
            }
             if (results.equals("verde")) {
                colore = color(0, 255, 0);
            }
            if (results.equals("blu")) {
                colore = color(0, 0, 255);
            }          
          }
         try {
         sleep(5); // to relief the cpu from active waiting
         } catch (Exception e) {println("Exception in sleep");} 
        }
    }
  }

class TimerThread extends Thread{
  int timediff; // quanto temporale
  
  TimerThread(int td) {
   timediff = td;
  }
  
 void run() {
   while(true) {
     try {   
       fill(colore);
       ellipse(int(random(100)), int(random(100)), 
         int(random(20)), int(random(20)));  
       sleep(timediff);
     } catch (Exception e) {println("Exception in sleep");}
   }
 } 
}

void setup() {
 stdin = new StringBuffer();
 TimerThread tt1 = new TimerThread(100);
 ColorInput ci = new ColorInput();
 ci.start();
 tt1.start(); 
}

void draw() {
}


	  

try {
   BufferedReader stdiin = createReader("nomefile");
   println(stdiin.readLine());
 }catch(Exception e){}
	  

try {
   FileReader is = new FileReader("nomefile");
   BufferedReader stdiin = new BufferedReader( is );
   println(stdiin.readLine());
 }catch(Exception e){}
	  

class sentenceReader extends Thread{
  int timediff; // quanto temporale
  
  sentenceReader(int td) {
   timediff = td;
  }
  
 void run() {
    while(true) {
      try {
       BufferedReader stdiin = createReader("http://www.essl.at/cgi-bin/swrap/cgis/lexikon-orakel.pl");
       for (int i=0; i<13; i++) stdiin.readLine();
       println(stdiin.readLine());
       sleep(timediff);
      }catch(Exception e){}
    }
  }
}

void setup() {
 sentenceReader st = new sentenceReader(2000);
 st.start();
}

void draw() {
}


	    

Sincronizzazione

Si supponga di dover estendere la lettura di comandi da tastiera con due thread che prendono comandi da stdin. I comandi possono essere consumati dall'uno o dall'altro dei thread, ma uno stesso comando non può essere consumato da entrambi. In questo caso si possono presentare problemi di race condition, cioè configurazioni di codice concorrente che danno luogo a risultati dipendenti dalla sequenza di scheduling attribuita ai vari thread. In particolare, la sezione critica

	    results=stdin.toString();            
            stdin.setLength(0);
            linea = false;
	

class IO extends Thread {
 String results;

 synchronized  String acquire() {
   results=stdin.toString();
   linea = false;
   stdin.setLength(0);
   return(results);
 }
}

	

Reference

Il capitolo 9 del libro Visualizing Data -- Ben Fry; O'Really 2007 fornisce esempi di acquisizione asincrona di dati da file e da siti remoti, con l'utilizzazione di thread e di sincronizzazione.