NIO

K.1. Nowe wejście-wyjście (NIO): przegląd

• tworzenie i przełączanie wątków (realizowane przez JVM) jest czasowo kosztowne,
• szybkie narastanie niepotrzebnych obiektów (zakończonych wątków) powoduje zmniejszenie efektywności dzialania programu ze względu na zwiększającą się zajętośc pamięci, bowiem standardowy odśmiecacz JVM nie  jest odpowiednio przystosowany do takiej sytuacji,
• synchronizowanie dużej liczby wątków na wspóldzielonych zasobach może być trudne w programowaniu, zawodne i bardzo czasochłonna z punktu widzenia efektywności dzialania programu. 

SocketChannel socketChannel = SocketChannel.open(); // otwarcie kanału
socketChanel.connect(...)                           // podłączenie do gniazda
socketChannel.configureBlocking (false);            // tryb nieblokujący

...

while (true) {
   ...
   if (socketChannel.read (buffer) != 0) {  // czy są jakieś dane?
      processInput (buffer);                // tak - przetwórz je
   }
   else {                                   // nie - wykonuj inne czynności
     ...
   }
}

• trzeba je oprogramować (i można przy tym popełnić błędy),
• polega na wysyłaniu instrukcji we/wy za pośrednictwem JVM (read(...)), co jest czasowo kosztowne i w rezultacie - przy dużej liczbie połączeń -  może niedopuszczalnie zmniejszać czas reakcji na każdym z połaczeń.

• jeden wątek może łatwo monitorować dużą liczbę gniazd sieciowych,
• wątek ten może być zablokowany dopóki nie pojawią się dane z któregokolwiek gniazda, a po ich pojawieniu się natychmiast wznowiony,
• może przy tym dowiedzieć się, który ze strumieni danych jest gotowy do przetwarzania i natychmiast podjąc to przetwarzanie. 

• zwalnia nas od obowiązku pisania trudnego kodu,
• jest efektywne, bowiem multipleksowanie i selekcja kanałów są zrealizowane w dużej mierze przez odwolania do rodzimych funkcji platformy systemowej i - wobec tego - omija JVM, pozostawiając ciężką pracę do wykonania procedurom systemowym, które robią to najsprawniej.

K.2. NIO: bufory

• alokowanie prywatnej pamięci bufora - metody allocate i allocateDirect (ta ostatnia dla buforów bezposrednich),
• opakowanie istniejącej tablicy elementów wybranego typu pierwotnego - metoda wrap,
• mapowanie plików lub ich części (metoda map(...) z klasy FileChanel)
  

import java.nio.*;

class Buffers {

  static void say(String s) { System.out.println(s); }

  static void showParms(String msg, Buffer b) {
    say("Charakterystyki bufora - " + msg);
    say("capacity  :" + b.capacity());
    say("limit     :" + b.limit());
    say("position  :" + b.position());
    say("remaining :" + b.remaining());
  }

  public static void main(String args[]) {

    // alokacja bufora 10 bajtowego (inicjalnie warości elementów = 0)
    ByteBuffer b = ByteBuffer.allocate(10);
    showParms("Po utworzeniu", b);

    // Zapis dwóch bajtów do bufora
    b.put((byte) 7).put((byte) 9);
    showParms("Po dodaniu dwóch elementów", b);

    // Przestawienie bufora
    b.flip();
    showParms("Po przestawieniu", b);

    // Teraz możemy czytać wpisane dane
    say("Czytamy pierwszy element: " + b.get());
    showParms("Po pobraniu pierwszego elementu", b);
    say("Czytamy drugi element: " + b.get());
    showParms("Po pobraniu drugiego elementu", b);

    say("Czy możemy jeszcze czytać?");
    try {
      byte x = b.get();
    } catch (BufferUnderflowException exc) {
       say("No, nie - proszę spojrzeć na ostatni limit!");
    }

    // Jeszcze raz odczytajmy dane z bufora
    // w tym celu musimy go przewinąć
    b.rewind();
    showParms("Po przewinięciu", b);

    say("Czytanie wszystkiego, co wpisaliśmy");
    while (b.hasRemaining())
      say("Jest: " + b.get());
  }
}

K.3 NIO: kanały i bufory

import java.io.*;
import java.nio.*;
import java.nio.channels.*;

class SimpleChannel {

  String fname = "test.tmp";
  byte[] data = {1,2,3,4,5 };

  SimpleChannel() {
    try {
      writeChannel(fname, data);
      byte[] wynik = readChannel(fname);
      for (int i=0; i < wynik.length; i++) System.out.println(wynik[i]);
    } catch(Exception exc) {
        exc.printStackTrace();
        System.exit(1);
    }
  }

  void writeChannel(String fname, byte[] data) throws Exception {

    // Możemy utworzyć bufor przez opakowanie istniejącej tablicy
    ByteBuffer buf = ByteBuffer.wrap(data);

    FileOutputStream out = new FileOutputStream(fname);

    // Uzyakanie kanału
    FileChannel fc = out.getChannel();

    //Zapis
    fc.write(buf);
    fc.close();
  }

  byte[] readChannel(String fname) throws Exception {


    // Stworzenie strumienia na podstawie obiektu klasy File
    FileInputStream in = new FileInputStream(fname;

    // Uzyskanie kanału
    FileChannel fc = in.getChannel();

    // Metoda size() z klasy FileChannel
    // zwraca long -rozmiar plku, do którego podlączony jest kanał
    int size = (int) fc.size();

    // Utworzenie bufora
    ByteBuffer buf = ByteBuffer.allocate(size);

    // Czytanie do bufora
    // nbytes - liczba przeczytanych bajtów
    int nbytes = fc.read(buf);
    fc.close();

    // Po przeczytaniu danych musimy bufor przestawić
    buf.flip();

    // Stworzenie tablicy na wynik czytania
    // jej rozmiar będzie określony przez liczbę przeczytanuych bajtów
    // którą możemy podać na dwa sposoby: poprzednie nbytes
    // lub uzyskując informację o liczbie jeszcze nieodczytanych bajtów z bufora

    byte[] wynik = new byte[buf.remaining()];
    buf.get(wynik);
    return wynik;
  }

  public static void main(String args[]) {
   new SimpleChannel();
  }
}   

K.4. Widoki buforów bajtowych

import java.nio.*;

class BufView1 {

  public static void main(String args[]) {

    final int SHORT_SIZE = 2;
    // Alokacja buforu bajtowego,
    // mogącego przechowywać do 10 liczb typu short
    ByteBuffer bb = ByteBuffer.allocate(10*SHORT_SIZE);

    // Widok na ten bofor jak na short-bufor
    ShortBuffer sb = bb.asShortBuffer();

    // Dodanie trzech liczb typu short
    short a = 1, b = 2, c = 3;
    sb.put(a).put(b).put(c);

    // Co wpisano do bufora? Na wydruku: 1, 2, 3
    sb.flip();
    while (sb.hasRemaining()) System.out.println(sb.get());

    // Operujemy teraz na nim za pomocą bufora bajtowego
    // zmieniając bajty na pozycji 1, 3 i 5.
    byte  x = 4, y = 5, z = 6;
    bb.put(1, x).put(3, y).put(5, z);

    // Co pokaże short-bufor? Na wydruku 4, 5, 6
    sb.rewind();
    while (sb.hasRemaining()) System.out.println(sb.get());
  }
}

  public static void main(String args[]) {

    final int SHORT_SIZE = 2;
    ByteBuffer bb = ByteBuffer.allocate(10*SHORT_SIZE);
    ShortBuffer sb = bb.asShortBuffer();
    short a = 1, b = 2, c = 3;
    sb.put(a).put(b).put(c);
    showParms("bufor short - po dodaniu liczb", sb);
    showParms("bufor bajtowy - po dodaniu liczb", bb);

    sb.flip();
    showParms("bufor short - po przestawieniu", sb);
    showParms("bufor bajtowy - po flip bufora short", bb);
    System.out.print("Dane");
    while (bb.hasRemaining()) System.out.print(" " + bb.get());
  }
}

    sb.flip();
    bb.limit(sb.limit()*SHORT_SIZE);
    System.out.print("Bajty wpisanych danych");
    while (bb.hasRemaining()) System.out.print(" " + bb.get());

import java.io.*;
import java.nio.*;
import java.nio.channels.*;

class BuffChan {

  String fname = "testfile.tmp";

  // inicjacja danych testowych
  void init() throws Exception {
    double[] data = { 0.1, 0.2, 0.3 };
    DataOutputStream out = new DataOutputStream(
                             new FileOutputStream(fname)
                            );
    for (int i=0; i < data.length; i++) out.writeDouble(data[i]);
    out.close();

  }

  BuffChan() throws Exception {

    // inicjalcja danych testowych
    init();

    // utworzenie bufora
    ByteBuffer buf = ByteBuffer.allocate(1000); // nie wiemy ile, maks 100B

    // uzyskanie kanału
    FileChannel fcin = new FileInputStream(fname).getChannel();

    // czytanie z kanału do bufora
    fcin.read(buf);
    fcin.close();

    // przestawienie bufora bajtowego
    buf.flip();

    // Utworzenie widoku bufora
    DoubleBuffer dbuf = buf.asDoubleBuffer();

    // Wypisanie odczytanych danych
    while (dbuf.hasRemaining()) System.out.println(dbuf.get());
  }

  public static void main(String args[]) throws Exception {
    new BuffChan();
  }
}

K.5. NIO: bufory - uporządkowanie bajtów (endianess)

• Porządek BIG ENDIAN oznacza, że mniej znaczące bajty danych są zapisywane pod większymi adresami pamięci (niejako od prawej do lewej)
• Porządek LITLLE ENDIAN jest odwrotny: najpierw są zapisywane mniej znaczące bajty, później bardziej (od lewej do prawej).

• order (ByteOrder.BIG_ENDIAN) - zmienia porządek na BIG ENDIAN
• order (ByteOrder.LITTLE_ENDIAN) - zmienia porządek na LITTLE ENDIAN

import java.nio.*;

class Endianness {

   static void show(int n) {
       String s = Integer.toHexString(n);
       int l = s.length();
       for (int i=l; i < 8; i++) s = '0' + s;
       System.out.println("Liczba " + n + " hex -> " + s.toUpperCase());
   }

   public static void main(String args[]) {
     int num = Integer.parseInt(args[0]);
     ByteBuffer buf = ByteBuffer.allocate(4);
     System.out.println(buf.order().toString());
     IntBuffer b1 = buf.asIntBuffer();
     System.out.println("Porządek b1 " + b1.order());
     b1.put(num);
     b1.flip();
     show(b1.get());
     buf.order(ByteOrder.LITTLE_ENDIAN);
     System.out.println("Porządek buf " + buf.order());
     System.out.println("Porządek b1 " + b1.order());
     b1.rewind();
     show(b1.get());
     System.out.println("Porządek buf " + buf.order());
     System.out.println("Porządek dziedzizcony " + buf.asIntBuffer().order());
     show(buf.asIntBuffer().get());
  }
}

K.6. NIO: bufory znakowe. Kodowanie i dekodowanie. 

• poza znanymi nam metodami buforowymi na buforach znakowych można operowac za pomocą metod tego interfejsu,
• klasa CharBuffer dostarcza metody wrap opakowującej dowolną sekwencję znaków (obiekt klasy implementującej interfejs CharSequence) i dzięki temu możemy np. w następujący sposób tworzyć bufory znakowe.:

import java.io.*;
import java.nio.*;
import java.nio.channels.*;

class Ende1 {

  public static void main(String[] args) {

    if (args.length != 4) {
      System.out.println("Syntax: in in_enc out out_enc");
      System.exit(1);
    }

    String infile  = args[0],     // plik wejściowy
           in_enc  = args[1],     // wejściowa strona kodowa
           outfile = args[2],     // plik wyjściowy
           out_enc = args[3];     // wyjściowa strona kodowa

    try {
       FileChannel fcin = new FileInputStream(infile).getChannel();
       FileChannel fcout = new FileOutputStream(outfile).getChannel();
       ByteBuffer buf = ByteBuffer.allocate((int)fcin.size());

       // czytanie z kanału
       fcin.read(buf);

       // przeniesienie zawartości bufora do tablicy bytes
       buf.flip();
       byte[] bytes = new byte[buf.capacity()];
       buf.get(bytes);

       // dekodowanie - za pomocą konstruktora klasy String
       String txt = new String(bytes, in_enc);

       // enkodowanie za pomocą metody getBytes z klasy String
       // utworzenie nowego bufora dla kanału wyjściowego
       // zapis do pliku poprzez kanał
       bytes = txt.getBytes(out_enc);
       buf = ByteBuffer.wrap(bytes);
       fcout.write(buf);

       fcin.close();
       fcout.close();
    } catch (Exception e) {
        System.err.println(e);
        System.exit(1);
    }

  }
} 

• Klasy CharsetDecoder i CharsetEncoder  dostarczają bogatych środków i pełnej kontroli nad procesem kodowania i dekodowania.

• Klasa Charset dostarcza definicji stron kodowych, a także wygodnych metod kodowania i dekodowania (które są łatwiejsze w użyciu niż zastosowanie klas CharsetEncoder i CharsetDecoder).

import java.io.*;
import java.nio.*;
import java.nio.channels.*;
import java.nio.charset.*;


class Ende2 {

  public static void main(String[] args) {

    if (args.length != 4) {
      System.out.println("Syntax: in in_enc out out_enc");
      System.exit(1);
    }

    String infile  = args[0],     // plik wejściowy
           in_enc  = args[1],     // wejściowa strona kodowa
           outfile = args[2],     // plik wyjściowy
           out_enc = args[3];     // wyjściowa strona kodowa

    try {
       FileChannel fcin = new FileInputStream(infile).getChannel();
       FileChannel fcout = new FileOutputStream(outfile).getChannel();
       ByteBuffer buf = ByteBuffer.allocate((int)fcin.size());

       // czytanie z kanału
       fcin.read(buf);

       // Strony kodowe
       Charset inCharset  = Charset.forName(in_enc),
               outCharset = Charset.forName(out_enc);

       // dekodowanie bufora bajtowego
       buf.flip();
       CharBuffer cbuf = inCharset.decode(buf);

       // enkodowanie bufora znakowego
       // i zapis do pliku poprzez kanał

       buf = outCharset.encode(cbuf);
       fcout.write(buf);

       fcin.close();
       fcout.close();
    } catch (Exception e) {
        System.err.println(e);
        System.exit(1);
    }
  }
}

K.7. NIO: operacje kanałowe na wielu buforach (scattering i gathering)

import java.io.*;
import java.nio.*;
import java.nio.channels.*;

public class ScatteringTest {

  static final String fname = "scatter.tst";  // nazwa pliku testowego

  public static void main(String[] args) throws Exception {

    // Zapisywanie danych testowych

    DataOutputStream out = new DataOutputStream(
    	                       new FileOutputStream(fname) );
    short[]  dat1 = { 1, 2, 3, };
    double[] dat2 = { 10.1, 10.2, 10.3 };
    for (int i=0; i < dat1.length; i++) out.writeShort(dat1[i]);
    for (int i=0; i < dat2.length; i++) out.writeDouble(dat2[i]);
    out.close();

    //-----------------------------------------------------------+
    // Odczytywanie danych testowych                             |
    //-----------------------------------------------------------+

    FileInputStream in = new FileInputStream(fname);

    // Uzyskanie kanału
    FileChannel channel = in.getChannel();

    // Tablica bajt-buforów
    final int SHORT_SIZE  = 2,  // ile bajtów ma short
              DOUBLE_SIZE = 8;  // ........... i double

    ByteBuffer[] buffers = { ByteBuffer.allocate(dat1.length*SHORT_SIZE),
                             ByteBuffer.allocate(dat2.length*DOUBLE_SIZE)
                           };
    // jedno czytanie z kanału zapisuje kilka buforów !
    long r = channel.read(buffers);

    System.out.println("Liczba bajtów przeczytanych do obu buforów: " + r);

    // Przed uzyskiwaniem danych z buforów - trzeba je przestawić!
    buffers[0].flip();
    buffers[1].flip();

    // Pierwssy bufor
    // Widok na bufor jako na zawierający liczby short
    ShortBuffer buf1 = buffers[0].asShortBuffer();
    System.out.println("Dane 1");
    while ( buf1.hasRemaining()) {
      short elt = buf1.get();
      System.out.println(elt);
    }

    // Drugi bufor
    // Widok na bufor jako na zawierający liczby double
    DoubleBuffer buf2 = buffers[1].asDoubleBuffer();
    System.out.println("Dane 2");
    while ( buf2.hasRemaining()) System.out.println(buf2.get());
  }
}

import java.io.*;
import java.nio.*;
import java.nio.channels.*;
import java.nio.charset.*;

class GatheringTest {

  public static void main(String[] args) throws Exception {

    // To będą stałe części każdego pliku
    String sHeader = "To jest nagłówek. Może być duży";
    String sFooter = "To jest zakończenie. Może być duże";

    // To będą dane, które się zmieniają od pliku do pliku
    byte[][] dane = { { 1, 2, 3},       // dane 1-go pliku
                     { 9, 10, 11, 12 }, // dane 2-go pliku
                     { 100, 101}        // dane 3-go pliku
                   };

    Charset charset = Charset.forName("windows-1250");
    ByteBuffer header = charset.encode(CharBuffer.wrap(sHeader)),
               footer = charset.encode(CharBuffer.wrap(sFooter));

    // Drugi element tablicy buforów będzie dynamicznie się zmienial
    // na razie = null
    ByteBuffer[] contents = { header, null, footer };
    for (int i = 0; i<dane.length; i++) {
      FileChannel fc = new FileOutputStream("plik"+i).getChannel();
      contents[1] = ByteBuffer.wrap(dane[i]);  // podstawienie zmiennych danych
      fc.write(contents);                      // zapis danych ze wszystkich buforów!
      fc.close();
      header.rewind();
      footer.rewind();
    }
  }


}

K.8. NIO: mapowanie plików

import java.io.*;
import java.nio.*;
import java.nio.channels.*;

class MapFiles1 {

  String fname = "test";

  public MapFiles1() throws Exception {
    init();         // inicjacja pliku testowego
    mapAndChange(); // mapowanie i zmiana danych pliku
    checkResult();  // sprawdzenie wyników
  }

  void init() throws IOException {
    int[] data = { 10, 11, 12, 13 };
    DataOutputStream out = new DataOutputStream(
                               new FileOutputStream(fname)
                            );
    for (int i=0; i<data.length; i++) out.writeInt(data[i]);
    out.close();
  }

  void mapAndChange() throws IOException {

    // Aby dokonywać zmian musimy przyłączyć kanal
    // do pliku otwartego w trybie "read-write"
    RandomAccessFile file =  new RandomAccessFile(fname, "rw");
    FileChannel channel = file.getChannel();

    // Mapowanie pliku
    MappedByteBuffer buf;
    buf  = channel.map(
                FileChannel.MapMode.READ_WRITE,  // tryb "odczyt-zapis"
                                             0,  // od początku pliku
                            (int)channel.size()  // cały plik
            );

    // Uzyskujemy widok na bufor = zmapowany plik
    IntBuffer ibuf = buf.asIntBuffer();

    // Dla ciekawości: jakie charakterystyki widoku
    System.out.println(ibuf + " --- Direct: " +  ibuf.isDirect());

    int i = 0;
    while (ibuf.hasRemaining()) {
      int num = ibuf.get();       // pobieramy kolejny element
      ibuf.put(i++, num * 10);    // zapisujemy jego wartość*10 na jego pozycji    }
    }

    // Zapewnia, że zmiany na pewno zostaną odzwierciedlone w pliku
    buf.force();

    channel.close();
  }

  void checkResult() throws IOException {
    DataInputStream in = null;
    try {
      in = new DataInputStream(new FileInputStream(fname));
      while(true) System.out.println(in.readInt());
    } catch(EOFException exc) {
        return;
    } finally {
        in.close();
    }
  }

  public static void main(String[] args) throws Exception  {
    new MapFiles1();
  }
}

• program praktycznie nie konsumuje pamięci dla przechowywania pliku (zarówno MappedByteBuffer, jak i jego widok jako IntBuffer są buforami bezpośrednimi)
• po zmapowaniu pliku, pozycja bufora bajtowego jest ustawiona na 0,  a jego pojemność i limit na liczbę zmapowanych bajtów; widoki "dziedziczą" te ustawienia, dokonując jedynie przeliczeń limitu i pojmeności z uwzględnieniem rozmiaru typu elementów,
  
• użycie metody force() z klasy MappedByteBuffer zapewnia fizyczny zapis do pliku; sposób i częstostliwość fizycznego zapisu zmienianych w buforze danych zależy od systemu operacyjnego, może się okazać, że nawet po zamknięciu kanału, systemowe czy sprzętowe cache/bufory nie są wymiatane.

• dekodowanie bufora bajtowego tworzy nowy bufor znakowy, który opakowuje tablicę elementów typu char[]. Ta tablica istnieje (ona własnie, praktycznie, jest tym buforem znakowym) i możemy mieć do niej dostęp poprzez odwołanie array() z klasy CharBuffer (dla wszystkich klas buforowych metoda array zwraca tablicę opakowaną przez bufor, ale tylko wtedy, gdy takie opakowanie miało miejsce),
• czasem potrzebne może być zastosowanie klasy CharsetEncoder (jej metody encode używamy po to by dokonać kodowania do już istniejącego bufora bajtowego,  w naszym przypadku - mapującego plik). Analogicznie (ale niejako w drugą stronę)  może być zastosowana klasa CharsetDecoder.

import java.io.*;
import java.nio.*;
import java.nio.channels.*;
import java.nio.charset.*;

class MapFiles2 {

  public static void main(String[] args) throws Exception  {
    Charset inCharset = Charset.forName("windows-1250"),
           outCharset = Charset.forName("ISO-8859-2");

    RandomAccessFile file = new RandomAccessFile(args[0], "rw");
    FileChannel fc = file.getChannel();

    // Mapowanie pliku
    MappedByteBuffer mbb = fc.map(FileChannel.MapMode.READ_WRITE,
                                  0, (int) fc.size());

    // Utworzenia bufora znakowego ze zdekodowanymi znakami
    // z bufora bajtowego (mapujące plik). Konwersja: win1250->unicode
    CharBuffer cbuf = inCharset.decode(mbb);

    // Okazuje się, że ten nowo utworzony bufor opakowuje tablicę
    // zatem możemy ją uzyskać i działać na jej elementach
    // to dzialanie oznacza dzialanie na elementach bufora
    char[] chArr = cbuf.array();
    for (int i=0; i < chArr.length; i++)
      chArr[i] = Character.toUpperCase(chArr[i]);

    // Po dekodowaniu bufor bajtowy musi być przewinięty do początku
    // aby koder (zob. dalej) mógł w nim zapisywać kodowane dane
    mbb.rewind();

    // Utworzenie kodera, zamieniającego Unicode na wyjściową stronę kodową
    CharsetEncoder encoder = outCharset.newEncoder();

    // Koder zapisuje istniejący bufor mbb (ten który mapuje plik)
    // ostatni argument - true oznacza zakończenie pracy kodera na tym wywołaniu
    encoder.encode(cbuf, mbb, true);
    fc.close();
  }
}

K.9. NIO: bezpośrednie transfery kanałowe

• bezpośredni transfer kanałowy z dowolnego kanalu do kanalu plikowego (metoda transferTo)
• bezpośredni transfer kanalowy z kanalu plikowego do dowlonego kanału (metoda transferFrom)

import java.nio.*;
import java.nio.channels.*;
import java.io.*;

class DirectTransfer {

  String inFileName;
  String outFileName;

  DirectTransfer(String infn, String outfn) throws Exception {
    inFileName  = infn;
    outFileName = outfn;
    directTransfer();
    copyByStream();
  }


  void directTransfer() throws Exception {

    FileInputStream in = new FileInputStream(inFileName);
    FileOutputStream out =  new FileOutputStream(outFileName);
    FileChannel fcin = in.getChannel();
    FileChannel fcout = out.getChannel();
    long size = fcin.size();
    System.out.println("Copying file " + size + "B.");

    long start =  System.currentTimeMillis();

    // Bezpośredni transfer
    fcout.transferFrom(fcin, 0, size);

    long end = System.currentTimeMillis();

    System.out.println("Direct transfer time " + (end - start));

   }


  final int BUFSIZE = 5000000;
  void copyByStream() throws Exception  {

    FileInputStream fin = new FileInputStream(inFileName);
    BufferedInputStream in = new BufferedInputStream(fin, BUFSIZE );
    FileOutputStream fout = new FileOutputStream(outFileName);
    BufferedOutputStream out = new BufferedOutputStream(fout, BUFSIZE);

    byte[] b = new byte[BUFSIZE];
    long start =  System.currentTimeMillis();
    while (true) {
      int n = in.read(b);
      if (n == -1) break;
      out.write(b, 0, n);
    }
    in.close();
    out.close();

    long end = System.currentTimeMillis();
    System.out.println("Stream time " + (end - start));
  }


   public static void main(String[] args) throws Exception {
     new DirectTransfer(args[0], args[1]);
   }
}