Entendendo a Performance em Aplicações Java - FLF

FACULDADE LOURENÇO FILHO
Curso de Ciência da Computação
José Tiago Ribeiro Filho
ENTENDENDO A PERFORMANCE
EM APLICAÇÕES JAVA
Fortaleza – Ceará
Dezembro de 2010

FACULDADE LOURENÇO FILHO
Curso de Ciência da Computação
José Tiago Ribeiro Filho
ENTENDENDO A PERFORMANCE
EM APLICAÇÕES JAVA
Monografia apresentada ao Curso de Ciência da
Computação da Faculdade Lourenço Filho, como
requisito parcial para obtenção do grau de
Bacharel em Ciência da Computação.
Orientador: Prof. MSc. João Frederico Roldan
Viana.
Fortaleza – Ceará
Dezembro de 2010

FACULDADE LOURENÇO FILHO
Curso de Ciência da Computação
Título do Trabalho: Entendendo a performance em aplicações java
Autor: José Tiago Ribeiro Filho
Banca Examinadora
_________________________________
João Frederico Roldan Viana, MSc. (FLF)
Orientador
_________________________________
André Barros Pereira, MSc. (FLF)
1º Membro
_________________________________
Francisco Nauber Góis, MSc. (FLF)
2º Membro
Aprovado em 21 de Dezembro de 2010.

“É melhor tentar e falhar, que
preocupar-se e ver a vida passar.
É melhor tentar, ainda que em vão que
sentar-se, fazendo nada até o final.
Eu prefiro na chuva caminhar, que em
dias frios em casa me esconder.
Prefiro ser feliz embora louco, que em
conformidade viver”.
Martin Luther King.

sabedoria.
mim dada.
orientação.
AGRADECIMENTOS
Agradeço em primeiro lugar a Deus, origem da vida e fonte de
A meus pais pelo estímulo em todos os momentos, e educação a
A meus irmãos que sempre que precisei estiveram ao meu lado.
Ao professor Frederico Viana, pelo incentivo constante e pela segura
E a todos aqueles que, direta ou indiretamente, contribuíram para a
elaboração desta monografia.
Muito Obrigado.

RESUMO
A monografia traz a definição de performance computacional, focando
desempenho em aplicações desenvolvidas em Java, explica aspectos
importantes que influenciam no desempenho tais como: utilização da memória
RAM, tempo de inicialização, escalabilidade e a performance percebida pelo
usuário do sistema. Apresenta uma técnica muito importante para medição de
desempenho, chamada benchmark de desempenho, explica o quanto o seu
uso pode auxiliar o desenvolvedor a ter um acompanhamento de possíveis
mudanças de desempenho no processo evolutivo da aplicação. Fornece uma
visão sobre algoritmos e estruturas de dados, como sua escolha pode
influenciar muito na velocidade de um software, define garbage collection, sua
importância para bom funcionamento da aplicação e traz uma visão sobre
arquitetura da maquina virtual HotSpot.

ABSTRACT
The monograph has a definition of computational performance, focusing on
performance in applications developed in Java, explains important aspects
influencing the performance such as: use of RAM, startup time, scalability and
performance as perceived by the user of the system. Presents a very important
technique for measuring performance, called performance benchmark, explains
how their use can help the developer to have a monitoring of possible changes
in performance in the evolutionary process of the application. Provides an
overview on algorithms and data structures, such as your choice can greatly
influence the speed of a software defined garbage collection, its importance for
proper functioning of the application and provides an insight into the
architecture of the HotSpot virtual machine.

SUMÁRIO
1 – INTRODUÇÃO . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
1.1 Motivação . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
1.2 Objetivos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
1.3 Estrutura da Monografia. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
2 – DEFINIÇÕES DE PERFORMANCE . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
2.1 Performance computacional . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
2.2 Utilização de memória RAM . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
2.3 Tempo de inicialização . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
2.4 Escalabilidade . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
2.5 Performance Percebida . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
3 – TÉCNICAS PARA MEDIR PERFORMANCE . . . . . . . . . . . . . . . . . . . . 19
3.1 Benchmarking . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
3.2 Profiling . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
3.2.1 Usando Hprof e Perfanal. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
4 – RELAÇÃO DE PERFORMANCE COM A IMPLEMENTAÇÃO DE
ALGORITIMOS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
5 – RELAÇÃO DE PERFORMANCE COM ESTRUTURAS DE DADOS . . 32
6 – PARTICULARIDADES DO JAVA . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
6.1 Garbage collection. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
6.2 Java HotSpot Virtual Machine. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43
CONCLUSÃO . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45
REFERÊNCIAS BIBLIOGRAFICAS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47
29

LISTA DE FIGURAS
Figura 1 – Representação da memória Usada, Livre e o total
perante o HEAP da JVM . . . . . . . . . . . . . . . . . . . . . . . . . .
Figura 2 – Gerenciador de Tarefas do Windows XP. . . . . . . . . . . . . . 14
Figura 3 – Sistema Não Escalar . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
Figura 4 – Sistema Escalar . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
Figura 5 – Comparação entre Desempenho computacional e
Performance percebida . . . . . . . . . . . . . . . . . . . . . . . . . . .
Figura 6 – Técnica de sincronização. . . . . . . . . . . . . . . . . . . . . . . . . . 21
Figura 7 – Simula o teste do cronômetro. . . . . . . . . . . . . . . . . . . . . . . 22
Figura 8 – Recriação da classe teste com o uso da classe
cronômetro. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Figura 9 – Método recursivo para inverter String . . . . . . . . . . . . . . . . 30
Figura 10 – Exceção lançada após estouro de pilha. . . . . . . . . . . . . . . 30
Figura 11 – Diagrama de classe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
Figura 12 – Fábrica de Sincronismo . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
Figura 13 – Benchmark para testar o desempenho de diversos tipos
de coleções . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Figura 14 – Arquitetura da maquina virtual . . . . . . . . . . . . . . . . . . . . . . 44
13
18
23
37

1 – Introdução
O presente trabalho irá discorrer sobre desempenho de aplicações
desenvolvidas na linguagem Java, irá definir o que é performance e como ela é
percebida pelo usuário, apresentará boas práticas para o desenvolvedor não
sofrer com perca de desempenho, assim como utilizar técnicas e ferramentas
para medir a velocidade da aplicação e se existem objetos ou métodos
consumindo muitos recursos de memória, apresentará vantagens e
desvantagens de se utilizar algumas estruturas de dados bem como algoritmos
e explicará a importância do coletor de lixo na performance final do software.
1.1 Motivação
A motivação para discorrer sobre este assunto é auxiliar aos
desenvolvedores que trabalham com a linguagem Java a entender os
malefícios de uma aplicação mal estruturada, fazer com que passe a observar
o “todo” e não só uma pequena parte do código quando se está em fase de
desenvolvimento, adquirir o hábito de realizar testes de desempenho e sempre
buscar a excelência em se tratando de velocidade do software.
Hoje em dia devido à grande complexidade de funcionalidades
exigidas quando se desenvolve um software, torna-se cada vez mais
importante a otimização do tempo de processamento ao realizar tarefas. O que
acontece é que grande parte dos desenvolvedores de softwares ainda não
atentaram para o estudo e analise de como melhorar o tempo de
processamento de uma aplicação. Um tempo perdido a mais no planejamento
do software para escolher os algoritmos e estruturas de dados adequadas para
cada tarefa pode ser revertido em ganho de performance e tempo mais a frente
9

no decorrer do projeto, pois reduzirá tempo e gastos com refatoração de código
para tentar melhorar o desempenho do sistema.
1.2 Objetivos
O objetivo deste trabalho é explicar o que é desempenho e qual a
importância de ter uma aplicação com grau satisfatório de performance, assim
como ensinar técnicas para medir a velocidade de métodos, algoritmos e
estrutura de dados usados quando se desenvolve na linguagem Java.
1.3 Estrutura da Monografia
Esta monografia está dividida em seis capítulos. O primeiro traz a
introdução, motivação e a estrutura deste trabalho; o segundo capítulo aborda
a performance, utilização de memória RAM e como pode-se medir o seu
consumo em aplicações Java; trata também de tempo de inicialização e
escalabilidade bem como a performance percebida pelo usuário quando está
usando um sistema; o terceiro capítulo trata de técnicas para medir
desempenho quando se está desenvolvendo um sistema, explica o que é
benchmark e como fazer uso dele para melhorar a aplicação, explica a
importância de ferramentas de perfis e apresenta dois tipos que acompanham
a plataforma Java; no quarto capítulo é explicado como a escolha errada do
algoritmo pode influenciar no produto final do software; No quinto capítulo
serão apresentadas algumas estruturas de dados utilizadas no Java, bem
como suas vantagens, desvantagens e onde elas podem ser melhor
aproveitadas; por último o sexto capítulo explica como funciona o coletor de
lixo, sua importância e o que ele afeta em se tratando de desempenho de uma
aplicação; descreve também a máquina virtual Hotspot, desenvolvida pela Sun,
explicando um pouco de sua arquitetura e ensinando alguns parâmetros de
configuração da mesma .
10

2 – Definições de Performance
2.1 Performance Computacional
Performance computacional, ou desempenho computacional, é um
termo que se refere afim de descrever uma metodologia onde analisa-se o
sistema com o objetivo de melhorar a capacidade de produção, eliminando
ações desnecessárias que reduzem a capacidade computacional global do
sistema (MANGAN, 2008, p.2).
Capacidade computacional é á quantidade total de trabalho útil que
pode ser realizado em um sistema em um determinado período fixo de tempo.
São planilhas recalculadas, os relatórios gerados, os trabalhos de impressão, a
rotação de uma imagem 3D, ou apenas jogando paciência se o sistema não é
bloqueado (MANGAN, 2008, p.2).
Os algoritmos implementados pelos desenvolvedores assim como a
estrutura de dados escolhida são alguns dos principais fatores que podem
afetar o desempenho global de uma aplicação. Acontece que isso é apenas
uma parte no quadro de desempenho para quem quer realmente produzir um
software de alta performance.
Para compreender os diferentes tipos de problemas que podem ser
encontrados na hora do desenvolvimento, devem-se considerar todos os
diferentes aspectos do desempenho computacional (WILSON, 2001, p.3). Além
da Performance computacional temos:
• Utilização da Memória RAM
• Tempo de inicialização
11

• Escalabilidade
• Performance Percebida
2.2 Utilização da Memória RAM
A quantidade de memória necessária para executar o software pode
ser de uma importância crucial para o desempenho global do sistema.
Todos os sistemas operacionais modernos fornecem um sistema de
memória virtual onde o espaço em disco pode ser utilizado no lugar de uma
RAM física. Contudo mesmo o disco mais rápido, é muito mais lento que o
modulo de memória mais lento com isso os aplicativos acabam forçando o
Sistema Operacional a ter um fraco desempenho na paginação da memória
virtual.
É muito comum um sistema ter um bom desempenho na época de
desenvolvimento e esse desempenho cair quando é implantado no cliente
(WILSON, 2001, p.53).
Isso pode ocorrer porque muitas vezes os desenvolvedores
possuem uma maquina mais robusta que as do usuário, consequentemente um
software que roda mais confortavelmente na maquina do desenvolvedor, pode
vir a ter um fraco desempenho no terminal do usuário.
É preciso desenvolver o software com uma configuração alvo em
mente, algumas medidas devem ser pensadas antes de começar a
desenvolver algum software, tem que se imaginar que a sua aplicação poderá
não ser a única em execução na maquina do usuário, usuários geralmente
mantém duas ou três aplicações rodando ao mesmo tempo, Não é interessante
que um programa consuma todos os recursos da maquina do usuário.
A API Java contém alguns mecanismos que ajudam a descobrir
quanto de memória RAM seu programa esta consumindo.
12

Existem dois métodos na classe Java.lang.Runtime que ajudam a
dar uma idéia de quanta memória esta sendo consumida, esses métodos
verificam o tamanho do Heap na maquina virtual Java (WILSON, 2001, p.53).
• Runtime.totalMemory – retorna o tamanho (em bytes) da pilha
usada para alocar os objetos.
• Runtime.freeMemory – retorna a quantidade de memória que não
esta sendo usada na pilha de objetos
Para descobrir se os objetos estão consumindo muito espaço na
memória é feito um calculo simples, subtrai-se a memória livre do total de
memória como demonstrado na figura 1.
Figura 1: Representação da memória Usada,
Livre e o total perante o HEAP da JVM.
Fonte: Wilson, 2001
Esse método de inspeção de memória e útil em varias situações,
como para averiguar o uso da pilha do programa em intervalos regulares de
tempo a fim de descobrir se está ocorrendo vazamento de memória se o uso
da pilha fica aumentando ao longo do tempo.
13

O Java não fornece nenhum método para verificar a velocidade do
programa, para medir com precisão a velocidade do seu aplicativo Java é
preciso apelar para utilitários específicos de uso do Sistema Operacional.
O Windows XP, por exemplo, fornece uma ferramenta chamada
Gerenciador de tarefas que nos fornece informações do uso de memória pelos
processos que estão em execução (ver Figura 2).
Figura 2: Gerenciador de Tarefas do Windows XP
Fonte: Elaborado pelo autor
Vários outros fatores contribuem também para o desempenho do
sistema e um melhor aproveitamento da memória e devem ser analisados com
muita calma pelo desenvolvedor (WILSON, 2001,p.53).
• Objetos
• Classes
• Tópicos
• Estrutura Nativa de Dados
• Código Nativo
14

O consumo de memória relativa desses itens varia de acordo com a
aplicação, plataforma ou ambiente de execução, porém objetos e classes
requem um pouco mais de atenção, pois normalmente são os que consomem
mais memória, o seu consumo varia de aplicativo para aplicativo.
Por exemplo, aplicações desktop que utilizam interfaces gráficas, as
classes tendem a utilizar mais a memória da maquina-cliente pelo fato de que
para iniciar uma interface gráfica sejam necessárias várias classes, já uma
aplicação web utiliza a memória mais com objetos, pois geralmente criamos
mais objetos para trafegarem as informações entre a Web (WILSON, 2001,p.53).
2.3 Tempo de Inicialização
Historicamente os sistemas desenvolvidos em Java possuem um
tempo de inicialização mais lento (WILSON, 2001, p.24).
O tempo de inicialização de um aplicativo é medido pelo tempo que
ele leva para levantar o serviço, carregar e ficar pronto para o usuário utilizar,
isso inclui tanto o tempo de inicialização da JVM como do aplicativo Java em si.
Para medir o tempo de inicialização de uma aplicação Java o
desenvolvedor pode fazer uso de dois métodos contidos na API Java (ORACLE,
2009, p.26-3).
• System.nanoTime(): retorna um valor em nano segundos.
(recupera o valor do Sistema Operacional).
• System.currentTimeMillis(): retorna o tempo atual em
milissegundos.
O Tamanho da pilha também influencia no tempo de inicialização da
JVM e da aplicação, isso porque a máquina virtual reserva um espaço na
memória para o tamanho máximo da pilha (-Xmx) e compromete a memória
com o tamanho da pilha inicial (-Xms).(ORACLE, 2009, p. 10-2).
15

Para aplicações de grande porte é inevitável ter essas duas
variáveis definidas com valores muito altos, mas para uma aplicação de
pequeno ou médio porte valores altos podem ocasionar uma lentidão
desnecessária na inicialização da máquina virtual. Por outro lado se a pilha
está definida com um valor muito pequeno ela vai ocasionar uma sobrecarga
na inicialização da maquina virtual, consequentemente forçará a mesma a
realizar constantes coletas de lixo ate que a pilha tenha crescido a um tamanho
razoável.
2.4 Escalabilidade
Escalabilidade é a capacidade de o sistema permanecer operando
de forma efetiva mesmo diante de um aumento significativo do número de
usuários ou/e de recursos disponíveis. É uma característica almejada por todos
que estão desenvolvendo um sistema e está ligada ao desempenho da
aplicação (MOREIRA, 2009, p.3).
A aplicação pode ter um ótimo desempenho quando enfrenta a
concorrência de 100 acessos simultâneos mais será que ela conseguirá
suportar um aumento de acessos na ordem 100 vezes. As figuras 3 e 4
mostram a diferença de tempo entre um sistema escalar e um não escalar.
Figura 3: Sistema Não Escalar
Fonte: Wilson, 2001
16

Figura 4: Sistema Escalar
Fonte: Wilson, 2001
O tempo de resposta sofre um aumento quase que exponencial
quando o número de usuários do sistema cresce em uma aplicação Não
Escalar o que torna praticamente inviável o seu uso. (figura 3)
Já em um sistema Escalar, o aumento no tempo de resposta é bem
menor, devido à sua característica de se readaptar de acordo com a demanda
(figura 4).
Faz-se necessário antes de implantar um sistema no cliente, sempre
submetê-lo a testes de Desempenho com uma carga aproximada de acessos
concorrentes para que se tenha uma real noção de seu desempenho quando o
mesmo realmente estiver em pleno funcionamento.
É importante estar ciente dos principais problemas de escalabilidade
e desenhar um sistema que esteja preparado para um eventual crescimento
futuro, existem algumas boas praticas no Java que ajudam a construir uma
aplicação preparada para expansão um deles é o encapsulamento que Craig
Larman (2003) define como:
“um mecanismo usado para ocultar os dados, a estrutura interna e
detalhes de implementação de um objeto”
17

O encapsulamento propõe que se isole a estrutura interna dos
Objetos do resto do programa, por isso seu uso é muito aconselhado em
sistemas escalares e de alto desempenho, a vantagem que ele traz é de se
poder avaliar rapidamente diferentes algoritmos e estruturas de dados, como
também evoluir facilmente o projeto para acomodar requisitos novos ou
alterados (WILSON, 2001, p.12).
2.5 Performance Percebida
Performance percebida esta ligada com a percepção do ser humano
sobre o desempenho do software, muitas pessoas da área de tecnologia da
informação confundem desempenho computacional com performance
percebida, esses são dois estudos diferentes enquanto o desempenho
computacional age mais em cima do desempenho do software(apesar de
poder afetar o usuário em si), a percepção de performance pensa somente no
usuário (MANGAN, 2008, p2). O processo de reflexão e análise do desempenho
percebido tem vários objetivos. A figura 5 retrata as diferenças entre
desempenho computacional e performance percebida.
Figura 5: Comparação entre Desempenho computacional
e Performance percebida
Fonte: Mangan, 2008
18

3 – Técnicas para Medir Performance
3.1. Benchmarking
Benchmarking é o processo de comparação de operações de uma
maneira que produza resultados quantitativos. Ele desempenha um papel
fundamental para garantir uma boa execução do software. Os processos a
serem comparados podem ser desde dois algoritmos diferentes que produzem
o mesmo resultado, ou duas maquinas virtuais executando o mesmo código
(WILSON, 2001, p.21).
O aspecto fundamental do benchmarking é a comparação. Um único
resultado produzido por ele não tem muito valor, só é válido quando ocorre a
comparação. Benchmarks tipicamente medem a quantidade de tempo que se
leva para realizar uma tarefa específica, mas também podem ser usadas para
medir outras variáveis tais como a quantidade de memória necessária para
realizar determinada tarefa.
Existe uma técnica de benchmarking simples e útil que pode ser
usada para medir o desempenho de um software. Chama-se Cronômetro
Benchmarking. Como o próprio nome já sugere, essa técnica consiste em
medir a performance com um cronômetro na mão e apesar de não ter a
precisão de milissegundos, ela é bastante útil em diversas situações, como as
listadas abaixo (WILSON, 2001, p.21).
• Medir quanto tempo demora ao lançar um aplicativo
• Medir o tempo que se leva para abrir um documento grande
• Medir o tempo que se leva para percorrer uma tabela muito
grande de dados
19

• Medir quanto tempo leva para executar uma consulta de uma
tabela de banco de dados complexa.
A tabela abaixo faz um comparativo das vantagens e desvantagens
de usar o cronometro benchmarking na medição de desempenho de um
software:
Prós Contras
Fácil Pode ser Impreciso
Não precisa modificar fonte código ou
a utilização de instrumentos
complexos de software
Difícil de automatizar os testes
Não vai distorcer os resultados Sujeito a erro humano
Outra técnica recomendada para uma ampla variedade de situações
é a de adicionar a funcionalidade de sincronismo ao código que está sendo
avaliado. No Java existe a classe java.lang.System que contem vários métodos
estáticos uteis incluindo um método chamado currentTimeMillis. Esse método
retorna uma variável do tipo long que contém o número de milissegundos que
se passaram desde a meia noite do dia 01 de janeiro de 1970. Portanto para
usar esse método para descobrir quanto tempo uma determinada parte do
código demora a ser executada, é necessário armazenar o tempo antes e após
a seção de código que se quer testar, e depois subtrair o tempo final do inicial.
A figura 6 mostra o exemplo dessa técnica em uma classe Java (WILSON, 2001,
p.21).
20

Figura 6: Técnica de sincronização
Fonte: Elaborado pelo autor
Essa técnica essencialmente é o mesmo que usar um cronômetro
exceto que o computador inicia e para o relógio automaticamente e também faz
com que o teste fique automatizado, o que acaba reduzindo o percentual de
erro no resultado do teste.
Uma boa prática para esse tipo de técnica consiste no
encapsulamento, ou seja, criar uma classe que emule o comportamento do
cronômetro (figura 7) e fazendo uso dela na parte de código que se deseja
testar, isso facilitará a vida do desenvolvedor alem de seguir um dos princípios
da Orientação a Objeto que é reutilização de código, pois não terá que replicar
o mesmo tipo de teste em diferentes partes do programa e também exclui
possíveis erros que poderiam vir a acontecer por desatenção na hora de
escrever o teste. A figura 8 demonstra como ficaria o teste anterior, agora
fazendo uso de uma classe cronômetro.
21

Figura 7: Simula o teste do cronômetro
Fonte: Elaborado pelo autor
22

Figura 8: Recriação da classe teste com o uso da classe cronômetro
Fonte:Elaborado pelo autor
Existem várias ferramentas de benchmarks criados pelas
comunidades de desenvolvedores Java, projetados para comparar
implementações em tempo de execução que podem ser uteis na hora de testar
o desempenho de um software. Alguns exemplos dessas soluções são
(WILSON, 2001, p.21):
• SpecJvm2008 – desenvolvido pela Standard Performance
Evaluation Corporation (SPEC) é utilizado para medir o
desempenho de diferentes maquinas virtuais Java.
• VolanoMark – desenvolvido pela Volano, permite determinar a
conexão e as limitações de desempenho do hardware, sistema
operacional e plataforma Java.
• SciMark – desenvolvido por Roldan Pozo e Bruce Miller , tem
como finalidade medir o desempenho de códigos numéricos que
ocorrem na engenharia e aplicações cientificas.
• CaffeineMark – desenvolvido pela Pendragon Software
Corporation, consiste em uma serie de testes que medem a
velocidade dos programas Java rodando em vários hardwares e
softwares de configurações diferente.
23

Embora essas soluções sejam ótimas para avaliar a aplicação em
tempo de execução, faz-se necessário a criação de benchmarks específicos
para avaliar o desempenho do software, ou seja, que testem seu próprio
código, as vantagens desse tipo de abordagem são que se pode comparar
desempenho de soluções alternativas, acompanhar o desempenho e realizar a
analise de tendência ao longo do ciclo de desenvolvimento.
A comparação, aliás, é o uso mais óbvio dos benchmarks
personalizados, por exemplo, quando o desenvolvedor precisa escolher entre
dois algoritmos para implementar determinada função, então ele pode criar um
ponto de referência e comparar as duas soluções.
Uma das grandes vantagens dos benchmarkings é que se pode
acompanhar e analisar as tendências do programa ao longo do
desenvolvimento, com isso ao adicionarmos novas funcionalidades ou
corrigirmos erros encontrados no meio desse processo, pode-se facilmente
descobrir o quanto a aplicação ficou mais lenta e ter o real controle de onde
isso está ocorrendo.
Benchmarks podem ser divididos em duas categorias, micro-
benchmarks e macro-benchmarks (WILSON, 2001, p.21):
• Micro-Benchmarks – são micro-pontos de referência que muitas
vezes podem ser escritos em poucas linhas de código e são
tipicamente muito fáceis de descrever.
• Macro-Benchmarks – Realizam testes no sistema como o usuário
final vai vê-lo. Para construí-lo é preciso entender como o cliente
irá utilizar o produto.
Saber analisar e interpretar os resultados gerados nos testes é
essencial, é preciso ter em mente que eles geralmente variam de execução
para execução, para facilitar a analise é recomendável realizar diversas tiradas
de tempo, após colher os dados com tempos diferentes precisa-se realizar a
analise estatística, existem muitos tipos de estatísticas que podem ser uteis,
24

mas é recomendável que se determine três números chaves, para o melhor
caso, pior caso e processo médio, para informar o pior caso basta pegar o pior
tempo, o melhor caso pega-se o melhor tempo e o processo médio tira-se uma
media do tempos colhidos. Como benchmark sustenta-se em comparações
deve-se fazê-las ao logo do desenvolvimento do sistema para que possa
acompanhar as mudanças de desempenho.
3.2. Profiling
Profiling é uma forma dinâmica de analisar um determinado
programa, ou seja, é uma forma de investigar o comportamento de um
programa usando informações recolhidas após a execução do mesmo. O
objetivo dessa análise é detectar quais seções de um programa precisam ser
otimizadas, seja para aumentar a velocidade geral ou diminuir o uso da
memória, ou ás vezes ambos.
Ferramentas de profiling devem ser capazes de responder algumas
perguntas, tais como: quais os métodos que são utilizados com maior
frequência, quais métodos estão chamando os métodos mais utilizados, quais
o métodos estão alocando mais memória, qual a percentagem de tempo que
cada método e utilizado. Essas ferramentas são na maioria das vezes ricas em
interfaces e permitem que possa escolher que tipo de teste deseja-se realizar.
Profiling pode ajudar ao desenvolvedor identificar se existe algum
método critico na aplicação, se este esta tomando a maior parte do tempo de
processamento da mesma, então o desenvolvedor poderá direcionar seu
esforço para melhorar o desempenho do método avaliado (WILSON, 2001, p.21).
Existem dois tipos de abordagens para otimizar a aplicação a qual o
desenvolvedor pode fazer uso quando descobre onde esta ocorrendo a queda
de desempenho do sistema (WILSON, 2001, p.21).
• Fazer com que métodos que sejam utilizados com maior
frequência tornem-se mais rápidos
25

• Fazer com que métodos mais lentos sejam chamados com menor
frequência.
Muitas vezes programadores partem logo para a primeira alternativa,
sendo que às vezes é mais fácil descobrir o porquê do método ser chamado
com muita freqüência e com isso tentar diminuir o numero de vezes que esse
método é acessado.
Ferramentas de profiling são interessantes para descobrir o quanto
de objetos seu programa tem, e quanto os mesmos estão consumindo de
memória, fazendo com que o programador tente minimizar a criação de
objetos, muitas vezes a uma relação entre métodos que utilizam muitos objetos
e métodos que são chamados várias vezes na aplicação, sempre é bom
verificar se todos os objetos criados no método são realmente necessários. Um
exemplo comum de criação de muitos objetos em um método e que com o uso
dessas ferramentas o programador pode minimizar é quando um método cria
um objeto dentro de um laço de repetição, a cada interação será criado um
novo objeto, e esse vai sendo alocado na pilha de objetos da jvm fazendo com
que o desempenho da aplicação caia, podendo gerar até um estouro de pilha,
movendo a criação para fora do laço faz com que o consumo de memória seja
reduzido.
O vazamento de memória também é um dos problemas críticos
quando se está desenvolvendo um sistema, vazamento de memória ocorre
quando a memória é alocada, mas não é liberada, embora a maquina virtual
Java seja responsável pela liberação de memória através do garbage collector,
a mesma não garante que horas isso ocorrerá, o que pode atrapalhar o
desempenho do sistema (WILSON, 2001, p.21).
O isolamento do vazamento de memória pode ser uma tarefa muito
difícil, é ai que o uso de profiling pode tornar-se uma arma a favor do
desenvolvedor, as ferramentas são bastante uteis para:
• Acompanhar o numero de instâncias de todas as classes em
determinado momento.
26

• Isolar um determinado objeto e ver todas as referências que
apontam pra ele.
• Coleta manual de lixo perdido.
A primeira etapa para isolar o vazamento é colocar o programa em
um estado de stress, ou seja, testá-lo com sua capacidade máxima, após isso,
deve-se realizar varias operações para certificar-se se todos os tempos gastos
na inicialização foram computados e que todos os objetos necessários foram
carregados, após isso retorna o programa ao estado normal, e faz-se um
comparativo de desempenho quando o mesmo estava submetido a sua
capacidade máxima. Depois, deve-se usar uma ferramenta de análise para
determinar o numero de anomalias existentes em cada classe, com o resultado
da analise em mãos deve-se fazer o uso da ferramenta de profiling para
processar todo o lixo disponível. Então, volta-se a usar o sistema em modo de
stress e depois em modo normal, para que sejam feitas novas comparações,
se terminado os testes os tempos de processamento e desempenho
continuarem quase iguais é sinal que a limpeza de lixo foi bem sucedida.
3.2.1 Usando HPROF e PERFANAL
Hprof é uma ferramenta de profiling para criação de estatísticas
sobre o desempenho da CPU e da pilha, ele é um agente incorporado a JVM
que é carregado dinamicamente através de linha de comando na sua
inicialização e torna-se processo da mesma. Ao fornecer opções HPROF na
inicialização, os usuários podem solicitar vários tipos de pilha e / ou recursos
de CPU profiling HPROF. Os dados gerados podem ser em forma de texto ou
binário, e podem ser usados para rastrear e isolar problemas de desempenho
que envolve o uso de memória e de código ineficiente. O arquivo de formato
binário do HPROF pode ser usado com ferramentas como HAT (Heap Analysis
Toll) para procurar os objetos alocados no HEAP (O'HAIR, 2004).
A partir da versão cinco do J2SE o HPROF passou a ser
implementado na nova JVM TI (Java Virtual Machine Tool Interface), ele é
27

capaz de apresentar estatísticas sobre alocação da pilha e monitorar os perfis
de contenção.
Perfanal é uma ferramenta baseada em GUI (Interface Gráfica para
Usuário) para analisar o desempenho de aplicações na plataforma Java, ele é
usado para identificar problemas de desempenho no código e localizar o código
que precise de ajustes, ela é uma ferramenta livre, licenciada pela GPL
(MEYERS, 2000).
O Perfanal tem a característica de simplificar bastante a analise do
desempenho por que ele interpreta os dados do perfil analisado e informa o
custo total dos métodos, ele apresenta os resultados em forma de gráfico o que
ajuda a análise.
28

4 – Relação de Performance com Implementação de
Algoritmos
Escolher o algoritmo correto é um fator primordial para obter-se um
grande desempenho da aplicação, se escolher o algoritmo errado todo o ajuste
feito por menor que seja não produzirá ganho de desempenho satisfatório. Um
algoritmo pode ter diferentes comportamentos para diferentes aplicações, ele
pode ser eficiente para algumas situações e deficiente para outras. Não
existem algoritmos que sejam bons para todos os tipos de situações, deve-se
analisar o algoritmo de acordo com o objetivo que se deseja alcançar e
escolher a solução que proporcionar melhores resultados. Para facilitar esse
tipo de escolha deve-se fazer uso de técnicas para comparação de soluções
como a já mencionada Benchmark, após decidir qual algoritmo usar, deve-se
levar o espaço do problema em consideração. Espaço do problema é um
conjunto de problemas com os quais o algoritmo será apresentado, em outras
palavras são as situações com o qual o algoritimo irá se deparar para que
consiga resolver um determinado problema. Muitas vezes pode-se atingir a
solução mais eficiente restringindo o algoritmo a tratar apenas o problema do
espaço definido em vez de usar o algoritmo mais geral, ou seja, o que o
programa não vai fazer é tão importante quanto ao que o programa faz.
Algoritmos recursivos podem ser usados em muitos casos para
resolver problemas lineares complexos, mas ela pode ser uma pratica não
muito recomendada em se tratando de algoritmos com muitas chamadas a
função recursiva, com isso ocorre o aumento de consumo de memória e
consequentemente a performance da aplicação diminui.
29

Cada chamada sucessiva de uma função recursiva cria um novo
quadro de pilha, se a função é chamada muitas vezes também pode fazer com
que o programa funcione com a memória sobrecarregada. O exemplo disso é o
algorítimo usado para inverter uma string (figura 9)
Figura 9: Método recursivo para inverter String
Fonte: Elaborado pelo autor
Se passarmos uma seqüência muito grande de strings para o
algoritmo inverter ele pode gerar um erro de estouro de pilha
(stackoverflowerror) conforme a figura 10.
Figura 10: Exceção lançada após estouro de pilha
Fonte: Laskowski, 2010
Algoritmos não são apenas soluções bem definidas para tarefas
normais, ao construir uma aplicação o desenvolvedor deve sempre perder um
tempo a mais para analisar o algoritmo correto que utilizará, pois a escolha
30

errada no começo pode fazer com que todo o sistema tenha um desempenho
não satisfatório.
31

5 – Relação de Performance com Estruturas de
Dados
A seleção de estrutura de dados adequada é tão importante quanto
a escolha do algoritmo. As estruturas de dados são normalmente conhecidas
como vetores, listas, filas etc. A plataforma Java possui suas próprias
implementações para algumas estruturas tais como ArrayList (listas), LinkedList
(filas) SortedList( lista ordenada). Todas essas classes são implementações da
interface Collection (coleções).
Coleção é um objeto que agrupa múltiplos elementos em uma única
unidade e são usadas para armazenar, recuperar e manipular dados. Ela
também é usada para transmitir dados a partir de um método para
outro. Coleções normalmente representam itens de dados que formam um
grupo natural, tais como (WILSON, 2001, p.122).
• Coleção de carros em uma concessionária.
• Coleção de livros de uma biblioteca.
• Coleção de animais em um zoológico.
A sua estrutura de uma coleção é composta de uma arquitetura
unificada para representar e manipular coleções trazendo a vantagem de
reduzir o esforço de programação, aumentando a performance. A estrutura foi
projetada para:
• Promover o reuso de software.
• Reduzir o esforço na concepção e de aprender novas APIs.
• Habilitar a coleta de dados a ser manipulado independente da sua
representação.
• Facilitar a interoperabilidade entre APIs independentes.
32

Coleções oferecem uma alta performance aliada com uma
implementação de ótima qualidade das estruturas de dados, coleções ajudam a
melhorar a qualidade e desempenho do software (WILSON, 2001, p.122). Por
ser uma estrutura pronta e desenvolvida para que o programador não utilize
seu tempo implementando funcionalidades para melhorar o desempenho, ou
seja, reescrevendo uma estrutura que já existe e está otimizada. O uso dela
acaba facilitando a vida do desenvolvedor para que ele utilize o seu tempo para
dedicar-se a melhoria da qualidade e desempenho do resto da aplicação. Sua
estrutura e baseada em seis interfaces como demonstrado no diagrama de
classes contido na figura 11.
Figura 11: Diagrama de classe
Fonte: Elaborado pelo autor
Cada tipo de estrutura de dados se adéqua mais a determinado tipo
de tarefa, entender o que cada estrutura de dados faz ajuda ao desenvolvedor
na escolha de qual será a melhor para resolver seu problema,
conseqüentemente ajudará a obter um maior desempenho da aplicação. Para
algumas interfaces, a estrutura oferece múltiplas implementações concretas.
A lista (List) é uma interface que estende de Coleção, ela é
ordenada e pode conter elementos repetidos, ao usar uma lista o
desenvolvedor tem o pleno controle sobre onde cada elemento é inserido,
33

pode-se acessar os elementos de uma lista só pelo seu índice (WILSON, 2001,
p.122).
Muitas vezes quando se deseja utilizar uma lista no Java faz-se o
uso do ArrayList por ser bastante rápido em algumas situações como itera-la e
por não ter de atribuir um objeto do nó para cada elemento da lista, ele usa o
método nativo System.arraycopy para mover vários elementos
simultaneamente. Um ArrayList é essencialmente um vetor sem o overhead de
sincronização (WILSON, 2001, p.122).
LinkedList é outro tipo de implementação da classe List e usado para
quem deseja adicionar elementos no inicio da lista ou iterar a lista e excluir
elementos do seu interior, o tempo que se leva para percorrer uma lista e maior
que no ArrayList, em compensação ele ganha quando deseja-se inserir e
excluir elementos em qualquer local da lista (WILSON, 2001, p.122). A melhor
maneira de escolher qual implementação irá usar e criar um benchmark
idêntico ao problema encontrado no seu programa e medir o tempo gasto para
realizar a operação.
Um Set é uma coleção que não pode conter elementos duplicados,
ela é uma abstração matemática dos conjuntos. Existem duas classes que
estendem da interface Set, que são HashSet e SortedSet a diferença é que a
HashSet é bem mais rápida mas não garante ordenação, se precisar de
garantia de ordenação deve-se usar a classe SortedSet ou TreeSet (WILSON,
2001, p.122).
Recomenda-se ao trabalhar com HashSet que escolha uma
capacidade inicial compatível com a atividade que deseja-se realizar, se
escolher uma capacidade muito alta pode-se desperdiçar espaço bem como
tempo. A capacidade inicial é de 101 elementos, no geral costuma-se escolher
uma capacidade duas vezes o tamanho que espera-se que o conjunto cresça
(WILSON, 2001, p.122).
34

HashSets possuem um parâmetro de ajuste, chamado de fator de
carga. Esta é uma medida de quanto é permitido que o HashSet obtenha de
sua capacidade para aumentá-la automaticamente. Quando o número de
inscrições excede o produto do fator de carga e da capacidade atual, a
capacidade será dobrada. Geralmente, o fator de carga padrão (0,75) oferece
uma boa performance levando em conta custos e espaço de tempo (WILSON,
2001, p.122).
Existem duas classes no Java que são sincronizadas a HashTable e
a Vector, por padrão as classes de coleções não são sincronizadas fazendo
com que o acesso a essa estrutura seja mais rápido quando se usa Threads no
mesmo ambiente. Já as coleções sincronizadas fazem uso do conjunto de
classes Wrapper.
Essas classes adicionam funcionalidades a implementação padrão
das coleções, as implementações Wrapper são anônimas, fornecem um
método estático que funciona como uma fabrica de sincronismo como pode ser
visto na figura 12.
public static Collection synchronizedCollection(Collection c);
public static Set synchronizedSet(Set s);
public static List synchronizedList(List list);
public static Map synchronizedMap(Map m);
public static SortedSet synchronizedSortedSet(SortedSet s);
Figura 12: Fábrica de Sincronismo
Fonte: Wilson, 2001
Cada método retorna uma fábrica sincronizada que é apoiada por
uma instância do tipo da instância escolhida. Quando se deseja iterar sobre
uma coleção sincronizada o desenvolvedor acaba tendo que sincronizar
manualmente a operação isso ocorre porque a iteração é realizada através de
varias chamadas para a coleção e essas chamadas tem que ser composta por
uma única operação atômica como no exemplo abaixo, se o desenvolvedor não
utilizar essa técnica a iteração pode resultar em um comportamento não-
determinístico.
35

A estrutura de coleções fornece alguns frameworks de algoritmos.
Do ponto de vista de desempenho existem dois: sort e binarySeach. Classificar
e pesquisar são tarefas comuns que podem assumir uma grande parte do
tempo. A estrutura das coleções fornece implementações bem-testadas dessas
tarefas e que possuem as características de desempenho documentadas.
Essas implementações são acessados através de algoritmo estático.
“Framework é um conjunto de classes que colaboram para
realizar uma responsabilidade para um domínio de um subsistema da
aplicação” (Fayad e Schmidt,1997, p.38).
Usando o benchmark é possível ter a real diferença do desempenho
de cada tipo de implementação da interface Collection e ter a noção do impacto
que cada escolha pode ocasionar no desempenho final do sistema. A figura 13
contém um exemplo do uso do benchmark para realizar o teste, no caso o
utilizado foi o Cronômetro já demonstrado no capitulo 2 (figura 7) esse teste foi
feito para medir o tempo decorrido ao adicionar itens a uma coleção, iterar
sobre a coleção e remover itens de uma coleção, e no caso se a interface
passada como argumento do método for uma instancia de List o benchmark
testa a velocidade de acesso á itens aleatórios.
36

Figura 13: Benchmark para testar o desempenho
de diversos tipos de coleções.
Fonte: Elaborado pelo autor
Realizando o teste com cinco implementações diferentes: ArrayList,
LinkedList, Vector, TreeSet, HashSet os resultados obtidos por cada Classe
foram os seguintes:
Classe Iterar Adicionar Remover Random
ArrayList 660 m/s 0 m/s 2360 m/s 0 m/s
LinkedList 1100 m/s 50 m/s 0 m/s 26800 m/s
Vector 880 m/s 0 m/s 2580 m/s 0 m/s
TreeSet 1430 m/s 330 m/s 60 m/s Não é Lista
HashSet 1430 m/s 110 m/s 50 m/s Não é Lista
37

Com os resultados dos testes pode-se perceber o quanto ArrayList e
o Vector por serem estruturas matriciais semelhantes possuem tempos quase
idênticos, sendo diferente somente que Vector possui uma sincronização
padrão o que o faz ter desempenho um pouco mais lento. Se comparar
ArrayList com LinkedList apesar de poderem executar as mesmas operações
percebe-se resultados bem diferentes, onde um é mais rápido o outro e mais
lento e vice versa. Onde obtivemos resultado igual a zero significa que o tempo
foi muito insignificante para o teste.
Com isso comprova-se a importância de escolher a estrutura correta
ao desenvolver-se um software.
38

6 – Particularidades do Java
6.1. Garbage Collection
Garbage Collection ou coleção de lixo é um processo usado para a
automação do gerenciamento de memória. Com ele é possível recuperar uma
área de memória inutilizada por um programa, o que pode evitar problemas
de vazamento de memória, resultando no esgotamento da memória livre para
alocação. A sua grande vantagem é que o desenvolvedor não precisa ficar
preocupado com desalocação de recursos, o próprio coletor de lixo faz uma
varredura no programa e elimina os que não estão sendo usados, sobrando
tempo para pensar em outros detalhes da implementação, outra grande
vantagem é evitar erros humanos ao desalocar um recurso errado, que ainda
estava sendo usado pelo programa, ou liberar uma região de memória mais de
uma vez (JAVAFREE, 2009).
O Garbage Collection é muito importante para um bom desempenho
da aplicação, pois esta diretamente ligada ao custo de alocação e desalocação
de memória. Se uma aplicação consome muita memória forçando assim o
Sistema Operacional a ter que usar a memória virtual ela consequentemente
terá uma perca de performance .
Garbage Collector (coletor de lixo) é um sistema de alocação
automática de objetos na pilha, isso ocorre quando se inicia a JVM (Java
Virtual Machine), ele funciona como um contador, toda vez que um se faz uma
referencia a um objeto ele anota, com isso ele sabe quantos referencias estão
apontando para determinado espaço de memória, quando esse contador atinge
zero o objeto vira um sério candidato a ser varrido da memória, então o
39

Garbage Collector escolherá o momento certo para limpa-lo da pilha. Ele é
nativo, ou seja, varia de JVM para JVM. No Java o desenvolvedor não tem
plenos poderes para mandar o Garbage Collector rodar na hora que ele
desejar, o Máximo que ele pode fazer é tentar induzi-lo a rodar em determinada
hora, o que não é garantia nenhuma que isso acontecerá (ROCHA, 2005a, p.46).
Todo objeto possui um ciclo de vida que começa quando ele é criado
(create), depois passa a ficar em uso (in use), torna-se invisível (invisible),
depois inalcançável (Unreachable), coletado (collected), ele é finalizado
(finalized) e por ultimo termina quando é desalocado (Deallocated).
Quando um objeto é criado um espaço na memória é alocado para
ele, a sua construção é então iniciada, o construtor da superclasse é chamado,
no Java todas as classes herdam da classe pai Object, os iniciadores de
instância e iniciadores de varáveis de instância são executados, então o resto
do corpo do construtor é executado. A criação de um objeto gera custos de
processamento, mas variam de JVM e de como a classe é implementada.
Após o objeto ser criado e ser ligado a uma variável ele passa pra o estado de
“uso”.
O Garbage Collector começa a agir quando o objeto encontra-se no
estado inalcançável, em outras palavras quando não existe nenhuma
referência do tipo strong (forte), ou seja, pode ser alcançado por uma Thread
que seja através de um objeto de referencia, quando ele chega nesse estado,
passa a ser um candidato a ser coletado, apesar de estar pronto para ser
coletado a JVM só o pode fazê-lo quando estiver precisando de espaço na
pilha para alocar outros objetos, então o objeto passa para o estado de
coletado e o garbage collector encaminha para o estado finalizado, quando um
objeto é finalizado ele fica esperando a desalocação.
Se o desenvolvedor quiser aumentar o tempo de vida de um objeto,
ele terá que implementar um método finalizador, isso ocorre pelo fato de toda
instancia da classe ter que chamar o método antes de desaloca-lo.
40

Após o método ser finalizado o garbage collector trata de desaloca-
lo e assim deixar a pilha com mais espaço, quando e como isso ocorre fica por
conta da JVM.
A máquina virtual da Sun utiliza a estratégia de coleta por gerações,
essa estratégia classifica os objetos em vários grupos chamados de gerações,
de acordo com sua idade, a coleta é realizada separadamente em cada
geração e ocorre mais freqüentemente nas gerações jovens, ou seja, no
objetos novos, os objetos que sobrevivem a primeira coleta são promovidos
para a próxima geração, as gerações representam áreas do HEAP a geração
jovem é a área menor, onde é inicialmente alocada a memória para novos
objetos. A geração antiga, ou estável, é uma área maior onde o espaço
alocado não é para novos objetos, mas para acomodar objetos que sobrevivem
a uma ou mais coletas de lixo na área menor (ROCHA, 2005a, p25).
Na versão 1.5 do Java foi inserido um novo recurso chamado de
Ergonomia, ele tem como objetivo proporcionar um bom desempenho á JVM
com um mínimo de linha de comando, ela tenta obter a melhor seleção do
coletor de lixo, tamanho da pilha e compilador de tempo de execução (JIT- Just
in time) (ORACLE, 2003).
Seus ajustes são baseados em duas metas: pausa máxima e
capacidade de processamento mínimo e tem como alvo aplicações que
funcionam em grandes servidores, logo na instalação e na execução ela realiza
os primeiros ajustes automáticos. Na instalação o sistema tenta descobrir se
esta numa maquina de classe Servidor ou Cliente, o parâmetro usado para
avaliar se a maquina é cliente ou servidor é a memória física que no caso deve
conter no mínimo dois gigas e se possui pelo menos duas CPU para o caso de
servidor, se a maquina for servidora ele ira usar a Server JVM, se for cliente
usara Client JVM (ROCHA, 2005b, p.63).
Para configurar as metas de pausa máxima e de capacidade de
processamento mínimo também conhecida como eficiência mínima, o
41

desenvolvedor configura o uso mínimo e máximo da memória do HEAP (pilha),
a partir daí o coletor efetua vários ajustes de parâmetros tais como o tamanho
e proporcionalidade entre a geração jovem, espaços sobreviventes, geração
estável e outros valores, como a alteração da política de promoção para
geração estável, para conseguir bater essa meta, se o coletor não conseguir
bater a meta o usuário pode ir ajustando ate conseguir uma configuração
aceitável para sua aplicação. A ergonomia não trabalha com garantias, ou seja,
ela não garante que as metas serão alcançadas, alguns comandos importantes
para configurar a ergometria no coletor paralelo de alta eficiência são (ROCHA,
2005b, p.65):
• -XX:MaxGCPauseMillis=valor – configura a meta de pausas
máximas, o valor indica a quantidade de tempo em milissegundos
que máxima que o coletor poderá para a aplicação para realizar a
coleta de lixo.
• -XX:GCTimeRatio=n – define a meta de eficiência, n é um valor
normalizado que mede a proporção de tempo dedicado á
aplicação da forma 1:n, um exemplo, se n for igual 15 o tempo
dedicado a aplicação pela maquina virtual será 16(1+15) vezes
mais tempo que a coleta de lixo.
• -XX:+Use AdaptiveSizePolicy – é usado somente se a Server Jvm
estiver com o coletor configurado default, essa opção faz com
que a maquina virtual colete dados e baseia-se por eles para
redimensionar as gerações jovens e antigas
Para fazer-se uso da ergonomia é importante que não se defina um
valor máximo para a pilha, e sim que se escolha uma meta de eficiência que
seja suficiente para a aplicação, pois o sistema aumentará a pilha ate atingir
um valor que irá permitir que se alcance a meta de eficiência esperada.
42

6.2. Java HotSpot Virtual Machine
Java HotSpot Virtual Machine é a máquina virtual Java
implementada pela Sun Microsystems Inc’s. Ela fornece a base da plataforma
Java e utiliza uma tecnologia de otimização dinâmica. Ela possui dois tipos de
versões uma no lado cliente outra no lado servidor. A versão cliente minimiza
tempo de início da aplicação e memória utilizada, enquanto que a versão para
servidor maximiza velocidade de execução da aplicação (ROCHA, 2005b, p.5).
As duas versões possuem:
• Compilador adaptivo.
• Alocação rápida de memória.
• Liberação de memória automática.
• Sincronização de threads escalável.
A VM HotSpot possui diversas implementações de algoritmos para
coleta de lixo baseados em gerações de objetos,a maioria deles utilizam uma
das três estratégias de coleta em paralelo como serial, concorrente e
incremental (ROCHA, 2005a, p.29).
• Serial: ideal para sistemas monoprocessados. Trabalham em
série parando a aplicação para executar uma única Thread na
CPU. Busca eficiência em detrimento de possíveis pausas
longas.
• Incrementais: rodam em Threads de baixa prioridade,
concorrendo com a aplicação sem interrompê-la.
• Concorrente: executa em varias Threads em paralelo, buscando
uma maior eficiência.
A arquitetura da VM HotSpot é dividida em duas partes: tempo de
execução (runtime) e o compilador (compiler). Na área de tempo de execução
existe um interpretador de bytecodes, um gerenciador de memória, o coletor de
lixo e o sincronizador de Threads. O Compilador trabalha com a tradução dos
bytecodes para instruções nativas de maquina, melhorando assim a
performance de execução (WILSON,2001, p.206).
43

Figura 14 Arquitetura da maquina virtual
Fonte: Wilson, 2001
A máquina virtual permite que se tenha um controle sobre suas
configurações, com o objetivo de manter sempre um nível alto de seu
desempenho, toda configuração e feita através de linhas de comando, todos
eles começam com a escrita –x podem ser obtidos através do comando de
ajuda Java –x. Alguns comandos importantes são:
• –Xnoclassgc: desabilita o coletor de lixo.
• –Xms : define o tamanho inicial da pilha de objetos, o
padrão e vir configurado com dois megabytes. Size é onde
configura o novo tamanho, ao aumentá-lo pode-se melhorar o
tempo de inicialização da aplicação.
• –Xmx : define o tamanho Maximo da pilha de objetos, por
padrão ele vem configurado com sessenta e quatro megabytes,
se o programa precisar alocar mais memória que o configurado
ele irá emitir a exceção OutOfMemoryError, o campo size é onde
deve colocar o valor máximo para a pilha de objetos.
• –Xprof: a máquina virtual habilita suas ferramentas de profiling.
O ajuste correto da máquina virtual em grandes aplicações pode
trazer ganhos bastante significativos em se tratando de desempenho. Um
ajuste pode ser simplesmente a seleção da maquina virtual, se ela é servidora
ou cliente, ou a definição manual de parâmetros de funcionamento.
44

CONCLUSÃO
Nesse trabalho foram apresentadas as definições de performance
computacional, a importância da utilização da memória RAM e do tempo de
inicialização de uma aplicação, as diferenças entre sistemas escaláveis e não
escaláveis, o que é performance percebida pelo usuário e porque deve-se
tentar melhora o tempo percebido, assim como boas práticas para medição de
desempenho e como melhorá-lo com uso de estruturas de dados e algoritmos
otimizados.
È muito importante ao desenvolver um software levar em conta o
desempenho final do ponto de vista do usuário. O que se vê em muitas
empresas responsáveis pelo desenvolvimento de aplicações é a falta de
conhecimento ou até de interesse de seus programadores em buscar uma
melhoria do seu algoritmo ou da funcionalidade que esteja codificando no
momento. Muitos deles não se atentaram que um tempo perdido na hora de
planejar um software ou até mesmo uma funcionalidade em sua concepção
pode trazer benefícios extraordinários quando o produto estiver concluído, além
de evitar transtornos futuros quando o produto estiver sendo implantado no
cliente.
É preciso que desenvolvedores tenham conhecimento de como
simples testes aplicados a seus códigos podem descobrir furos enormes no
desenvolvimento, e que essa prática deve-se tornar freqüente para se obter
uma boa qualidade de seu sistema. Para isso é essencial que se faça uso de
técnicas como o benchmark, pois ele poderá identificar o quanto de tempo está
sendo usado em determinada funcionalidade. Benchmarks são simples de
implementar e oferecem uma enorme ajuda na medição de performance.
45

Saber o comportamento em termos computacionais de algoritmos e
estruturas de dados são de grande importância para quem deseja criar um
software robusto e com o mínimo de perdas de performance. O Java oferece
algumas implementações próprias para algumas estruturas, cada uma
recomendada para certo tipo de tarefa. Elas trazem melhorias consideráveis
em termo de tempo computacional.
Entender o funcionamento da maquina virtual e como configurá-la
para obter um melhor desempenho pode fazer com que o software não corra
riscos de um futuro estouro de memória, ou com que o mesmo perca tempo
criando uma pilha de objetos muito maior do que a aplicação irá precisar. A
JVM HotSpot contém diversos comandos que podem ser usados para
aperfeiçoar o seu funcionamento.
Como trabalhos futuros podemos sugerir a avaliação de ferramentas
de profiling, com foco maior em suas funcionalidades e benefícios, assim como
dissecar a maquina virtual HotSpot explicando os diferentes algoritmos que são
usados no coletor de lixo, informando a vantagem de cada um deles e onde e
como é empregado pela VM.
46

REFERÊNCIAS BIBLIOGRÁFICAS
FAYAD, M. & SCHMIDT, C. D., Object-oriented application frameworks.
ACM, 1997.
HDIERKING. Understanding Perceived Performance. 2009. Disponível em:
. Acessado em 16 de outubro de 2010.
JAVAFREE. Garbage Collection. 2009. Disponível em: Acessado em 20 de novembro
de 2010.
LARMAN, C. Utilizando Uml e padrões 2ª edição, Bookman, 2003.
LASKOWSKI, J. Reported issue with ZB300 labs and reading Tasks
chapter in JRules 7 InfoCenter, 2010. Disponível em: Acessado em 25 de outubro de 2010.
MANGAN, T. Perceived Performance -Tuning a System for What Really
Mattersng The Java HotSpot Performance Engine Architecture, 2008.
Disponível em: Acessado
em 27 de setembro de 2010.
MEYERS N. PerfAnal: A Performance Analysis Tool, 2000. Disponível em <
http://java.sun.com/developer/technicalArticles/Programming/perfanal/ >.
Acessado em 25 de outubro de 2010.
47

MOREIRA E., Sistemas Distribuídos – introdução, 2009 Disponível em <
http://erikomoreira.com.br/flf/sd/slides/introducao.6s.pdf>. Acessado em 20 de
setembro de 2010.
O’HAIR K., HPROF: A Heap/CPU Profiling Tool in J2SE 5.0, 2004
Disponível em . Acessado em 29 de
setembro de 2010.
ORACLE, JRockit JV - Diagnostics Guid, 2009 Disponível em:
Acessado
em 26 de outubro de 2010.
__________. Tuning Garbage Collection with the 5.0 Java Virtual
Machine. 2003. Disponível em: < http://www.oracle.com/technetwork/java/gc-
tuning-5-138395.html> Acessado em 26 de novembro de 2010.
__________. Tuning The Java HotSpot Performance Engine Architecture.
2010. Disponível em:
Acessado em 27 de novembro de 2010.
ROCHA, H. Gerência de memória em Java, 2005a , Disponível em:
Acessado em 26 de novembro de 2010.
__________. Gerência de memória em Java parte 2: Monitoração e
configuração da maquina virtual HotSpot, 2005b , Disponível em:<
http://www.argonavis.com.br/cursos/java/j100/java-5-mem-2.pdf> Acessado em
26 de novembro de 2010.
TMURGENT. Perceived Performance, 2003. Disponível em:
. Acessado
em 20 de setembro de 2010.
48

WILSON, S. Performance, 2001 Disponível em < http://java.sun.com/
docs/books/performance/1st_edition/html/JPPerformance.fm.html#16387 >.
Acessado em 20 de setembro de 2010.
49