Otimizando a performance da aplica��o ao trabalhar com datas em Java

Figura 1: Trabalhar com datas � muito comum

Introduç�o

Para realizar operaç�es de formataç�o ou parse de datas, muitos programadores Java usam a conhecida classe SimpleDateFormat, do pacote java.text. Ela � uma alternativa natural, pois faz parte da API padr�o h� muito tempo e � relativamente simples de usar. Por�m, o que poucos sabem � que ela pode n�o ser a melhor opç�o em termos de performance para certos cen�rios.

Como alternativa ao SimpleDateFormat, iremos analisar o FastDateFormat da Apache e o DateTimeFormatter do JodaTime.

SimpleDateFormat:

Faz parte da API padr�o. (Ser� utilizado o Java 6).

FastDateFormat:

Faz parte da API commons lang da Apache;
Download: http://commons.apache.org/lang/
Ser� utilizada a vers�o 3.3.1.

DateTimeFormatter:

Faz parte da API Joda-Time;
Download: http://joda-time.sourceforge.net/;
Ser� utilizada a vers�o 2.1.

Os testes ser�o realizados sobre as seguintes configuraç�es:

Windows XP;
Intel Core 2 Duo CPU - 2.80 Ghz;
3,49 G Ram;
Netbeans 7.0.1;
Java 1.6.

Listagem 1: Classe de Teste para formataç�o com criaç�o de objeto no loop


package br.com.devmedia.benchmark;

import java.text.SimpleDateFormat;
import java.util.Date;
import org.apache.commons.lang3.time.FastDateFormat;
import org.joda.time.DateTime;
import org.joda.time.format.DateTimeFormat;

public class TestePerformanceFormat1 {

    private static final int OPERACOES = 1000;
    private static final int EXECUCOES = 1000;
    private static final String PATTERN = "yyyy/MM/dd";

    public static void main(String... args) {
        double t1, t2, t3;
        int i;

        final Date now = new Date();
        final DateTime nowJoda = new DateTime();

        t1 = t2 = t3 = 0.0;
        for (i = 0; i < EXECUCOES; i++) {
            t1 += testSimpleDateFormat(now);
            t2 += testFastDateFormat(now);
            t3 += testDateTimeFormat(nowJoda);
        }

        System.out.println("SimpleDateFormat: Tempo m�dio decorrido = " + (t1 / EXECUCOES) + " milisegundos ");
        System.out.println("FastDateFormat Tempo m�dio decorrido = " + (t2 / EXECUCOES) + " milisegundos ");
        System.out.println("DateTimeFormatter Tempo m�dio decorrido = " + (t3 / EXECUCOES) + " milisegundos ");
    }

    public static long testSimpleDateFormat(final Date now) {
        String result = null;
        int i;
        long t1 = System.currentTimeMillis();
        for (i = 0; i < OPERACOES; i++) {
            result = new SimpleDateFormat(PATTERN).format(now);
        }
        long t2 = System.currentTimeMillis();
        // Print nao entra no contagem de tempo
        System.out.println("result testSimpleDateFormat = " + result);
        return t2 - t1;
    }

    public static long testFastDateFormat(final Date now) {
        String result = null;
        int i;
        long t1 = System.currentTimeMillis();
        for (i = 0; i < OPERACOES; i++) {
            result = FastDateFormat.getInstance(PATTERN).format(now);
        }
        long t2 = System.currentTimeMillis();
        // Print nao entra no contagem de tempo
        System.out.println("result testFastDateFormat = " + result);
        return t2 - t1;
    }

    public static long testDateTimeFormat(final DateTime now) {
        String result = null;
        int i;
        long t1 = System.currentTimeMillis();
        for (i = 0; i < OPERACOES; i++) {
            result = DateTimeFormat.forPattern(PATTERN).print(now);
        }
        long t2 = System.currentTimeMillis();
        // Print nao entra no contagem de tempo
        System.out.println("result testDateTimeFormat = " + result);
        return t2 - t1;
    }
}

Ao rodar o teste, temos os seguintes tempos m�dios:

Sa�da:

result testSimpleDateFormat = 2012/11/25
result testFastDateFormat = 2012/11/25
result testDateTimeFormat = 2012/11/25

1� Execuç�o:

SimpleDateFormat: Tempo m�dio decorrido = 6.63 milisegundos
FastDateFormat Tempo m�dio decorrido = 2.386 milisegundos
DateTimeFormatter Tempo m�dio decorrido = 0.765 milisegundos

2� Execuç�o:

SimpleDateFormat: Tempo m�dio decorrido = 6.623 milisegundos
FastDateFormat Tempo m�dio decorrido = 2.165 milisegundos
DateTimeFormatter Tempo m�dio decorrido = 0.884 milisegundos

No c�digo-fonte da listagem 1, esta sendo cronometrado o tempo de criaç�o dos objetos e a operaç�o de formataç�o, que transforma o objeto Date numa String. (Observe que o JodaTime n�o trabalha com o objeto Date, e sim com DateTime).

Nota-se que o tempo m�dio de processamento nesse cen�rio � favor�vel ao DateTimeFormatter. Utilizando o JProfile, verificou tamb�m que o consumo de mem�ria � bem menor no m�todo que utiliza DateTimeFormatter do que nas outras duas abordagens. (Ou seja, a API do Joda Time cria menos objetos internos do que as outras alternativas).

Liistagem 2: Classe de Teste para formataç�o sem criaç�o de objeto no loop


package br.com.devmedia.benchmark;

import java.text.SimpleDateFormat;
import java.util.Date;
import org.apache.commons.lang3.time.FastDateFormat;
import org.joda.time.DateTime;
import org.joda.time.format.DateTimeFormat;
import org.joda.time.format.DateTimeFormatter;

public class TestePerformanceFormat2 {
    
    private static final int OPERACOES = 1000;
    private static final int EXECUCOES = 1000;    
    private static final String PATTERN = "yyyy/MM/dd";
    
    public static void main(String... args) {        
        double t1, t2, t3;
        int i;
        
        final Date now = new Date();
        final DateTime nowJoda = new DateTime();        
        
        final SimpleDateFormat sdf = new SimpleDateFormat(PATTERN);
        final FastDateFormat fdf = FastDateFormat.getInstance(PATTERN);
        final DateTimeFormatter dtf = DateTimeFormat.forPattern(PATTERN);
        
        t1 = t2 = t3 = 0;
        for(i = 0; i < EXECUCOES; i++) {        
            t1 += testSimpleDateFormat(sdf, now);        
            t2 += testFastDateFormat(fdf, now);
            t3 += testDateTimeFormat(dtf, nowJoda);            
        }
        
        System.out.println("SimpleDateFormat: Tempo m�dio decorrido = " + (t1 / EXECUCOES) + " milisegundos ");
        System.out.println("FastDateFormat Tempo m�dio decorrido = " + (t2 / EXECUCOES) + " milisegundos ");
        System.out.println("DateTimeFormatter Tempo m�dio decorrido = " + (t3 / EXECUCOES) + " milisegundos ");
    }    
    
    public static long testSimpleDateFormat(final SimpleDateFormat sdf, final Date now) {
        String result = null;
        long t1 = System.currentTimeMillis();        
        for (int i = 0; i < OPERACOES; i++) {
            result = sdf.format(now);
        }
        long t2 = System.currentTimeMillis();  
        // Print nao entra no contagem de tempo
        System.out.println("result testSimpleDateFormat = " + result);
        return t2 - t1;
    }
    
    public static long testFastDateFormat(final FastDateFormat fdf, final Date now) {
        String result = null;
        long t1 = System.currentTimeMillis();        
        for (int i = 0; i < OPERACOES; i++) {
            result = fdf.format(now);
        }
        long t2 = System.currentTimeMillis();
        // Print nao entra no contagem de tempo
        System.out.println("result testFastDateFormat = " + result);
        return t2 - t1;
    }    
    
    public static long testDateTimeFormat(final DateTimeFormatter dtf, final DateTime now) {
        String result = null;
        long t1 = System.currentTimeMillis();        
        for (int i = 0; i < OPERACOES; i++) {
            result = dtf.print(now);
        }
        long t2 = System.currentTimeMillis();
        // Print nao entra no contagem de tempo
        System.out.println("result testDateTimeFormat = " + result);
        return t2 - t1;
    }        
}

Sa�da:

result testSimpleDateFormat = 2012/11/25
result testFastDateFormat = 2012/11/25
result testDateTimeFormat = 2012/11/25

1� Execuç�o:

SimpleDateFormat: Tempo m�dio decorrido = 0.731 milisegundos
FastDateFormat Tempo m�dio decorrido = 2.064 milisegundos
DateTimeFormatter Tempo m�dio decorrido = 0.878 milisegundos

2� Execuç�o:

SimpleDateFormat: Tempo m�dio decorrido = 0.871 milisegundos
FastDateFormat Tempo m�dio decorrido = 1.673 milisegundos
DateTimeFormatter Tempo m�dio decorrido = 1.143 milisegundos

Quando os objetos s�o criados fora dos loops, verifica-se que o SimpleDateFormat teve um desempenho melhor. Houve tamb�m um menor consumo de mem�ria no m�todo que usa SimpleDateFormat do que o DateTimeFormatter (JProfile). J� o FastDateFormat, al�m de ser o mais lento foi o que consumiu maior quantidade de mem�ria.

Listagem 3: Classe de Teste para operaç�es de parse com criaç�o de objeto no loop


package br.com.devmedia.benchmark;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import org.joda.time.DateTime;
import org.joda.time.format.DateTimeFormat;

public class TestePerformanceParse1 {

    private static final int OPERACOES = 1000;
    private static final int EXECUCOES = 1000;
    private static final String PATTERN = "yyyy/MM/dd";
    private static String date = "2010/10/10";

    public static void main(String... args) throws ParseException {
        double t1, t2;
        int i;

        t1 = t2 = 0;
        for (i = 0; i < EXECUCOES; i++) {
            t1 += testSimpleDateFormat(date);
            t2 += testDateTimeFormat(date);
        }

        System.out.println("SimpleDateFormat: Tempo m�dio decorrido = " + (t1 / EXECUCOES) + " milisegundos ");
        System.out.println("DateTimeFormatter Tempo m�dio decorrido = " + (t2 / EXECUCOES) + " milisegundos ");
    }

    public static long testSimpleDateFormat(final String strDate) throws ParseException {
        Date result = null;
        int i;
        long t1 = System.currentTimeMillis();
        for (i = 0; i < OPERACOES; i++) {
            result = new SimpleDateFormat(PATTERN).parse(strDate);
        }
        long t2 = System.currentTimeMillis();
        // Print nao entra no contagem de tempo
        System.out.println("result testSimpleDateFormat = " + result);
        return t2 - t1;
    }

    public static long testDateTimeFormat(final String strDate) {
        DateTime result = null;
        int i;
        long t1 = System.currentTimeMillis();
        for (i = 0; i < OPERACOES; i++) {
            result = DateTimeFormat.forPattern(PATTERN).parseDateTime(strDate);
        }
        long t2 = System.currentTimeMillis();
        // Print nao entra no contagem de tempo
        System.out.println("result testDateTimeFormat = " + result);
        return t2 - t1;
    }
}

Sa�da:

result testSimpleDateFormat = Sun Oct 10 00:00:00 BRT 2010
result testDateTimeFormat = 2010-10-10T00:00:00.000-03:00

1� Execuç�o:

SimpleDateFormat: Tempo m�dio decorrido = 9.107 milisegundos
DateTimeFormatter Tempo m�dio decorrido = 1.939 milisegundos

2� Execuç�o:

SimpleDateFormat: Tempo m�dio decorrido = 8.867 milisegundos
DateTimeFormatter Tempo m�dio decorrido = 1.993 milisegundos

Assim como na listagem 1, quando os objetos s�o criados dentro do loop, a API do JodaTime � novamente superior em termos de desempenho (e uso de mem�ria).

Nota: O FastDateFormat n�o foi utilizado, pois ele n�o possue funç�es de parse semelhantes ao SimpleDateFormat e DateTimeFormatter. FastDateFormat s� pode ser utilizado para formataç�o.

Listagem 4: Classe de Teste para operaç�es de parse sem criaç�o de objeto no loop


package br.com.devmedia.benchmark;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import org.joda.time.DateTime;
import org.joda.time.format.DateTimeFormat;
import org.joda.time.format.DateTimeFormatter;


public class TestePerformanceParse2 {

    private static final int OPERACOES = 1000;
    private static final int EXECUCOES = 1000;
    private static final String PATTERN = "yyyy/MM/dd";
    private static String date = "2010/10/10";

    public static void main(String... args) throws ParseException {
        double t1, t2;
        int i;

        final SimpleDateFormat sdf = new SimpleDateFormat(PATTERN);
        final DateTimeFormatter dtf = DateTimeFormat.forPattern(PATTERN);

        t1 = t2 = 0;
        for (i = 0; i < EXECUCOES; i++) {
            t1 += testSimpleDateFormat(sdf, date);
            t2 += testDateTimeFormat(dtf, date);
        }

        System.out.println("SimpleDateFormat: Tempo m�dio decorrido = " + (t1 / EXECUCOES) + " milisegundos ");
        System.out.println("DateTimeFormatter Tempo m�dio decorrido = " + (t2 / EXECUCOES) + " milisegundos ");
    }

    public static long testSimpleDateFormat(final SimpleDateFormat sdf, final String strDate) throws ParseException {
        Date result = null;
        int i;
        long t1 = System.currentTimeMillis();
        for (i = 0; i < OPERACOES; i++) {
            result = sdf.parse(strDate);
        }
        long t2 = System.currentTimeMillis();
        // Print nao entra no contagem de tempo
        System.out.println("result testSimpleDateFormat = " + result);
        return t2 - t1;
    }

    public static long testDateTimeFormat(final DateTimeFormatter dtf, final String strDate) {
        DateTime result = null;
        int i;
        long t1 = System.currentTimeMillis();
        for (i = 0; i < OPERACOES; i++) {
            result = dtf.parseDateTime(strDate);
        }
        long t2 = System.currentTimeMillis();
        // Print nao entra no contagem de tempo
        System.out.println("result testDateTimeFormat = " + result);
        return t2 - t1;
    }
}

Sa�da:

result testSimpleDateFormat = Sun Oct 10 00:00:00 BRT 2010
result testDateTimeFormat = 2010-10-10T00:00:00.000-03:00

1� Execuç�o:

SimpleDateFormat: Tempo m�dio decorrido = 2.486 milisegundos
DateTimeFormatter Tempo m�dio decorrido = 1.95 milisegundos

2� Execuç�o:

SimpleDateFormat: Tempo m�dio decorrido = 2.477 milisegundos
DateTimeFormatter Tempo m�dio decorrido = 2.148 milisegundos

3� Execuç�o:

SimpleDateFormat: Tempo m�dio decorrido = 2.702 milisegundos
DateTimeFormatter Tempo m�dio decorrido = 1.922 milisegundos

4� Execuç�o:

SimpleDateFormat: Tempo m�dio decorrido = 2.544 milisegundos
DateTimeFormatter Tempo m�dio decorrido = 2.002 milisegundos

Esse foi o cen�rio mais equilibrado. Pode-se dizer que as duas abordagens s�o semelhantes em desempenho. J� em relaç�o ao consumo de mem�ria medida pelo JProfile, o DateTimeFormatter � mais eficiente do que o SimpleDateFormat.

SimpleDateFormat n�o � Thread-Safe!

O grande calcanhar de aquiles do SimpleDateFormat � que ele n�o � thread-safe. Isso significa que ele n�o pode ser compartilhado por m�ltiplas threads, o que força os desenvolvedores a instanci�-lo de forma local sempre que for necess�rio utiliz�-lo (as listagens 1 e 3 deixam claro o custo de instanciaç�o). Devemos, portanto, ficar atentos ao usar o SimpleDateFormat em ambiente web, ou aplicaç�es que façam uso de mais de uma thread.

A grande vantagem do DateTimeFormatter e do FastDateFormat � que ambos foram concebidos para serem classes imut�veis, e portanto, thread-safe. Isso garante que eles possam ser compartilhados em ambientes de m�ltiplas threads e podem inclusive serem injetados via Spring no modo Singleton, onde uma �nica inst�ncia pode ser compartilhada por v�rios outros beans do sistema, reduzindo o uso de mem�ria.

De fato, em ambientes concorrentes, pode ser mais interessante usar o DateTimeFormatter do Joda Time, pois ele tem bom desempenho e consumo de mem�ria. O FastDateFormat � limitado a situaç�es onde apenas seja necess�rio operaç�es de formataç�o.

A abordagem da imutabilidade � importante, pois mesmo que as classes que voc� desenvolva agora n�o sejam compartilhadas por v�rias threads, ningu�m pode garantir que no futuro elas n�o sejam. Ent�o, utilizar classes imut�veis no seu desenvolvimento pode ser uma quest�o interessante a ser levada em consideraç�o.

Com isso finaliza-se a comparaç�o entre essas tr�s alternativas. Espero que isso tenha auxiliado o leitor a considerar outras opç�es ao SimpleDateFormat.

Obrigado e at� a pr�xima!

Otimizando a performance da aplica��o ao trabalhar com datas em Java

Veja nesse artigo como otimizar o desempenho de suas aplicações quando se trabalha com datas utilizando alternativas ao SimpleDateFormat.

Introduç�o

Refer�ncias:

Artigos relacionados