Java/Thread: diferenças entre revisões
[edição verificada] | [edição verificada] |
Linha 45: | Linha 45: | ||
Já que <code>Runnable</code> é uma interface funcional, é possível reescrever o código acima da seguinte forma. |
Já que <code>Runnable</code> é uma interface funcional, é possível reescrever o código acima da seguinte forma. |
||
<source lang="Java" |
<source lang="Java" > |
||
Runnable runnable = () -> System.out.println(Thread.currentThread()); |
Runnable runnable = () -> System.out.println(Thread.currentThread()); |
||
</source> |
</source> |
||
Uma vez que a classe <code>Thread</code> implementa <code>Runnable</code>, alternativamente é possível estender <code>Thread</code> e inserir o código em uma sobreescrita do método < |
Uma vez que a classe <code>Thread</code> implementa <code>Runnable</code>, alternativamente é possível estender <code>Thread</code> e inserir o código em uma sobreescrita do método <code>void run()</code>. |
||
<source lang="Java" highlight="1,4"> |
<source lang="Java" highlight="1,4"> |
||
class LinhaDeExecucao extends Thread { |
class LinhaDeExecucao extends Thread { |
||
Linha 59: | Linha 59: | ||
} |
} |
||
</source> |
</source> |
||
===Instanciando a classe Thread=== |
===Instanciando a classe Thread=== |
Revisão das 14h52min de 28 de julho de 2016
Cada objeto gerado pela classe java.lang.Thread
cria uma thread. Também conhecida em línguas lusófonas como linha de execução.
Cada uma dessas linhas de execução podem ser executadas em paralelo, possibilitando à aplicação a execução de instruções relativamente simultâneas.
A thread main
Toda aplicação tem ao menos uma thread, não-daemon, em tempo de execução: a thread main
.
A thread main
, criada automaticamente pela JVM quando uma aplicação é iniciada, é responsável por executar o código inicial da aplicação (comumente inserido no corpo do método public static void main(String... args)
).
public static void main(String... args) {
Thread t = Thread.currentThread();
String nome = t.getName();
long id = t.getId();
System.out.println("Nome: " + nome + ", id: " + id);
}
Nome: main, id: 1
Thread Thread.currentThread()
devolve uma referência do objeto Thread
correspondente à thread que executa a chamada desse método. No código acima, foi devolvida uma referência à thread main
.
String getName()
foi utilizado para obter o nome da thread, complementarmente há o método void setName(String)
que altera o nome da thread.
long getId()
devolve um long
automaticamente atribuído quando a thread é criada. Esse valor é único e não é reutilizado quando a thread morre.
Criando threads
Para criar sua própria thread por meio da classe Thread
, é preciso realizar 3 etapas:
- Definir o código a ser executado pela thread;
- Referenciar esse código em uma instância de
Thread
e; - Chamar o método
void start()
dessa classe.
Definindo o código
O código que será executado por uma thread deve ser definido no método void run()
da interface java.lang.Runnable
.
class Executavel implements Runnable {
@Override
public void run() {
System.out.println(Thread.currentThread());
}
}
Já que Runnable
é uma interface funcional, é possível reescrever o código acima da seguinte forma.
Runnable runnable = () -> System.out.println(Thread.currentThread());
Uma vez que a classe Thread
implementa Runnable
, alternativamente é possível estender Thread
e inserir o código em uma sobreescrita do método void run()
.
class LinhaDeExecucao extends Thread {
@Override
public void run() {
System.out.println(Thread.currentThread());
}
}
Instanciando a classe Thread
class EstudandoThreads {
public static void main(String[] args) {
Runnable runnable = () -> System.out.println(Thread.currentThread());
Thread thread = new Thread(runnable);
}
}
Executando a thread
class EstudandoThreads {
public static void main(String[] args) {
Runnable runnable = () -> System.out.println(Thread.currentThread());
Thread thread = new Thread(runnable);
thread.start();
}
}
Thread[Thread-0,5,main]
String name
especifica um nome para a thread. Caso não especificado no construtor o nome da thread será criado automaticamente derivado do modelo Thread-0, onde 0 é um número incrementado a cada nova thread criada sem definição de nome.
Evite ThreadGroup
java.lang.ThreadGroup group
inclui a thread em um grupo de threads. A utilização de ThreadGroup
deve ser evitada[1].
Então evite os seguintes construtores da classe Thread
.
Thread(ThreadGroup group, Runnable target)
Thread(ThreadGroup group, Runnable target, String name)
Thread(ThreadGroup group, String name)
Métodos estáticos
activeCount()
currentThread()
dumpStack()
enumerate(Thread[] tarray)
getAllStackTraces()
getDefaultUncaughtExceptionHandler()
holdsLock(Object obj)
interrupted()
setDefaultUncaughtExceptionHandler(Thread.UncaughtExceptionHandler eh)
sleep(long millis)
sleep(long millis, int nanos)
yield()
Métodos de instância
checkAccess()
countStackFrames()
getContextClassLoader()
getId()
getName()
getPriority()
getState()
getThreadGroup()
getUncaughtExceptionHandler()
interrupt()
isAlive()
isDaemon()
isInterrupted()
join()
join(long millis)
join(long millis, int nanos)
run()
setContextClassLoader(ClassLoader cl)
setDaemon(boolean on)
setName(String name)
setPriority(int newPriority)
setUncaughtExceptionHandler(Thread.UncaughtExceptionHandler eh)
start()
- ↑ Item 73 - JOSHUA, Bloch. Effective Java. 2.ª edição, 2009.