Threads e Estruturas de dados

public static void main(String[] args) throws
CloneNotSupportedException {
Objeto meuObjeto = new Objeto();
Objeto seuObjeto = meuObjeto;
System.out.println(meuObjeto);
// resultado: br.com.douglas.Objeto@56cbfb61
System.out.println(seuObjeto);
// resultado: br.com.douglas.Objeto@56cbfb61
Objeto objetoDele = meuObjeto.clone();
System.out.println(objetoDele);
// resultado: br.com.douglas.Objeto@1134affc
}
public class Objeto implements Cloneable {
// atributos e métodos
@Override
protected Objeto clone() throws CloneNotSupportedException
{
return (Objeto) super.clone();
}
}

Mutable
- É possível mudar os atributos e
estados depois que o objeto é
criado
// classe mutável
public class Pessoa {
// Campos imutáveis
private final String nome;
private final String cpf;
// Campo mutável
private EstadoCivil estadoCivil;
public Pessoa(String nome, String cpf) {
this.nome = nome;
this.cpf = cpf;
this.estadoCivil = EstadoCivil.SOLTEIRO;
}
public String getNome() { return nome; }
public String getCpf() { return cpf; }
public EstadoCivil getEstadoCivil() { return estadoCivil; }
public void setEstadoCivil(EstadoCivil estadoCivil) {
this.estadoCivil = estadoCivil;
}
}

Immutable
- Não se pode alterar os dados
depois de criado o objeto
- Objetos mais simples
- ThreadSafe
public final class Carta {
private final Integer valor;
private final Naipe naipe;
public Carta(Integer valor, Naipe naipe) {
this.valor = valor;
this.naipe = naipe;
}
public Integer getValor() {
return valor;
}
public Naipe getNaipe() {
return naipe;
}
}

Referências, em Java, se diferenciam por como o coletor de lixo lida com elas
1. Strong Reference (Padrão)
2. Weak Reference
3. Soft Reference
4. Phantom Reference

public static void main(String[] args) {
Carro c;
// 0 objetos criados
c = new Carro();
// 1 objeto criado
c.ano = 2014;
c.nome = "Brasilia";
c = new Carro();
// 2 objetos criados - 1 inacessível
if(5>3) {
Carro c2 = new Carro();
}
// 3 objetos criados - 2 inacessíveis
Carro c3;
for (int i = 0; i < 5; i++) {
c3 = new Carro();
}
// 8 objetos criados - 6 inacessíveis
}

Strong Reference
- Padrão
- Só é elegível para ser coletado
quando o objeto passa a apontar
para null
Clazz c = new Clazz();
// StrongReference - não elegível para coleta - Clazz@2c8d66b2
c = null;
// elegível para coleta

WeakReference
- Se a JVM detectar só
WeakReferences linkadas com o
objeto, ele será marcado como
elegível para coleta
- Deve ser criado usando
java.lang.ref.WeakReference
- Objeto pode ser recuperado usando
get()
// StrongReference - Clazz@2c8d66b2
WeakReference<Clazz> weakClazz = new
WeakReference<>(c);
c = null;
c = weakClazz.get();
// c agora aponta para o objeto anterior - Clazz@2c8d66b2
Stack Heap
Clazz@2c8d66b2
c
weakClazz

Soft Reference
- Uma referência do tipo Soft é
elegível para coleta, mas só é
coletado se a JVM precisar de mais
memória.
- Deve ser criado usando
java.lang.ref.SoftReference
// StrongReference - Clazz@2c8d66b2
SoftReference<Clazz> softClazz = new SoftReference<>(c);
c = null;
c = softClazz.get();
// c agora aponta para o objeto anterior - Clazz@2c8d66b2

Phantom Reference
- Não devolve referencias (get() é
sempre null)
- Necessário o uso de uma
ReferenceQueue para receber as
referências
- Um objeto será adicionado a queue
antes de ser removido da memória
public class ClazzFinalizer extends
PhantomReference<Clazz> {
public ClazzFinalizer(Clazz referent, ReferenceQueue<?
super Clazz> q) {
super(referent, q);
}
public void finalizeResources() {
// ação de limpar
System.out.println("Limpando ...");
}

ReferenceQueue<Clazz> queue = new
ReferenceQueue<>();
ClazzFinalizer finalizer = new ClazzFinalizer(c, queue);
System.out.println("Está na queue? " +
finalizer.isEnqueued());
c = null;
System.gc();
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("Está na queue agora? " +
finalizer.isEnqueued());
Reference<? extends Clazz> clazzFromQueue =
queue.poll();
((ClazzFinalizer)clazzFromQueue).finalizeResources();
}

Exception x Error
Thowable
Exception Error
RuntimeException
NullPointerException IllegalStateException
VitualMachineError
StackOverflowError
IOException
SQLException

main
metodo1
metodo2
metodo3
metodo1();
}
public void metodo1() { metodo2() }
public void metodo2() { metodo3() }
main
metodo1
metodo2

Try-Catch
- Tenta executar um bloco de código
e captura a exceção, caso seja
lançada
- Pode conter um bloco finally para
ser executado ao final,
independente do lançamento da
exceção

Checked x Unchecked
Sincronizado
(ThreadSafe)
Vector
● Não é obrigado fazer
tratamento
● Erros mais simples de serem
evitados
● Herdam de RuntimeException
Verificadas pelo compilador
Checked
● Tratamento obrigatório
● Erros dificeis de serem
evitados
● Herdam diretamente de
Exception
Não são verificadas pelo
compilador
Unchecked

int x = 0;
int y = 15;
int resultado = y/x;
}
try(Banco banco = new Banco()) {
System.out.println(banco);
} catch (Exception e) {
}
}
Banco banco = null;
try {
banco = new Banco();
System.out.println(banco);
} finally {
banco.close();
}
CHECKED UNCHECKED

- Uma unidade de execução em um
processo (programa)
- Permite rodar duas ou mais tarefas
ao mesmo tempo
- Podem ser executados de forma
concorrente ou paralela
Processo
Thread
Processo
Thread
Thread
Thread

Concorrente x Paralelo
#1
#2
#1
#2
#1
#1 #2

Caracteristicas
- Não possui ordem de execução
- Cada thread possui seu próprio
contador de programa, pilha e
variáveis locais
- Compartilha a memória do processo
em que está sendo executado

public class ServidorTarefas {
private final ServerSocket servidor;
private final ExecutorService threadPool;
private AtomicBoolean estaRodando;
private BlockingQueue<String> filaDeComandos;
/** Constructor */
public ServidorTarefas() throws IOException {
System.out.println(" ---- Iniciando servidor ---- ");
servidor = new ServerSocket(12345);
threadPool =
Executors.newCachedThreadPool(new
FabricaDeThreads());
this.estaRodando = new AtomicBoolean(true);
this.filaDeComandos = new
ArrayBlockingQueue<>(2);
incializarConsumidores(2);
}
public static void main(String[] args) throws
IOException {
ServidorTarefas servidor = new ServidorTarefas();
servidor.rodar();
servidor.desliga();
}
public void desliga() throws IOException {
this.estaRodando.set(false);
servidor.close();
threadPool.shutdown();
}
public void rodar() throws IOException {
while(estaRodando.get()) {
try {
Socket socket = servidor.accept();
System.out.println("Aceitando novo cliente na porta " +
socket.getPort());
DistribuirTarefas distribuirTarefas = new
DistribuirTarefas(threadPool, filaDeComandos, socket, this);
threadPool.execute(distribuirTarefas);
} catch (SocketException e) {
System.out.println("O servidor desligará depois que todos os
clientes desconectarem.");
}
}
}
private void incializarConsumidores(int numConsumidores) {
for (int i = 0; i < numConsumidores; i++) {
TarefaConsumir tarefa = new TarefaConsumir(filaDeComandos);
this.threadPool.execute(tarefa);
}
}

public class ClienteTarefas {
public static void main(String[] args) throws Exception {
Socket socket = criaConexao();
PrintStream saida = new
PrintStream(socket.getOutputStream());
// ***** Execução das threads *****
Thread threadDeSaida = criaThreadDeSaida(socket, saida);
threadDeSaida.start();
criaEExecutaThreadDeEntrada(socket);
threadDeSaida.join();
socket.close();
}
private static Socket criaConexao() throws IOException {
Socket socket = new Socket("localhost",12345);
System.out.println("Conexão estabelecida n Pode enviar
comandos!");
return socket;
}
private static Thread criaThreadDeSaida(Socket socket,
PrintStream saida) {
return new Thread(() -> executaComandosNoServidor(socket,
saida), "ThreadDeSaida");
}
private static void imprimeRespostaDoServidor(Socket socket) {
try {
Scanner respostaServidor = new
Scanner(socket.getInputStream());
while(respostaServidor.hasNextLine()){
System.out.println(respostaServidor.nextLine());
}
System.out.println("IOException: " + e.getMessage());
}
}

private static void executaComandosNoServidor(Socket socket, PrintStream saida) {
pegaInputEPrinta(saida);
saida.println("Encerrando o cliente " + socket);
saida.close();
}
private static void pegaInputEPrinta(PrintStream saida) {
Scanner teclado = new Scanner(System.in);
while(teclado.hasNextLine()) {
String linha = teclado.nextLine();
if (ehComandoVazio(linha)) break;
saida.println(linha);
}
}
private static boolean ehComandoVazio(String linha) {
return (linha.trim().equals(""));
}
private static void criaEExecutaThreadDeEntrada(Socket socket) {
Thread threadEntrada = new Thread(() -> imprimeRespostaDoServidor(socket), "ThreadDeEntrada");
threadEntrada.start();
}

Synchronized
- Permite controlar o fluxo (só uma
thread tem acesso ao método)
- Se uma segunda thread tenta
acessar o método, terá que esperar
que a primeira termine
public synchronized void remove() {
// executa remoção de alguma coisa
}
synchronized (this) {
// faz alguma coisa
}

Semaphore
- Permite controlar o acesso a algum
recurso através de um contador
- Podemos determinar quantos locks
queremos disponibilizar
- Se todos os locks estão ocupados, a
thread é bloqueada e espera a
liberação de algum lock
- Após a execução da thread, o lock é
liberado para a próxima thread
public class TesteSemaphore {
Semaphore semaphore = new Semaphore(3);
public void run() {
try {
System.out.println("Adquirindo lock");
System.out.println("Permits restantes: " +
semaphore.availablePermits());
semaphore.acquire();
System.out.println("Permit adquirido");
try {
// Fazendo alguma coisa complexa
// e capturando a exceção que possa ser
lançada
} finally {
System.out.println("Liberando lock ...");
semaphore.release();
System.out.println("Permits disponíveis: " +
semaphore.availablePermits());
} catch (InterruptedException e) {
System.out.println("Deu ruim");
}
}

Array (Vetor)
- Declaração de Arrays:
“Uma coleção sequencial, de tamanho fixo, que guarda elementos do mesmo tipo”
int[] numeros = new int[10]; -> Cria um array de 10 inteiros
LoremIpsum
15
7
9
23
4
35
0
8
42
18
LoremIpsum
0
0
0
0
0
0
0
0
0
0
numeros[0] = 42;
numeros[1] = 18;
numeros[2] = 4;
numeros[3] = 35;
numeros[4] = 0;
numeros[5] = 8;
numeros[6] = 15;
numeros[7] = 7;
numeros[8] = 9;
numeros[9] = 23;

Implementações de List:
1. ArrayList
2. Vector
1. Stack
3. LinkedList:
1. SinglyLinkedList (SLL)
2. DoublyLinkedList(DLL)
Listas (java.util.List)
“Uma sequencia ordenada de objetos”

ArrayList - Vector
- Recebe itens repetidos
- Usa um Array para organizar e armazenar os dados
- Consultas rápidas mas inserções/remoções lentas
- Aumenta e diminui dinamicamente para manter a otimização de dados

Sincronizado
(ThreadSafe)
Vector
● Dobra o tamanho da lista caso
todos os espaços sejam
preenchidos
● + Lento
● JDK 1.0
Não sincronizado
(ThreadUnsafe)
ArrayList
● Aumenta 50% do tamanho da
lista caso todos os espaços
sejam preenchidos
● + Rápido
● JDK 1.2
Sincronizado
(ThreadSafe)
Vector

Stack (Pilha)
- LIFO (Last-in-First-Out)
- Não é possível adicionar ou remover a partir de um index
- Sempre recebemos o ultimo item adicionado

#1
#2
#3
#4
#5
push(E e)
#1
#2
#3
#4
pop()
#5
#1
#2
#3
#4
peek()
#4

Queue(Interface)
- FIFO (First-in-First-Out)
- Não é possível adicionar/remover a partir de um index
- Sempre recebemos o primeiro item adicionado
- Geralmente criada usando uma LinkedList
- Queue<String> fila = new LinkedList<>();

#3
#2
#1
#4
offer(E
e)
#3
#2
#1
pop()
remove()
#3
#2
#1
peek()
#1
add(E e)

LinkedLists
- Usa referências para organizar a ordem
- Rápidas inserções mas lentas consultas
- Aumenta e diminui dinamicamente para manter a otimização de dados
- ThreadUnsafe

SLL x DLL
Celula Celula Celula
CelulaCelulaCelula
CelulaCelulaCelula

Sincronizado
(ThreadSafe)
Vector
● Usa 2 links de referência (anterior
e próxima)
● Ocupa mais espaço na memória
● Acesso aos elementos mais
eficiente
SLL
● Usa só um link de referência
(próxima celula)
● Ocupa menos espaço na
memória
● Acesso aos elementos menos
eficiente
DLL
Dados Link Dados LinkLink

Set (Interface)
- Não podem conter itens repetidos
- Implementação mais usada: HashSet
- Não é possível adquirir um item a partir de um index.
- Para recuperar algum elemento, é necessário usar um Iterator (ou um foreach, a partir
do Java 5)

Set<Aluno> set = new HashSet<>();
Aluno douglas = new Aluno("Douglas", 3729);
Aluno mauricio = new Aluno("Mauricio", 2587);
Aluno isadora = new Aluno("Isadora", 3652);
set.add(mauricio);
set.add(douglas);
set.add(douglas);
set.add(isadora);
System.out.println("************ Usando foreach ************");
for (Aluno aluno : set) {
System.out.println(aluno.getNome());
}
System.out.println("************ Usando metodo foreach() ************");
set.forEach(aluno -> {
});
System.out.println("************ Usando iterator ************");
Iterator<Aluno> iterator = set.iterator();
while (iterator.hasNext()) {
Aluno aluno = iterator.next();
}

Map (Interface)
Mapeia valores para suas chaves

HashMap
- Usa um algoritmo de espalhamento
- Rápidas consultas e inserções
Implementação mais usada da interface Map

Aluno(Chave)
José Maria João
Matricula(Valores
)
369 ...
123
258

Threads e Estruturas de dados

Mais conteúdo relacionado

Mais procurados

Semelhante a Threads e Estruturas de dados

Threads e Estruturas de dados

Notas do Editor