IO

//server
// 监听8080端口
ServerSocket server = new ServerSocket(8080);
// 等待请求
Socket socket = server.accept();
// 进行通信
BufferedReader reader = new BufferedReader(
        new InputStreamReader(socket.getInputStream()));
String line = reader.readLine();
System.out.println(line);
PrintWriter writer = new PrintWriter(socket.getOutputStream());
writer.println(line);
writer.flush(); // 不要忘了这个
// 关闭资源
writer.close();
reader.close();
socket.close();
server.close();

//client
// 监听8080端口
Socket socket = new Socket("127.0.0.1", 8080);
// 开始通信
PrintWriter writer = new PrintWriter(socket.getOutputStream());
writer.println("hello");
writer.flush();
BufferedReader reader = new BufferedReader(
        new InputStreamReader(socket.getInputStream()));
String line = reader.readLine();
System.out.println(line);
// 关闭资源
writer.close();
reader.close();
socket.close();

//服务端
// 选择器、字符集
private Selector selector = null;
private Charset charset = Charset.forName("UTF-8");
// 打开管道
ServerSocketChannel server = ServerSocketChannel.open();
InetSocketAddress isa = new InetSocketAddress("127.0.0.1", 9999);
server.socket().bind(isa);
server.configureBlocking(false);
// 打开选择器
selector = Selector.open();
server.register(selector, SelectionKey.OP_ACCEPT);
// 依次处理选择器上的选择键
while(selector.select() > 0) {
    for(SelectionKey sk : selector.selectedKeys()) {
        selector.selectedKeys().remove(sk);
        // 连接请求
        if(sk.isAcceptable()) {
            SocketChannel sc = server.accept();
            sc.configureBlocking(false);
            sc.register(selector, SelectionKey.OP_READ);
            sk.interestOps(SelectionKey.OP_ACCEPT);
        }
        // 存在可读取数据
        if(sk.isReadable()) {
            // 使用缓冲区读取
            SocketChannel sc = (SocketChannel) sk.channel();
            ByteBuffer buff = ByteBuffer.allocate(1024);
            String content = "";
            try {
                while(sc.read(buff) > 0) {
                    buff.flip();
                    content += charset.decode(buff);
                }
                System.out.println("=======" + content);
                // 将管道设置为准备下一次读取
                sk.interestOps(SelectionKey.OP_READ);
            } catch(IOException e) {
                // 如果该sk对应的管道出现异常，表明管道的客户端出现异常，
                // 所以从选择器中取消sk
                e.printStackTrace();
                sk.cancel();
                if(sk.channel() != null) {
                    sk.channel().close();
                }
            }
            // 说明聊天信息不为空
            if(content.length() > 0) {
                // 将聊天信息输入每个选择键对应的管道中
                for(SelectionKey key : selector.keys()) {
                    Channel targetChannel = key.channel();
                    if(targetChannel instanceof SocketChannel) {
                        SocketChannel dest = (SocketChannel) targetChannel;
                        dest.write(charset.encode(content));
                    }
                }
            }
        }
    }
}

// 客户端
// 管道、选择器、字符集
private SocketChannel sc = null;
private Selector selector = null;
private Charset charset = Charset.forName("UTF-8");
//创建线程类用于从服务端获取数据
private class ClientThread extends Thread {
    public void run() {
        try {
            // 遍历所有选择键
            while(selector.select() > 0) {
                for(SelectionKey sk : selector.selectedKeys()) {
                    // 删除正在处理的
                    selector.selectedKeys().remove(sk);
                    // 如果该键对应的通道中有可读的数据
                    if(sk.isReadable()) {
                        // 使用缓冲区读取管道内的数据
                        SocketChannel sc = (SocketChannel) sk.channel();
                        ByteBuffer buff = ByteBuffer.allocate(1024);
                        String content = "";
                        while(sc.read(buff) > 0) {
                            buff.flip();
                            content += charset.decode(buff);
                        }
                        // 打印
                        System.out.println("聊天信息" + content);
                        sk.interestOps(SelectionKey.OP_READ);
                    }
                }
            }
        } catch(IOException e) {
            e.printStackTrace();
        }
    }
}
// 初始化SocketChannel
InetSocketAddress isa = new InetSocketAddress("127.0.0.1", 9999);
sc = SocketChannel.open(isa);
sc.configureBlocking(false);
// 注册选择器
selector = Selector.open();
sc.register(selector, SelectionKey.OP_READ);
创建线程从服务端拉取数据，及不断从键盘读入发送到服务端
// 启动线程不断从服务端拉取
new ClientThread().start();
// 读取键盘输入到通道
Scanner reader = new Scanner(System.in);
while(reader.hasNextLine()) {
    String line = reader.nextLine();
    sc.write(charset.encode(line));
}

public class ReadFromFile {
  public static void main(String[] args) throws Exception {
    Path file = Paths.get("/usr/a.txt");
    AsynchronousFileChannel channel = AsynchronousFileChannel.open(file);

    ByteBuffer buffer = ByteBuffer.allocate(100_000);
    Future<Integer> result = channel.read(buffer, 0);

    while (!result.isDone()) {
      ProfitCalculator.calculateTax();
    }
    Integer bytesRead = result.get();
    System.out.println("Bytes read [" + bytesRead + "]");
  }
}
class ProfitCalculator {
  public ProfitCalculator() {
  }
  public static void calculateTax() {
  }
}
public class WriteToFile {

  public static void main(String[] args) throws Exception {
    AsynchronousFileChannel fileChannel = AsynchronousFileChannel.open(
        Paths.get("/asynchronous.txt"), StandardOpenOption.READ,
        StandardOpenOption.WRITE, StandardOpenOption.CREATE);
    CompletionHandler<Integer, Object> handler = new CompletionHandler<Integer, Object>() {

      @Override
      public void completed(Integer result, Object attachment) {
        System.out.println("Attachment: " + attachment + " " + result
            + " bytes written");
        System.out.println("CompletionHandler Thread ID: "
            + Thread.currentThread().getId());
      }

      @Override
      public void failed(Throwable e, Object attachment) {
        System.err.println("Attachment: " + attachment + " failed with:");
        e.printStackTrace();
      }
    };

    System.out.println("Main Thread ID: " + Thread.currentThread().getId());
    fileChannel.write(ByteBuffer.wrap("Sample".getBytes()), 0, "First Write",
        handler);
    fileChannel.write(ByteBuffer.wrap("Box".getBytes()), 0, "Second Write",
        handler);

  }
}