La classe Thread possiede un metodo sleep() che la mette in stato blocked per un certo numero di millisecondi. Ciò consente di programmare in maniera compatta e agevole flussi di eventi tra loro indipendenti. Ad esempio, il codice che segue produce il disegno di ellissi di due colori diversi, e ogni colore corrisponde ad un diverso intervallo di tempo (i.e., 1000 e 1300 millisecondi) tra due eventi successivi di disegno.

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() {
}


	

Si nota che il metodo sleep() di Java esige di essere invocato all'interno di un costrutto try catch(), cioè di una sezione di codice che consenta la cattura delle eccezioni. La gestione delle eccezioni consente di affrontare delle condizioni che alterano il normale flusso di esecuzione di un programma. Nell'esempio, la sleep() può fallire e sollevare (throw) una eccezione che, in questo caso, è gestita mediante la mera scrittura di una messaggio sulla console.

Si supponga di dover disegnare in maniera automatica e ripetuta delle ellissi nella finestra grafica, e di voler controllare gli attributi di tali ellissi mediante parole chiave immesse da tastiera. Conviene separare il compito di lettura e interpretazione (parsing) del flusso di caratteri che viene dalla tastiera dal compito di produzione dell'output grafico. Ciò si può realizzare come segue, nel caso semplice in cui le parole accettate siano "rosso", "verde", e "blu" corrispondenti a diverse colorature delle ellissi prodotte.

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() {
}


	  

Sono presenti, in questo caso, due diverse estensioni della classe Thread. La prima estensione fa una attesa attiva di linee di testo, impostando il colore ogniqualvolta viene rilevata una linea di testo contenente una delle tre parole chiave riconosciute. L'invocazione di sleep(5) rende questa attesa attiva meno onerosa per la CPU. L'altro thread, invece, si occupa di disegnare un'ellisse al secondo. In Processing è difficile realizzare un input bloccante da tastiera, in quanto non è accessibile direttamente lo stream System.in, sul quale in Java si può normalmente applicare lettura bufferizzata bloccante. Viceversa, Processing invita ad una programmazione event-based fornendo gli event handler keyReleased(), keyPressed(), e keyTyped(). E' possibile però fare un input bloccante di una linea da file di testo con un codice del tipo

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

dove createReader() è una funzione di Processing che crea un BufferedReader object da un file o da una URL. Essa consente una leggera semplificazione rispetto al codice Java

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

Per semplificare la lettura da file di testo, locali o remoti, Processing mette a disposizione la funzione loadStrings(), che carica tutte le linee di file di testo in un array di tipo String[]. Questo metodo può essere utile se il file non è troppo grande o dinamicamente variabile.