Java - Bufferizar dados

Após algumas vezes programar rotinas para capturar bytes vindos de conexão socket ou porta serial, armazenar estes bytes e em seguida processá-los para extrair a informação original, percebi logo a complexidade disso.

Qualquer um que já tenha programado um client ou server socket em Java, C++ e C ANSI sabe o que digo, pois utilizar um byte array para armazenar (bufferizar) dados recebidos antes de enquadrar uma informação significativa é uma maneira arcaica e dispensiosa.

Certo dia, resolvi simplificar esta situação com a criação de um mecanismo chamado WTByteBuffer bastante simples para prover apenas dois métodos, um método de escrita e outro de leitura a partir do ByteBuffer do Java NIO.

O método de escrita armazena os bytes lidos e o método de leitura consome os bytes. Desta forma, o programador Java será poupado de todo o trabalho discutido anteriormente para bufferizar e consumir dados recebidos.

WTByteBuffer - Classe para bufferizar


import java.nio.ByteBuffer;

public class WTByteBuffer {

    public static final int DEFAULT_MAX_SIZE = 1024 * 65;

    private volatile ByteBuffer buffer;
    private int size;
    private int bufferMaxSize;

    public int getSize() {
        return this.size;
    }

    public ByteBuffer getBuffer() {
        return this.buffer;
    }
   
   
    public WTByteBuffer() {
        this(WTByteBuffer.DEFAULT_MAX_SIZE);
    }

    public WTByteBuffer(int bufferMaxSize) {
        this.bufferMaxSize = bufferMaxSize;
        this.buffer = ByteBuffer.allocate(bufferMaxSize);
        buffer.position(0);
        this.size = 0;
       
    }

    public synchronized void write(byte[] bytes) {

        if (this.buffer == null)
            System.out.println("Buffer nulo : W");
       
        this.buffer.put(bytes);
        this.size = this.buffer.position();
       
    }

    public synchronized int read(byte[] bytes) {

        int target, position, newPosition, capacity;
        byte[] completeBuffer = null;
        byte[] remainingBuffer = null;

        if (bytes == null || bytes.length == 0) {
            return 0;
        }

        if (this.buffer == null)
            System.out.println("Buffer nulo : R");

        target = bytes.length;
        position = this.buffer.position();
        capacity = this.buffer.capacity();

        if (target > position) {
            target = position;
        }

        newPosition = position - target;
        completeBuffer = new byte[position];
        remainingBuffer = new byte[newPosition];
       
        this.buffer.flip();
        this.buffer.get(completeBuffer, 0, position);
        System.arraycopy(completeBuffer, 0, bytes, 0, target);

        this.buffer = null;
        this.buffer = ByteBuffer.allocate(capacity);
       
        if (newPosition > 0) {
            System.arraycopy(completeBuffer, target, remainingBuffer, 0, newPosition);
            this.buffer.put(remainingBuffer);
        }
   
        this.size = this.buffer.position();
   
        return target;

    }
   
    public synchronized void clear() {
       
        if (this.buffer != null) {
            this.buffer.clear();
            this.buffer = null;
        }
        this.buffer = ByteBuffer.allocate(bufferMaxSize);
        buffer.position(0);
        this.size = 0;

    }   
 
}

Testando um buffer

Este exemplo cria uma instância de WTByteBuffer com 100 bytes de capacidade, escreve a série de bytes de um texto qualquer e recupera de um em um byte. Depois repete o teste recuperando de dois em dois bytes do texto bufferizado.

        WTByteBuffer buffer = new WTByteBuffer(100);
        String text = "ABXYZ-0123456-abc";
       
        byte[] read = new byte[2];
        byte[] serialized = text.getBytes();
        int size = 0;

        System.out.println("-----------------------------------------");

        buffer.write(serialized);

        System.out.format("Texto guardado em buffer: %s\n", text);
       
        System.out.println("Recupera texto de 1 em 1 byte...");
       
        while (buffer.getSize() > 0) {

            read = new byte[1];

            size = buffer.read(read);

            System.out.format("1 byte lido: %s\n", new String(read));

        }

        System.out.format("Bytes guardados: %d\n", buffer.getSize());

        System.out.println("-----------------------------------------");

        buffer.write(serialized);

        System.out.format("Texto guardado em buffer: %s\n", text);
       
        System.out.println("Recupera texto de 2 em 2 byte...");
       
        while (buffer.getSize() > 0) {

            read = new byte[2];

            size = buffer.read(read);

            System.out.format("%d byte(s) lido(s): %s\n", size, new String(read));

        }
       
        buffer = null;


Numa situação real a capacidade deste buffer deverá ser maior do que 100. Caso desejar aumentar o tamanho, faça isso ao construir o WTByteBuffer ou então utilize o construtor padrão para iniciar com o tamanho padrão de reserva máxima.

A classe abordada ainda provê métodos adicionais para controle e acesso ao buffer central.

Boa sorte.

Alerta de ameaça - Plugin Java para navegadores

Foi detectada recentemente uma falha no plugin do Java para navegadores e está sendo explorada por um malware difundido pela rede.

O malware é capaz de conceder acesso completo ao sistema de seu computador que poderá ser controlado por servidores já preparados para isso.

A recomendação é desativar o plugin do Java de seus navegadores enquanto a falha na segurança é corrigida.

Caso você não saiba como desabilitar o plugin em seu navegador, consulte um especialista para te ajudar.

Fontes:
http://g1.globo.com/tecnologia/noticia/2012/08/java-tem-falha-critica-e-codigo-de-exploracao-ja-circula-na-web.html
http://tecnoblog.net/111640/java-falha-zero-day/

Eclipse - Failed to create Java Virtual Machine

Recentemente meu Eclipse Indigo se atualizou como de costume e após reiniciá-lo recebi a mensagem "Failed to create the Java Virtual Machine".

A razão do problema é que o Eclipse teve seu arquivo de inicialização modificado de maneira errada por alguma atualização.

Foi necessário editar o arquivo Eclipse.INI  e reorganizar as informações e o Eclipse voltou a funcionar:

Atenção: Faça um backup do seu Eclipse.INI antes de alterá-lo, porque os pacotes JAR do seu INI original devem ser preservados.

-startup
plugins/org.eclipse.equinox.launcher_1.2.0.v20110502.jar
--launcher.library
plugins/org.eclipse.equinox.launcher.win32.win32.x86_1.1.100.v20110502
-product
org.eclipse.epp.package.rcp.product
--launcher.defaultAction
openFile
--launcher.XXMaxPermSize
256M
-showsplash
org.eclipse.platform
--launcher.XXMaxPermSize
256m
--launcher.defaultAction
openFile
-vm
C:\Program Files\Java\jdk1.6.0_27\bin\javaw.exe
-vmargs
-Dosgi.requiredJavaVersion=1.5
-Xms40m
-Xmx1024m
 
Fonte: http://wiki.eclipse.org/Eclipse.ini

Java - Leitura de XML com a SAX

Ao ler um arquivo XML você pode utilizar duas maneiras, SAX e a DOM.

A SAX é prove uma forma direta de acessar elementos de um XML por seu identificador e não requer leitura de uma hierarquia para isso. Diferente da SAX, a DOM é uma maneira de ler o XML também, mas por meio de uma hierarquia.

No entanto, este artigo apresenta um exemplo de leitura de XML via SAX na linguagem Java.

Documento XML

Crie o arquivo cesta.xml. No exemplo, este arquivo foi criado no diretório c:\temp. Preencha com o conteúdo a seguir:

<cesta loja="Papelex">

   <caneta>Caneta BIC</caneta>
   <caneta>Caneta Kilometrica</caneta>
   <caneta>Caneta Faber</caneta>
   <caneta>Caneta Helios</caneta>
   <caneta>Caneta Ferrari</caneta>
   <caneta>Caneta Pentec</caneta>

   <lapis>Caneta BIC</lapis>
   <lapis>Caneta Kilometrica</lapis>
   <lapis>Caneta Faber</lapis>
   <lapis>Caneta Helios</lapis>
   <lapis>Caneta Ferrari</lapis>
   <lapis>Caneta Pentec</lapis>

</cesta>
 

Classe de leitura do XML

Crie a classe de leitura do XML chamada TestaXML.java.

import java.io.File;
import java.io.IOException;
import java.util.List;

import org.jdom2.Document;
import org.jdom2.Element;
import org.jdom2.JDOMException;
import org.jdom2.input.SAXBuilder;

public class TestaXML {

    public static void main(String[] args) throws JDOMException, IOException {

        File f = new File("c:/temp/cesta.xml");
       
        SAXBuilder sb = new SAXBuilder();
       
        Document doc = sb.build(f);

        Element cesta = doc.getRootElement();

        System.out.println("CESTA:");   
        System.out.println("Loja: " + cesta.getAttributeValue("loja"));   
        System.out.println("-------------------------------------------------");   
       
        List<Element> canetas = cesta.getChildren("caneta");

        for (int i = 0; i < canetas.size(); i++) {
           
            Element caneta = canetas.get(i);

            System.out.println("CANETA:");   
            System.out.println("Modelo: " + caneta.getValue());   
        }
        System.out.println("-------------------------------------------------");   
       
        List<Element> lapis = cesta.getChildren("lapis");

        for (int i = 0; i < lapis.size(); i++) {
           
            Element umLapis = lapis.get(i);

            System.out.println("LÁPIS:");   
            System.out.println("Modelo: " + umLapis.getValue());   
        }

        System.out.println("-------------------------------------------------");   
       
    }
}


Observe que entre as tags <cesta> e </cesta>, foram colocadas tags <caneta> e <lapis> muitas vezes. Logo, foram acessadas separadamente os elementos do tipo caneta e lápis pela função getChildren.

TDC 2012

No próximo dia 4 até 8/07/2012, ocorrerá em São Paulo, na Universidade Anhembi Morumbi a sexta edição TDC (The Developers Conference), evento organizado pela GlobalCode para profissionais e estudantes iniciantes em tecnologia.

Você pode se inscrever e selecionar uma trilha de palestra por dia. Por exemplo, se na segunda-feira você decidir participar da trilha sobre Java, passará o "dia inteiro" de palestra vendo somente Java. Além do Java, outras tecnologias atuais serão palestradas com Ruby, Python, PHP, C/C++, Scala, .NET, Arduino, Testes, Marketing Digital, Robótica, Banco de Dados, Android, iOS, WindowsPhone e muito mais.

As inscrições já estão abertas no site do evento.

Para mais informações, acesse:

Java - Clonagem de objetos

Durante sua vida um programador pode lidar com a necessidade de manter um objeto matriz e reproduzir cópias deste objeto para fins de alterar estas cópias sem perder a originalidade da matriz.

Posso descrever uma situação onde tive uma rotina de envio de mensagem para um determinado host, mas esta rotina alterava propriedades da minha mensagem original porque seu comportamento normal era este. Foi desenhado para envio de mensagem sempre para um destinatário. Efeito:

  d - Destino da mensagem (host).

  m.o. - Mensagem original.

  m.a. - Mensagem alterada.

  send_to_some (d, m.o. -> m.a.) - Função de envio para d onde m.o. passa a ser m.a. ao final do processamento.

Acrescentei ao sistema uma função a mais para enviar a mensagem destinada para mais de um host através de clonagem para preservar a original. Efeito:

  m.o. - Mensagem original.

  m.c. - Mensagem clonada.

  m.a. - Mensagem alterada.

  send_to_all (m.o. -> m.a.) - Função de envio para todos m.c. passa a ser m.a. ao final do processamento, mas m.o. é preservado.

Após implementar send_to_all, simplismente esta função passou a varrer a lista ativa de conexões de hosts e para cada iteração clona a mensagem original e passa o clone como parâmetro de send_to_some.

Vamos para a prática!

WTByteArrayInputStream

Esta classe representa um mecanismo para transformar uma série de bytes em um objeto. Será utilizada no processo de clonagem.

import java.io.InputStream;

public class WTByteArrayInputStream extends InputStream {

    protected byte[] buf = null;

    protected int count = 0;

    protected int pos = 0;

    public WTByteArrayInputStream(byte[] buf, int count) {
        this.buf = buf;
        this.count = count;
    }

    public final int available() {
        return count - pos;
    }

    public final int read() {
        return (pos < count) ? (buf[pos++] & 0xff) : -1;
    }

    public final int read(byte[] b, int off, int len) {
        if (pos >= count)
            return -1;

        if ((pos + len) > count)
            len = (count - pos);

        System.arraycopy(buf, pos, b, off, len);
        pos += len;
        return len;
    }

    public final long skip(long n) {
        if ((pos + n) > count)
            n = count - pos;
        if (n < 0)
            return 0;
        pos += n;
        return n;
    }

}

WTByteArrayOutputStream

Esta classe representa um mecanismo para transformar um objeto em uma série de bytes e oferece uma função para obter uma conexão com os bytes do objeto.

import java.io.InputStream;
import java.io.OutputStream;

public class WTByteArrayOutputStream extends OutputStream {

    protected byte[] buf = null;
    protected int size = 0;

    public WTByteArrayOutputStream() {
        this(5 * 1024);
    }

    public WTByteArrayOutputStream(int initSize) {
        this.size = 0;
        this.buf = new byte[initSize];
    }

    private void verifyBufferSize(int sz) {
        if (sz > buf.length) {
            byte[] old = buf;
            buf = new byte[Math.max(sz, 2 * buf.length )];
            System.arraycopy(old, 0, buf, 0, old.length);
            old = null;
        }
    }

    public int getSize() {
        return size;
    }

    public byte[] getByteArray() {
        return buf;
    }

    public final void write(byte b[]) {
        verifyBufferSize(size + b.length);
        System.arraycopy(b, 0, buf, size, b.length);
        size += b.length;
    }

    public final void write(byte b[], int off, int len) {
        verifyBufferSize(size + len);
        System.arraycopy(b, off, buf, size, len);
        size += len;
    }

    public final void write(int b) {
        verifyBufferSize(size + 1);
        buf[size++] = (byte) b;
    }

    public void reset() {
        size = 0;
    }

    public InputStream getInputStream() {
        return new WTByteArrayInputStream(buf, size);
    }

}

WTCloneObject

Esta classe é a própria rotina de clonagem.

import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

public class WTCloneObject {

    public static Object copy(Object orig) {

        Object obj = null;

        try {

            WTByteArrayOutputStream fbos = new WTByteArrayOutputStream();
            ObjectOutputStream out = new ObjectOutputStream(fbos);

            out.writeObject(orig);
            out.flush();
            out.close();

            ObjectInputStream in = new ObjectInputStream(fbos.getInputStream());
            obj = in.readObject();

        }
        catch(IOException e) {
            e.printStackTrace();
        }
        catch(ClassNotFoundException cnfe) {
            cnfe.printStackTrace();
        }
        return obj;
    }

}

DadosPessoais

Esta classe é um bean muito simples que auxiliará apenas o teste. Como será o tipo do objeto para clonar em nosso teste, esta deve implementar a interface Serializable. Observe a palavra-chave transient no parâmetro senha_Bancaria, pois indica que o atributo não será gravado quando o objeto de DadosPessoais for serializado em bytes. Esta mesma técnica pode ser utilizada se um dos atributos for tão complexo ou fechado que não te permite fazer suas classes ou sub-classes implementarem a interface Serializable.

import java.io.Serializable;
 
class DadosPessoais implements Serializable {

    private String nome;
    private int idade;
    private String telefone;
    private String sexo;
    private transient String senha_Bancaria;

    public String getNome() {
        return nome;
    }

    public void setNome(String nome) {
        this.nome = nome;
    }

    public int getIdade() {
        return idade;
    }

    public void setIdade(int idade) {
        this.idade = idade;
    }

    public String getTelefone() {
        return telefone;
    }

    public void setTelefone(String telefone) {
        this.telefone = telefone;
    }

    public String getSexo() {
        return sexo;
    }

    public void setSexo(String sexo) {
        this.sexo = sexo;
    }

    public String getSenha_Bancaria() {
        return senha_Bancaria;
    }

    public void setSenha_Bancaria(String senha_Bancaria) {
        this.senha_Bancaria = senha_Bancaria;
    }

    @Override
    public String toString() {
        return "DadosPessoais [nome=" + nome + ", idade=" + idade
                + ", telefone=" + telefone + ", sexo=" + sexo
                + ", senha_Bancaria=" + senha_Bancaria + "]";
    }

}

Testando

Crie uma classe de teste com um método main para testar a clonagem:

        DadosPessoais matriz = new DadosPessoais();

        matriz.setNome("Jose");
        matriz.setIdade(30);
        matriz.setTelefone("+55 11 88888888");
        matriz.setSexo("M");
        matriz.setSenha_Bancaria("123#%!");

        System.out.println("Esta é a matriz");
        System.out.println(matriz.toString());
        System.out.println("");

        for (int i = 0; i < 10; i++) {
           
            DadosPessoais clone = (DadosPessoais) WTCloneObject.copy(matriz);

            System.out.println("Este é o clone id = " + i);
            System.out.println(clone.toString());
            System.out.println("");
           
        }

Fique atento, a senha não foi clonada em nenhum momento porque foi marcada como transient na classe DadosPessoais.

Até a próxima.

Java - Limpeza automática de coleções

Um dos problemas principais em aplicações do tipo serviço é a alocação e devolução de memória, porque aplicações do tipo serviço tendem a ter um ciclo de vida de horas, dias ou meses por terem como premissa uma longa disponibilidade e robustez.

A depender da complexidade do serviço em relação ao volume de requisições à processar, é costume do arquiteto definir o uso de pilhas sofisticadas (coleções) para enfileirar e controlar o fluxo do processamento de requisições. Não obstante, estas pilhas podem naturalmente receber novos elementos, porém por uma eventual falha (ou não tratada) fará alguns de seus elementos ficarem empilhados "para sempre" até o fim do serviço. O pior é que a gc (garbage collector) nesta situação não fara a limpeza porque os elementos perdidos estão vinculados a um objeto de pilha (elemento).

No exemplo deste artigo, coloco a disposição especializações das coleções ConcurrentHashMap e ConcurrentLinkedQueue por se tratar das pilhas mais comuns numa arquitetura de serviço com paralelismo para alta produtividade. As especializações a seguir tem o mesmo propósito, expirar elementos após 120 segundos (2 minutos) em fila. Perceba na constante KEY_TIMEOUT_VALUE, encontrada em cada uma das especializações, que este tempo pode ser aumentado ou diminuído.

Importante: O mecanismo proposto como base expira elementos da pilha e destrói objetos envelopados por WTTimeObject através de anulamento. Porém, se o objeto núcleo armazenado na pilha for muito complexo, como é o caso de um Socket ou File, este será removido do empilhamento, mas ficará em aberto mesmo com o anulamento enquanto o serviço estiver ativo. Para este caso, recomendo um controle transacional conciente para o correto encerramento do objeto complexo.

WTTimeObject

Esta classe é um invólucro usado por ambas as especializações citadas anteriormente. O WTTimeObject contém atributos para a guarda do tempo de último acesso ao elemento núcleo empilhado (aquele que realmente se pretente armazenar) generalizado em <V>. Se você não entende de Generics em Java, terá dificuldades de compreender este artigo.

public class WTTimeObject<V> {

    private static long nextVal = 0L;
   
    private long lastAccessTime = 0L;
    private V value;
    private long objectId;
   
    public WTTimeObject() {
        this.objectId = this.getNextVal();
    }
   
    public WTTimeObject(V value) {

        this();

        this.lastAccessTime = System.currentTimeMillis();
        this.value = value;

    }

    public long getLastAccessTime() {
        return lastAccessTime;
    }

    public V getValue() {
        return this.getValue(true);
    }

   
    public V getValue(boolean doUpdateAccessTime) {
        if (doUpdateAccessTime) {
            this.lastAccessTime = System.currentTimeMillis();
        }
        return value;
    }

    public void setValue(V value) {
        this.lastAccessTime = System.currentTimeMillis();
        this.value = value;
    }
   
    public synchronized long getNextVal() {
       
        if (WTTimeObject.nextVal < Long.MAX_VALUE) {
            WTTimeObject.nextVal++;
        } else {
            WTTimeObject.nextVal=1;
        }
       
        return WTTimeObject.nextVal;
       
    }

    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + (int) (objectId ^ (objectId >>> 32));
        return result;
    }

    public boolean equals(Object obj) {

        if (this == obj)
            return true;

        if (obj == null)
            return false;

        if (getClass() != obj.getClass())
            return false;

        WTTimeObject<?> other = (WTTimeObject<?>) obj;

        if (objectId != other.objectId)
            return false;

        return true;

    }

}

WTConcurrentLinkedQueue

Esta é a especialização da coleção ConcurrentLinkedQueue, perceba que existe uma inner class na especialização chamada ClearExpiredRunnable que é do tipo Runnable, porque a cada adição a instância de ClearExpiredRunnable será acionada à verificar e eliminar elementos não acessados a mais de 120 segundos.

import java.util.Iterator;
import java.util.concurrent.ConcurrentLinkedQueue;

public class WTConcurrentLinkedQueue<V> {

    public static final long CLEAR_EXPIRED_INTERVAL_VALUE = 60; // A cada 1 minuto verifica
    public static final long KEY_TIMEOUT_VALUE = 120; // Elementos mais velhos do que 2 minutos 

    private ConcurrentLinkedQueue<WTTimeObject<V>> queue;

    private long keyTimeout;
    private String id;
    private long clearExpiredTimeout;
    private ClearExpiredValues clearExpiredRunnable;

    public WTConcurrentLinkedQueue(String id) {
        this(id, KEY_TIMEOUT_VALUE);
    }

    public WTConcurrentLinkedQueue(String id, Long keyTimeout) {
        this.id = id;
        this.queue = new ConcurrentLinkedQueue<WTTimeObject<V>>();
        updateTimeoutOfClearExpired();
        this.keyTimeout = keyTimeout;
        clearExpiredRunnable = new ClearExpiredValues(this);
    }

    public boolean add(V value) {

        boolean result = false;

        result = this.queue.add(new WTTimeObject<V>(value));
   
        // Chama evento para excluir elementos expirados
        clearExpiredValues();
       
        return result;

    }

    public V peek() {

        WTTimeObject<V> result = null;

        result = this.queue.peek();

        if (result == null) {
            return null;
        } else {
            return result.getValue();
        }
    }
   
    public V poll() {

        WTTimeObject<V> result = null;

        result = this.queue.poll();

        if (result == null) {
            return null;
        } else {
            return result.getValue();
        }
    }
   
   
    public boolean remove(V value) {

        boolean result = false;
       
        WTTimeObject<V> timeObj = null;

        synchronized(queue) {
       
            Iterator<WTTimeObject<V>> it = this.queue.iterator();
   
            while (it.hasNext()) {
   
                timeObj = it.next();
   
                // A comparação deve ser feita com o conteúdo de DGTimeObject e nunca direto
                if (value instanceof String) {
                    if (timeObj.getValue(false).equals(value)) {
                        result = this.queue.remove(timeObj);
                        it.remove();
                        break;
                    }
                }else {
                    if (timeObj.getValue(false) == value) {
                        result = this.queue.remove(timeObj);
                        it.remove();
                        break;
                    }
                }
   
            }
           
        }

        return result;
       
    }

    public Iterator<WTTimeObject<V>> iterator() {
        return this.queue.iterator();
    }

    public int size() {
        return this.queue.size();
    }
   
    public void clearExpiredValues() {

        if (clearExpiredTimeout < System.currentTimeMillis()) {
            updateTimeoutOfClearExpired();
            Thread r = new Thread(clearExpiredRunnable);
            r.start();
        }

    }

    public void clear() {

        this.queue.clear();

    }
   
   
    class ClearExpiredValues implements Runnable {

        private WTConcurrentLinkedQueue<V> queue;

        public ClearExpiredValues(WTConcurrentLinkedQueue<V> queue) {
            this.queue = queue;
        }

        public void run() {

            int countRemove = 0;
           
            Iterator<WTTimeObject<V>> it = this.queue.iterator();

            WTTimeObject<V> value;

            while (it.hasNext()) {

                value = it.next();

                // Verifica se o objeto venceu
                if (value != null && value.getLastAccessTime() + (keyTimeout * 1000) < System.currentTimeMillis()) {

                    // ATENÇÃO: Nunca anular o valor dentro de value, porque o remove encontra
                    // o elemento para remoção através de value.getValue().
                    this.queue.remove(value.getValue());
                    it.remove();

                    value.setValue(null);
                    value = null;

                    countRemove++;

                }
   
            }

            if (countRemove > 0)
                System.out.println(String.format("Removido(s) %d elemento(s) vencidos de %s.", countRemove, id));

        }

    }

    public void updateTimeoutOfClearExpired() {
        clearExpiredTimeout = System.currentTimeMillis() + (CLEAR_EXPIRED_INTERVAL_VALUE * 1000);
    }   

}

WTConcurrentHashMap

Já esta é a outra especialização, agora da coleção ConcurrentHashMap, perceba que também existe uma inner class na especialização chamada ClearExpiredRunnable que é do tipo Runnable, porque a cada adição a instância de ClearExpiredRunnable será acionada à verificar e eliminar elementos não acessados a mais de 120 segundos.

import java.util.Enumeration;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;

public class WTConcurrentHashMap<K, V> {

    public static final long CLEAR_EXPIRED_INTERVAL_VALUE = 60; // A cada 1 minuto verifica
    public static final long KEY_TIMEOUT_VALUE = 120; // Elementos mais velhos do que 2 minutos 

    private ConcurrentHashMap<K, WTTimeObject<V>> map;
    private long keyTimeout;
    private String id;
    private long clearExpiredTimeout;
    private ClearExpiredKeys clearExpiredRunnable;

    public WTConcurrentHashMap(String id) {
        this(id, KEY_TIMEOUT_VALUE);
    }

    public WTConcurrentHashMap(String id, Long keyTimeout) {
        this.id = id;
        map = new ConcurrentHashMap<K, WTTimeObject<V>>();
        updateTimeoutOfClearExpired();
        this.keyTimeout = keyTimeout;
        clearExpiredRunnable = new ClearExpiredKeys(map);
    }

    public V put(K key, V value) {

        WTTimeObject<V> result = null;

        synchronized(map) {
            result = map.put(key, new WTTimeObject<V>(value));
        }

        if (this.keyTimeout > 0L) {
            // Chama evento para excluir elementos expirados
            clearExpiredKeys();
        }
       
        if (result == null) {
            return null;
        } else {
            return value;
        }
    }

    public V get(K key) {

        WTTimeObject<V> result = null;

        synchronized(map) {
            result = map.get(key);
        }

        if (result == null) {
            return null;
        } else {
            return result.getValue();
        }
    }
   
    public V remove(K key) {

        WTTimeObject<V> result = null;

        synchronized(map) {
            result = map.remove(key);
        }

        if (result == null) {
            return null;
        } else {
            return result.getValue();
        }
    }
   
    public void clearExpiredKeys() {

        if (clearExpiredTimeout < System.currentTimeMillis()) {
            updateTimeoutOfClearExpired();
            Thread r = new Thread(clearExpiredRunnable);
            r.start();
        }

    }

    public void clear() {
        synchronized(map) {
            map.clear();
        }
    }
   
    public Set<K> keySet() {
        synchronized(map) {
            return map.keySet();
        }
    }

    public int size() {
        synchronized(map) {
            return map.size();
        }
    }
   
    class ClearExpiredKeys implements Runnable {

        private ConcurrentHashMap<K, WTTimeObject<V>> map;

        public ClearExpiredKeys(ConcurrentHashMap<K, WTTimeObject<V>> map) {
            this.map = map;
        }
       
        public void run() {

            int countRemove = 0;

            synchronized(map) {
               
                Enumeration<K> en = map.keys();
   
                K key;
                WTTimeObject<V> value;
   
                while (en.hasMoreElements()) {
   
                    key = en.nextElement();
   
                    value = map.get(key);
   
                    // Verifica se o objeto venceu
                    if (value != null && value.getLastAccessTime() + (keyTimeout * 1000) < System.currentTimeMillis()) {
   
                        value.setValue(null);
                        value = null;
                        map.remove(key);
                        countRemove++;
   
                    }
   
                }
               
            }

            if (countRemove > 0)
                System.out.println(String.format("Removido(s) %d elemento(s) vencidos de %s.", countRemove, id));

        }

    }
   
    public void updateTimeoutOfClearExpired() {
        clearExpiredTimeout = System.currentTimeMillis() + (CLEAR_EXPIRED_INTERVAL_VALUE * 1000);
    }

}

Testando as coleções especializadas

Para finalizar, vamos testar as coleções para observar a limpeza de elementos com mais de 120 segundos sem acesso:

        WTConcurrentLinkedQueue<String> map = new WTConcurrentLinkedQueue<String>("ColecaoTeste");
        WTConcurrentHashMap<Integer, String> map1 = new WTConcurrentHashMap<Integer, String>("ColecaoTeste");
        int contador = 0;

        while (true) {
            contador++;
            map.add("Teste " + contador);
            map1.put(contador, "Teste " + contador);
            try {
                Thread.sleep(1L);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }