File.read(fileDesc, buf, len);
Socket.send(socket, buf, len);

import java.io.DataOutputStream;
import java.io.FileInputStream;
import java.io.IOException;
import java.net.Socket;
import java.net.UnknownHostException;

public class TraditionalClient {


	public static void main(String[] args) {

		int port = 2000;
		String server = "localhost";
		Socket socket = null;
		String lineToBeSent;

		DataOutputStream output = null;
		FileInputStream inputStream = null;
		int ERROR = 1;


		// connect to server
		try {
			socket = new Socket(server, port);
			System.out.println("Connected with server " +
					socket.getInetAddress() +
					":" + socket.getPort());
		}
		catch (UnknownHostException e) {
			System.out.println(e);
			System.exit(ERROR);
		}
		catch (IOException e) {
			System.out.println(e);
			System.exit(ERROR);
		}

		try {
			String fname = "sendfile/NetworkInterfaces.c";
			inputStream = new FileInputStream(fname);

			output = new DataOutputStream(socket.getOutputStream());
			long start = System.currentTimeMillis();
			byte[] b = new byte[4096];
			long read = 0, total = 0;
			while ((read = inputStream.read(b)) >= 0) {
				total = total + read;
				output.write(b);
			}
			System.out.println("bytes send--" + total + " and totaltime--" + (System.currentTimeMillis() - start));
		}
		catch (IOException e) {
			System.out.println(e);
		}

		try {
			output.close();
			socket.close();
			inputStream.close();
		}
		catch (IOException e) {
			System.out.println(e);
		}
	}
}

/**
   * Transfers bytes from this channel's file to the given writable byte
   * channel.
   *
   * <p> An attempt is made to read up to <tt>count</tt> bytes starting at
   * the given <tt>position</tt> in this channel's file and write them to the
   * target channel.  An invocation of this method may or may not transfer
   * all of the requested bytes; whether or not it does so depends upon the
   * natures and states of the channels.  Fewer than the requested number of
   * bytes are transferred if this channel's file contains fewer than
   * <tt>count</tt> bytes starting at the given <tt>position</tt>, or if the
   * target channel is non-blocking and it has fewer than <tt>count</tt>
   * bytes free in its output buffer.
   *
   * <p> This method does not modify this channel's position.  If the given
   * position is greater than the file's current size then no bytes are
   * transferred.  If the target channel has a position then bytes are
   * written starting at that position and then the position is incremented
   * by the number of bytes written.
   *
   * <p> This method is potentially much more efficient than a simple loop
   * that reads from this channel and writes to the target channel.  Many
   * operating systems can transfer bytes directly from the filesystem cache
   * to the target channel without actually copying them.  </p>
   *
   * @param  position
   *         The position within the file at which the transfer is to begin;
   *         must be non-negative
   *
   * @param  count
   *         The maximum number of bytes to be transferred; must be
   *         non-negative
   *
   * @param  target
   *         The target channel
   *
   * @return  The number of bytes, possibly zero,
   *          that were actually transferred
   *
   * @throws IllegalArgumentException
   *         If the preconditions on the parameters do not hold
   *
   * @throws  NonReadableChannelException
   *          If this channel was not opened for reading
   *
   * @throws  NonWritableChannelException
   *          If the target channel was not opened for writing
   *
   * @throws  ClosedChannelException
   *          If either this channel or the target channel is closed
   *
   * @throws  AsynchronousCloseException
   *          If another thread closes either channel
   *          while the transfer is in progress
   *
   * @throws  ClosedByInterruptException
   *          If another thread interrupts the current thread while the
   *          transfer is in progress, thereby closing both channels and
   *          setting the current thread's interrupt status
   *
   * @throws  IOException
   *          If some other I/O error occurs
   */
  public abstract long transferTo(long position, long count,
                                  WritableByteChannel target)
      throws IOException;

File.read(fileDesc, buf, len);
Socket.send(socket, buf, len);

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.net.InetSocketAddress;
import java.net.SocketAddress;
import java.nio.channels.FileChannel;
import java.nio.channels.SocketChannel;

public class TransferToClient {
	
	public static void main(String[] args) throws IOException{
		TransferToClient sfc = new TransferToClient();
		sfc.testSendfile();
	}
	public void testSendfile() throws IOException {
	    String host = "localhost";
	    int port = 9026;
	    SocketAddress sad = new InetSocketAddress(host, port);
	    SocketChannel sc = SocketChannel.open();
	    sc.connect(sad);
	    sc.configureBlocking(true);

	    String fname = "sendfile/NetworkInterfaces.c";
	    long fsize = 183678375L, sendzise = 4094;
	    
	    // FileProposerExample.stuffFile(fname, fsize);
	    FileChannel fc = new FileInputStream(fname).getChannel();
            long start = System.currentTimeMillis();
	    long nsent = 0, curnset = 0;
	    curnset =  fc.transferTo(0, fsize, sc);
	    System.out.println("total bytes transferred--"+curnset+" and time taken in MS--"+(System.currentTimeMillis() - start));
	    //fc.close();
	  }
}

log-bin = /Users/rollenholt/Downloads/mysql/binlog
binlog-format = ROW
server_id = 1

~/Downloads/mysql » ls
binlog.000001 binlog.000002 binlog.000003 binlog.000004 binlog.index
------------------------------------------------------------
~/Downloads/mysql » cat binlog.index
/Users/rollenholt/Downloads/mysql/binlog.000001
/Users/rollenholt/Downloads/mysql/binlog.000002
/Users/rollenholt/Downloads/mysql/binlog.000003
/Users/rollenholt/Downloads/mysql/binlog.000004
------------------------------------------------------------
~/Downloads/mysql » cat binlog.000001
_binR �[w{5.7.20-logR �[8


**4SVѶR �[#��_]�hu �[����%                                                                        ------------------------------------------------------------
~/Downloads/mysql »

public class Array<T> implements Iterable<T> {
    T[] values;  // this contains the actual elements of the array

    // Constructor that takes a "raw" array and stores it
    public Array(T[] values) {
        this.values = values;
    }

    // This is a private class that implements iteration over the elements
    // of the list. It is not accessed directly by the user, but is used in
    // the iterator() method of the Array class. It implements the hasNext()
    // and next() methods.
    class ArrayIterator implements Iterator<T> {
        int current = 0;  // the current element we are looking at

        // return whether or not there are more elements in the array that
        // have not been iterated over.
        public boolean hasNext() {
            if (current < Array.this.values.length) {
                return true;
            } else {
                return false;
            }
        }

        // return the next element of the iteration and move the current
        // index to the element after that.
        public T next() {
            if (!hasNext()) {
                throw new NoSuchElementException();
            }
            return values[current++];
        }
    }

    // Return the value at a given index
    public T get(int index) {
        return values[index];
    }

    // Set the value at a given index
    public void set(int index, T value) {
        values[index] = value;
    }

    // Return the length of the array
    public int length() {
        return values.length;
    }

    // Return an iterator over the elements in the array. This is generally not
    // called directly, but is called by Java when used in a "simple" for loop.
    public Iterator<T> iterator() {
        return new ArrayIterator();
    }

    // This is just a sample program that can be run to show how the Array
    // class might be used.
    public static void main(String[] args) {
        // create an array of strings
        String[] strings = new String[]{"Hello", "World"};

        // create a new array to hold these strings
        Array<String> array = new Array<String>(strings);

        // get and print the first values (prints "Hello")
        System.out.println(array.get(0));

        // set the second value
        array.set(1, "Javaland!");

        // iterate over the array, printing "Hello\nJavaland!"
        for (String s : array) {
            System.out.println(s);
        }
    }
}

/**
 * Computes or retrieves the value corresponding to {@code key}.
 *
 * @param key the non-null key whose value should be loaded
 * @return the value associated with {@code key}; <b>must not be null</b>
 * @throws Exception if unable to load the result
 * @throws InterruptedException if this method is interrupted. {@code InterruptedException} is
 *     treated like any other {@code Exception} in all respects except that, when it is caught,
 *     the thread's interrupt status is set
 */
public abstract V load(K key) throws Exception;

import java.util.concurrent.ExecutionException;

import com.google.common.cache.CacheBuilder;
import com.google.common.cache.CacheLoader;
import com.google.common.cache.LoadingCache;


public class Test {

	public static void main(String[] args) {
		LoadingCache cache = CacheBuilder.newBuilder().build(new CacheLoader<Object, Object>() {
			@Override
			public Object load(Object key) {
				return null;
			}
		});

		try {
			cache.getUnchecked("asda");
		}
		catch (Exception e) {
			System.out.println("本例子中这里会出现异常 这里会cache住抛出异常");
		}

		try {
			cache.get("adsa");
		}
		catch (ExecutionException e) {
			System.out.println("本例子中不会抛出这个异常");
		}catch (Exception e) {
			System.out.println("本例子中这里会出现异常 这里会cache住抛出异常");
		}

		System.out.println("fuck");

	}
}

# Default Homebrew MySQL server config
[mysqld]
# Only allow connections from localhost
bind-address = 127.0.0.1