Java Threads - IME-USP

Java Threads
Definição por herança
class Ordenador extends Thread {
List l;
public Ordenador(List l) { this.l = l; }
public void run() { Collections.sort(l); }
}
Thread meuOrdenador = new Ordenador(list);
meuOrdenador.start();
Definição por delegação
class Ordenador implements Runnable {
List l;
public Ordenador(List l) { this.l = l; }
public void run() { Collections.sort(l); }
}
Thread t = new Thread(new Ordenador(list));
t.start();
ou
Thread t = new Thread(new Runnable()
{public void run() {Collections.sort(list);}});
t.start();
Prioridades

A ordem de execução das threads segue a ordem
de prioridades das mesmas

MIN_PRIORITY = 1
MAX_PRIORITY = 10
NORM_PRIORITY = 5

Uma thread é criada com a mesma prioridade da
thread mãe
Criando uma thread com prioridade inferior:
t.setPriority(Thread.currentThread().getPriority() -1);

Escalonamento - 1

Threads educadas:
Thread t = new Thread (new Runnable {
public void run() {
for(int i =0; i<data.length; i++){
processa(data[i]);
if ((i%10) == 0) Thread.yield();
}
}
}
Escalonamento - 2

Threads programadas:
public class Clock extends Thread {
java.text.DateFormat f =
java.text.DateFormat.getTimeInstance(java.text.DateFormat.MEDIUM);
boolean continueRodando = true;
public void run() {
while (continueRodando) {
String time = f.format ( new java.uti..Date() );
System.out.println (time);
try { Thread.sleep(1000); }
catch (InterruptedException e) {} }}
public void pare() { continueRodando = false; }
}
//stop deprecated
Threads interdependentes
...
Thread meuOrdenador = new Ordenador(list);
meuOrdenador.setPriority(Thread.currentThread.getPriority() -1);
meuOrdenador.start();
byte[] dados = leDados();
meuOrdenador.join();
...
Sincronização



Em uma aplicação multithread há o perigo de duas
ou mais threads acessarem a mesma estrutura de
dados.
Para evitar essa situação, podemos fazer uso do lock
que todo objeto Java possui.
Definindo métodos como sinchronized, uma thread
só pode executar esses métodos se tiver o lock do
objeto.
Sincronização

Para uma sincronização mais fina, pode-se
sincronizar apenas um trecho de código:
public void swap(Object[] array, int indice1, indice2){
synchronized (array) {
Object aux = array[indice1];
array[indice1] = array[indice2];
array[indice2] = aux;
}
}
Deadlock
Thread t1 = new Thread (new Runnable() {
public void run() {
synchronized(recurso1) {
synchronized(recurso2) { processa(); }}}};
Thread t2 = new Thread (new Runnable() {
public void run() {
synchronized(recurso2) {
synchronized(recurso1) { processa(); }}}};
t1.start();
t2.start();
Sincronização por dependência
Class LinhaDeProducao {
LinkedList esteira = new LinkedList();
public synchronized Object consome (Object o) {
while (esteira.size() == 0)
try { this.wait (); } catch (InterruptedException e) {} }
return esteira.remove(0);
}
public synchronized void produz(Object o) {
esteira.add(o);
this.notify();
}
}
ThreadGroup




Pode não ser desejável que todas as threads tenham
controle sobre as outras.
Threads podem ser organizadas em grupos de
segurança, onde podem ter acesso entre si.
Estes grupos podem ser organizados sob uma
hierarquia (grupos dentro de grupos). Assim as
threads de um grupo têm acesso também as threads
dos sub-grupos.
O ThreadGroup de uma thread é definido no
momento de sua criação. O default é ser criada no
mesmo ThreadGroup da thread mãe.
ThreadGroup - alguns métodos









ThreadGroup (String name)
ThreadGroup (ThreadGroup parent, String name)
String getName()
ThreadGroup getParent()
void setMaxPriority()
int getMaxPriority()
boolean parentOf(ThreadGroup g)
void checkAccess() throws SecurityException
void destroy()
Thread - outros métodos







ThreadGroup getThreadGroup()
void notifyAll()
void suspend()
void resume()
boolean isAlive()
int activeCount()
String toString()