java.

nio, a nova entrada e sada do Java

IO melhorado com java.nio

Luiz Arnaldo de Gusmo Bastos (Luca)

Engenheiro e desenvolvedor Java
People Consulting

lucabastos@gmail.com
java.nio - Agenda

Introduo

Buffers

Channels
Scatter/Gather
File Channels e file locking
Memory mapped files
Transferncia channel to channel
Socket Channels

Selectors e SelectionKeys

Comparao entre java.io e java.nio
java.nio - Introduo

O Java sempre foi criticado quanto performance de IO

As classes disponveis nos pacotes java.io e java.net fornecem
abstrao boa para o desenvolvedor mas no permitem o uso de
facilidades reais nativas do sistema operacional.

Alm disto algumas decises tomadas no desenvolvimento
inviabilizam o uso destas APIs Java em aplicaes que exigem IO
de alta performance.

Problemas dos pacotes java.io e java.net:

Abstrao distante das facilidades do SO;

Locks demais sem controle do desenvolvedor;

Falta de file locking;

Falta de buffers em algumas classes;

IO sempre bloqueante;
java.nio - Introduo, problemas java.io

Abstrao distante das facilidades do SO

Os sistemas operacionais movem os dados em grandes pacotes.
As vezes contam com ajuda do hardware para transferir dados
sem passar pela CPU usando um outro barramento de dados
disponvel na arquitetura da mquina. a facilidade conhecida
como Direct Memory Access (DMA).

As classes do java.io e java.net, no caso de uso das Streams,
movem os dados em pequenos pedaos para facilitar o
programador. Isto significa que as classes de IO do tipo Stream
do Java perdem tempo empacotando e desempacotando bytes
para se ajustar as necessidades do SO. Esta perda ocorre em
todas as composies das Streams.

A classe RandomAccessFile de java.io a nica capaz de
transferir grandes pacotes de dados. Mas no tem buffers.
java.nio - Introduo, problemas java.io

Locks demais sem controle do desenvolvedor

Classes importantes so declaradas como synchronized para ter
um comportamento thread safe. Isto facilitou o uso seguro mas
sacrificou a desempenho. O programador de IO de alta
performance ficou sem opes para evitar o monte de locks
muitas vezes desnecessrios.
Exemplos: StringBuffers, IO Streams, etc.

Problema dos StringBuffers
Todos os mtodos pblicos so synchronized. O Java implementa
o operador de concatenao de Strings usando StringBuffer.
Avaliar a expresso "Java" + "NIO" significa fazer:
new StringBuffer.append("Java").append.("NIO").toString()

Trs aquisies de lock, uma para cada chamada de mtodo,

completamente desnecessrias se o StringBuffer acessado na
mesma thread.
java.nio - Introduo, problemas java.io

Locks demais sem controle do desenvolvedor (cont. 1)

Os StringBuffers so usados por debaixo dos panos por mtodos

de outras classes Java. Inocentes Integer.toString e
Long.toString usam n+2 aquisies de lock onde n o
comprimento da String resultante.

Exerccio: Calcular o nmero de locks da expresso "PI=" +

3.1415926535897932384626433832795.

Este problema aparece tambm ao converter um endereo IP

para String. Ao usar InetAddress.getHostAddress() para
converter um endereo como 200.189.176.20 para String, sero
feitas vrias aquisies de lock desnecessrias.
java.nio - Introduo, problemas java.io

Locks demais sem controle do desenvolvedor (cont. 2)

Problemas do IO Stream

As classes Stream servem para IO byte a byte e as classes
Reader/Writer para o IO de caracteres Unicode. Normalmente
usamos composio. Ler uma seqncia de inteiros a partir de
um arquivo compor um FileInputStream com um
BufferedInputStream e um DataInputStream.

Vrias classes de java.io so synchronized. O mtodo read de
BufferedInputStream synchronized (assim como o write de
BufferedOutputStream). No se pode optar por no fazer locks e
garantir a segurana lendo tudo em uma nica thread.

Quase todos os mtodos de DataOutputStream escrevem um byte
de cada vez, writeLong faz 8 operaes de write. Uma simples
chamada acarreta 8 aquisies de lock.
java.nio - Introduo, problemas java.io

Falta de file locking

File locking uma facilidade essencial para controlar acesso
concorrente a recursos comuns entre vrias entidades e o Java
no dispunha disto.

Falta de buffers em algumas classes

Algumas classes no usam buffers. O programador precisa
escrever sua prpria classe de buffer.

IO sempre bloqueante

O programador Java j se acostumou a criar novas threads
quando quer esperar o resultado de uma operao de IO que
bloqueia enquanto no terminarem os dados. A maioria dos SO
permite colocar as Streams em modo no bloqueante.
java.nio - Introduo, problemas java.io

IO sempre bloqueante (cont.1)

Os SOs permitem que um processo verifique se tem dados
chegando em uma Stream de input ao invs de ficar parado
esperando exclusivamente a chegada de novos dados. Aproveitar
esta facilidade trs um enorme ganho de performance ao sistema. O
SO pode ser avisado para observar vrias Streams e avisar ao
processo quando uma das Streams estiver pronta para uso.

Os SOs permitem ao desenvolvedor multiplexar muitas Streams
ativas no mesmo trecho de cdigo e em uma nica thread. Usando
s java.io e java.net no se tem isto que usado com sucesso em
alguns servidores web tal como mostra a figura a seguir.

Na figura, o eixo horizontal mostra nmero de usurios e na vertical
o nmero de hits por segundo. Os 4 servidores com melhor
desempenho usam IO no bloqueante e system call select()
(equivalente ao Selector do java.nio). Em verde o Apache 1.3.
java.nio - Introduo, problemas java.io

IO sempre bloqueante (cont.2) Vantagem dos selectors

Fonte: http://www.acme.com/software/thttpd/benchmarks.html
java.nio - Introduo

API java.nio

As APIs disponveis no Java antes da verso 1.4 no permitiam o
desenvolvimento de aplicaes servidoras com desempenho
comparvel s mesmas aplicaes desenvolvidas em outras
linguagens.

A API java.nio includa na verso 1.4 introduz novas abstraes
para fazer IO e desta vez focadas em uma maior aproximao
com o SO. Fornecem classes de gerenciamento dos buffers,
melhoram as classes de IO em rede e arquivos usando facilidades
como selectors e channels e ainda incluem suporte a expresses
regulares e Character sets.

Apresentaremos somente buffers, selectors e channels. O
objetivo introduzir alguns conceitos da figura do prximo slide.
java.nio - Buffers, Channels e Selectors
java.nio - Buffers

Conceitos bsicos

As classes de buffer so a base da API java.nio. Alis, os
buffers so o prprio pacote java.nio porque as outras
classes ficam em pacotes especializados debaixo de
java.nio. A maioria das operaes destas outras classes
usam buffers. Um buffer acumula dados entre operaes
de IO com fins de otimizao de performance. igual ao
armrio de comida onde se guardam as compras da feira
antes de cozinhar.

H uma classe Buffer para cada tipo primitivo no
booleano. Todas as classes so abstratas. Os buffers so
alocados atravs de mtodos estticos.

A classe Buffer define operaes comuns a todos os
buffers.
java.nio - Buffers
java.nio - Buffers
Atributos

Capacity mximo nmero de elementos definido na
criaao.

Limit primeiro elemento que NO pode ser lido ou
gravado.

Position prximo elemento a ser lido ou gravado.

Mark guarda uma posiao na memria para voltar a ela
mais tarde com reset()

0 mark position limit capacity

Exemplo: CharBuffer buffer = CharBuffer.allocate(10);

java.nio - Buffers
Um buffer pode ser criado de vrios modos:

Alocando diretamente usando o mtodo esttico allocate()
de uma das subclasses de buffer.
ByteBuffer buffer = ByteBuffer.allocate(12);

Associando um array ao buffer, o chamado wrapping:
char[] charArray = new char[22];
CharBuffer bufferChar = CharBuffer.wrap(charArray);

Duplicando um buffer:
ByteBuffer bufferDup = buffer.duplicate();

Duplicando s uma fatia do buffer:
buffer.position(4).limit(8);
ByteBuffer bufferSlice = buffer.slice();

Criando viso de um ByteBuffer como outro qualquer:
LongBuffer bufferlong = buffer.asLongBuffer();
java.nio - Buffers
Assinaturas dos mtodos da classe Buffer

package java.nio;
public abstract class Buffer {

public final int capacity()

public final int position()
public final Buffer position(int newPosition)
public final int limit()
public final Buffer limit(int newLimit)
public final Buffer mark()
public final Buffer reset()
public final Buffer clear()
public final Buffer flip()
public final Buffer rewind()
public final int remaining()
public final boolean hasRemaining()
public abstract boolean isReadOnly()
}
java.nio - Buffers - Exemplos
Como fica um buffer escrito com buffer.put(Alo SP);

Preparando um buffer para drenar dados buffer.flip();

o mesmo que: buffer.limit(buffer.position()).position(0);

java.nio - Buffers - Exemplos
Vamos supor que s os 2 primeiros chars sairam do buffer

A API tem um mtodo para compactar o buffer: buffer.compact();

Os elementos 2 a 5 foram movidos para as posies 1 a 3.

As posies 4 e 5 no mudaram porm esto fora de
alcance. O limit voltou a ser igual a capacity.
java.nio - Buffers - Comparao
Dois buffers testados com buffer1.equals(buffer2) so
considerados iguais se:

Ambos so do mesmo tipo;

Ambos tem o mesmo nmero de elementos restantes. A
capacidade no precisa ser a mesma e nem mesmo os
ndices, mas o nmero de elementos desde position at
limit precisa ser igual

Os elementos que podem ser obtidos com get() devem
ser idnticos

A comparao de 2 buffers com buffer1.compareTo(buffer2)

feita de modo anlogo ao equals comparando os elementos
restantes at que um valor seja menor ou o menor buffer
atinja seu valor limit.
java.nio - Buffers Movendo Blocos

O objetivo principal dos buffers permitir transferncia
de dados eficiente.
Para ajudar nisto, as classes de buffer possuem alguns
mtodos get() e put() com array em seus parmetros que
ajudam a mover dados em bloco como em CharBuffer

public CharBuffer get (char[] destino)

public CharBuffer get (char[] destino, int offset, int length)

public final CharBuffer put (char[] origem)

public CharBuffer put (char[] origem, int offset, int length)
public CharBuffer put (CharBuffer origem)
public final CharBuffer put (String origem)
public CharBuffer put (String origem, int offset, int length)

Obs.:
a) As transferncias em bloco so sempre com tamanho
fixo.
b) Os 2 ltimos mtodos com parmetros String s
existem em CharBuffer.
java.nio - Byte Buffers e byte order
Byte a unidade fundamental de dados do SO e das
operaes de IO. Todo IO de mais baixo nvel como channels
por exemplo usa objetos da classe ByteBuffer. Esta a
classe com mais mtodos do pacote java.nio.

Para operar com bytes preciso entender a ordem como os

bytes so armazenados. Cada dado primitivo armazenado
na memria como uma seqncia de bytes (menos boolean).
Esta seqncia pode comear pelo byte de mais alta ordem.
Ou ser justamente ao contrrio.
O inteiro 0x01020304 (decimal 16909060) pode ficar assim:

big-endian byte order (Motorola, Sun, PowerPC)

Ou assim:
little-endian byte order (Intel)

Para todas as classes de buffer, menos ByteBuffer, h uma

propriedade read only com a ordem dos bytes.
java.nio - Byte Buffers e byte order
ByteBuffer tambm tem esta propriedade mas possvel
modifica-la para o caso em que a ordem nativa do SO seja
diferente do valor default adotado que BIG_ENDIAN.

Para isto deve ser usado o mtodo

ByteBuffer order (ByteOrder bo)
onde ByteOrder uma classe com 2 variveis estticas:
BIG_ENDIAN e LITTLE_ENDIAN

O mtodo order(), como a maioria dos mtodos da API

java.nio, retorna uma referncia ao objeto com o qual foi
invocado (this). Isto uma tcnica de projeto de classes que
permite o chamado invocation chaining, isto , escrever as
chamadas aos mtodos de forma encadeada tal como no
exemplo abaixo:
ByteBuffer.allocate(100).order(ByteOrder.LITTLE_ENDIAN);
ou fazer algo assim:
buffer.mark().position(5).reset();
java.nio - Direct Buffers

Uma das coisas que distingue os ByteBuffers dos outros
buffers o fato deles poderem ser usados nas operaes
de IO com Channels. Nestas operaes so sempre usados
buffers diretos que so alocados usando cdigo nativo em
uma rea de memria acessada diretamente pelo SO. Quer
dizer, os dados saem diretamente do buffer para o
dispositivo de armazenamento (ou vice-versa) sem a
intermediao de um outro buffer do SO e sem precisar de
interveno da JVM.

A criao de um ByteBuffer direto feita usando
ByteBuffer.allocateDirect (int capacity)

Os buffers diretos so timos para IO mais so muito mais
custosos para criar do que um buffer comum. A memria
alocada pela chamada de mtodos nativos fora da heap da
JVM e fora do alcance do GC.

Exemplo: alocar memria de vdeo como ByteBuffer direto.
java.nio.channels

Channels

Abstrao que representa uma conexo direta com os
servios de IO do SO.

Canal de transporte eficiente de dados entre ByteBuffers
e as entidades do outro extremo que normalmente so
arquivos ou sockets.

So como um gateway pelo qual podem ser acessados
os servios nativos de IO do SO com o menor overhead.

A API baseada em interfaces. As implementaes
podem depender do SO. A API somente descreve o que
pode ser feito.

Os channels s operam em ByteBuffers. possvel
extender para outros tipos de dados mas IO de baixo
nvel sempre em termos de bytes.
java.nio.channels

Interfaces principais
java.nio.channels

Os channels podem ser unidirecionais ou bidirecionais,
isto , implementam ReadableByteChannel,
WritableByteChannel ou ByteChannel que extende
ambas e assim bidirecional.

Os channels tem uma relao um-para-um com os file
descriptors ou file handlers do SO. So restritos s
caractersticas do servio ao qual esto conectados.
Um channel que implementa WritableByteChannel no
pode gravar em um arquivo marcado como Read Only
pelo SO.

A interface InterruptibleChannel, quando
implementada, apenas indica que o channel pode ser
interrompido.

A API inclui as 2 classes AbstractInterruptibleChannel e
AbstractSelectableChannel em java.nio.channels.spi
com mtodos necessrios para as implementaes
concretas de channels.
java.nio.channels

Criao de channels

Socket channels so criados pelo mtodo factory open()

SocketChannel sc = SocketChannel.open();
sc.connect(new InetSocketAddress(host, port);

ServerSocketChannel ssc = SocketChannel.open();

ssc.socket().bind(new InetSocketAddress(host);

DatagramChannel dc = DatagramChannel.open();

Os file channels no podem ser criados diretamente. So
obtidos usando getChannel() de um objeto de um dos tipos
RandomAccessFile, FileInputStream ou FileOutputStream.

RandomAccessFile rf = new RandomAccessFile(arq, r);

FileChannel fc = rf.getChannel();
java.nio.channels

Uso de Channels

Os mtodos read de ReadableByteChannel e write de
WritableByteChannel recebem ByteBuffers e retornam o
nmero de bytes transferidos que pode ser menor do que
o tamanho do buffer. A posio do buffer atualizada.

Channels seqnciais (tipo Stream) podem operar
bloqueados ou no. Uma operao de IO no
bloqueante quando permite a um processo verificar se h
dados na entidade de IO sem estacionar esperando pela
chegada de algum dado. uma caracterstica nativa da
maioria dos SOs.

Um channel no modo no bloqueante nunca adormece a
thread que o chama, sempre retorna imediadamente com
a operao completa ou com o que deu para ser feito
naquele instante.
java.nio.channels
Exemplo de uso tradicional de socket com java.net
java.nio.channels

Uso de Channels (continuao)

Somente channels orientados a Streams como sockets e
pipes podem operar no modo no bloqueante.

Os objetos do tipo channel no podem ser reutilizados.
Representam uma conexo especfica com um
determinado servio de IO e encapsulam o estado da
conexo.

Quando um channel fechado a conexo perdida.

Nos channels que implementam InterruptibleChannel, se
uma thread bloqueada em um channel interrompida
(por outra thread), o channel fechado e a thread lana
ClosedByInterruptionException. E mais, se o status de
interrupo da thread est setado (por uma chamada de
interrupt()) e a thread tenta acessar o channel, ento este
imediatamente fechado e a mesma exceo lanada.
java.nio.channels

Scatter / Gather
Um pouco de ingls:

Scatter = disseminate, spread, disperse, sprinkle, etc.

Gather = bring together, assemble, collect,
accumulate, etc.

Scattering:
ReadableByteChannel ByteBuffer[ ]

L dados de um channel e espalha em um array de

buffers.

Gathering:
ByteBuffer[ ] WritableByteChannel

Coleta dados em um array de buffers e escreve em

um channel.
java.nio.channels

File Channels

Sempre so bloqueantes e no podem ser criados
diretamente.

Usam servios nativos de IO sempre que possvel.

So thread-safe mas nem todas as operaes so multi-
threaded.

garantido que dentro de uma mesma JVM todas as
instncias tero acesso consistente a um arquivo. O
acesso concorrente a arquivos entre diferentes JVMs ou
com aplicaes em outras linguagens depende do SO.
java.nio.channels

File Channels (continuao) - File locking

File locking o esquema pelo qual um processo pode
evitar ou restringir o modo de acesso de outros
processos a um arquivo. usado para controlar
atualizaes em arquivos compartilhados ou controlar
transaes. uma facilidade nova essencial para a
integrao com outras linguagens. Pode ser shared ou
exclusive. E ainda advisory (Unix) ou mandatory (M$).

File locks do tipo advisory fornecem informaes sobre
os locks usados aos processos que solicitam tal
informao. O SO no garante o lock. O processo
precisa cooperar e respeitar a informao sobre o lock.

File locks do tipo mandatory so mantidos pelo SO e o
file system evitar o acesso de processos s reas
protegidas dos arquivos quer os processos estejam
conscientes do lock ou no.
java.nio.channels

File Channels (continuao) - Memory-mapped files

O IO convencional move os dados da rea de memria do

usurio para uma rea de memria acessada pelo SO. Mas
a maioria dos SOs suporta um tipo especial de operao que
permite ao programa do usurio mapear seus dados
diretamente na rea da memria mapeada pelo file system.

A classe FileChannel tem o mtodo map() que cria uma

memria virtual entre um arquivo aberto e um

MappedByteBuffer que uma subclasse de ByteBuffer.

MappedByteBuffer File system

User Kernel

Pgina na memria Memria fsica

java.nio.channels

File Channels (continuao)

Transferncia rpida entre channels

Podemos transferir dados de um channel para outro
diretamente sem usar buffers intermedirios. muito
mais eficiente do que usar read() e write().
Exemplo onde destino um WritableByteChannel:

FileInputStream fis = new FileInputStream(arq);

FileChannel fchannel = fis.getChannel();
fchannel.transferTo(0, fchannel.size(), destino);
fchannel.close();
fis.close();

O mtodo transferTo() escreve no destino mas existe
tambm o mtodo transferFrom() que l de um
ReadableByteChannel para um FileChannel.
java.nio.channels

Socket Channels

SocketChannel, ServerSocketChannel e
DatagramChannel

Podem operar em modo no bloqueante e podem ser
usados com selectors.

Descendem de SelectableChannel e tambm de
InterruptibleChannel.

Usando selectors no necessrio dedicar uma thread
para cada conexo via socket e degradar a performance
com as trocas de contexto entre as muitas threads.

Os sockets channels criam um objeto socket quando
instanciados. Eles delegam as operaes de protocolo a
este objeto a menos que existam mtodos de mesmo
nome nas classes channel.
java.nio.channels

Selectors

Fornecem a possibilidade de selecionar um channel e
verificar se ele est pronto para ser usado sem fazer uma
operao de leitura. Isto permite o chamado IO
multiplexado.

Modo de usar:
1. Criar vrios SelectableChannels e configurar no modo
no bloqueante;

2. Criar um objeto Selector;

3. Registrar um ou mais channels com o objeto Selector.

Recebe em cada registro um SelectionKey que
representa a relao entre este channel e o selector. Ela
guarda o que se quer fazer com o channel (ler, escrever
ou ambos) e tambm qual das operaes o channel est
pronto para fazer;
java.nio.channels

Selectors - Modo de Usar (cont.)

4. Pegar o int retornado por selector.select(). Caso > 0,
porque ao menos uma key foi atualizada e se pode passar
ao passo seguinte, seno se deve chamar selector.select()
novamente at que uma chave indique um channel livre
para nossa operao;

5. Iterar pelo conjunto de chaves para servir cada channel

pronto desde a ltima chamada de select().

O importante mtodo select() seleciona um conjunto de

chaves cujos correspondentes channels esto prontos
para o IO. Faz a operao de seleo de modo bloqueante,
isto , retorna somente depois que ao menos um channel
seja selecionado, a thread atual seja interrompida ou com
uso de wakeup(). Na seleo, as chaves canceladas so
removidas e o seu channel perde o registro. A seguir
verifica todos os demais channels e atualiza o estado de
todas as chaves.
java.nio.channels

Resumo dos envolvidos no processo

Selector
Classe que gerencia as informaes entre um conjunto
de channels registrados e seus estados. Um selector
pode ser argdo para atualizar o estado dos channels
registrados. A thread que faz isto pode ficar em
suspenso at que um dos channels esteja pronto para a
operao desejada.

SelectableChannel
Classe abstrata que fornece os mtodos necessrios
para implementar a facilidade de seleo. FileChannels
no extendem esta classe. Os objetos tipo
SelectableChannel podem ser registrados com objetos
Selector junto com uma indicao da operao em que o
Selector est interessado. Um channel pode ser
registrado com vrios Selectors diferentes mas uma vez
s por Selector.
java.nio.channels

Resumo dos envolvidos no processo (cont.)

SelectionKey
Uma SelectionKey encapsula o relacionamento
registrado entre um determinado channel e o
especificado selector. Contm apenas 2 informaes
obtidas dos bits de inteiros: as operaes do channel
que o selector registrado tem interesse e quais
operaes o channel est pronto para executar.
java.nio.channels

Selectors - Observaes

Cada objeto Selector guarda 3 conjuntos de chaves
- Registered key set chaves registradas com o selector;
- Selected key set subconjunto com as chaves
associadas a um channel com ao menos uma operao
pronta de IO de interesse da chave;
- Cancelled key set conjunto com chaves canceladas;

So 4 as operaes que podem ser registradas:
read, write, connect e accept.
Cada operao faz sentido para determinado tipo de
channel. Exemplo: registrar um SocketChannel para
accept resulta em IllegalArgumentException.

Fechamento de um channel
Quando um channel fechado todas as SelectionKeys
associadas so automaticamente invalidadas. Quando
um selector fechado, todos os channels registrados
perdem o registro e suas chaves so invalidadas.
java.nio - Comparao entre java.io e java.nio

Comparao feita com cpia de arquivo - A

Ambiente:
WinXP, AMD Athlon XP2000+, 1.67GHz, 496 Mb de RAM

A - Simples cpia
in = new FileInputStream(from);
out = new FileOutputStream(to);
while (true) {
int data = in.read();
if (data == -1) {
break;
}
out.write(data);
}

Arquivo Mb Tempo em ms
2541 9003
6616 23504
java.nio - Comparao entre java.io e java.nio

Comparao feita com cpia de arquivo - B

B cpia com BufferedStream
InputStream inFile = new FileInputStream(from);
in = new BufferedInputStream(inFile);
OutputStream outFile = new FileOutputStream(to);
out = new BufferedOutputStream(outFile);
while (true) {
int data = in.read();
if (data == -1) {
break;
}
out.write(data);
}
Arquivo Mb Tempo em ms
2541 163
6616 405
17651 1270
java.nio - Comparao entre java.io e java.nio

Comparao feita com cpia de arquivo - C

C cpia com buffer customizado seguro
static final byte[] buffer = new byte[100000];
.........
in = new FileInputStream(from);
out = new FileOutputStream(to);
while (true) {
synchronized (buffer) {
int amountRead = in.read(buffer);
if (amountRead == -1) {
break;
}
out.write(buffer, 0, amountRead);
}
} Arquivo Mb Tempo em ms
2541 60
6616 152
17651 725
93548 20275
java.nio - Comparao entre java.io e java.nio

Comparao feita com cpia de arquivo - D

D cpia com channel.transferTo
FileInputStream fiO = new FileInputStream(files[0]);
FileOutputStream fiD = new FileOutputStream(files[1]);
FileChannel chOrigem = fiOrigem.getChannel();
FileChannel chDestino = fiDestino.getChannel();

chOrigem.transferTo (0, chOrigem.size(), chDestino);

Arquivo Mb Tempo em ms
2541 33
6616 135
17651 203
93548 1867
java.nio - Comparao entre java.io e java.nio

Comparao feita com cpia de arquivo

Resumo comparativo

Arquivo Tempo em ms
Mb A B C D
2.541 9003 163 60 33
6.616 23504 405 152 135
17.651 ---- 1270 725 203
93.548 ---- ---- 20275 1867

Cdigo Java usados nos testes:

Java Plataform Performance de Steve Wilson e Jeff
Kesselman, Listings 4-1, 4-2 e 4-4 para os casos com
java.io A, B e C respectivamente.

Java NIO de Ron Hitchens, Example 3-6 modificado para

saida em outro arquivo ao invs do console. Usado no
caso D
java.nio Use sempre que possvel

Muito obrigado !
Luiz A. G. Bastos (Luca) lucabastos@gmail.com