package com.bjmashibing.system.io;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.InetSocketAddress;
import java.net.ServerSocket;
import java.net.Socket;

/**
 * @author: 马士兵教育
 * @create: 2020-05-17 05:34
 * BIO  多线程的方式
 */
public class SocketIOPropertites {


    //server socket listen property:
    private static final int RECEIVE_BUFFER = 10;
    private static final int SO_TIMEOUT = 0;
    private static final boolean REUSE_ADDR = false;
    private static final int BACK_LOG = 2;
    //client socket listen property on server endpoint:
    private static final boolean CLI_KEEPALIVE = false;
    private static final boolean CLI_OOB = false;
    private static final int CLI_REC_BUF = 20;
    private static final boolean CLI_REUSE_ADDR = false;
    private static final int CLI_SEND_BUF = 20;
    private static final boolean CLI_LINGER = true;
    private static final int CLI_LINGER_N = 0;
    private static final int CLI_TIMEOUT = 0;
    private static final boolean CLI_NO_DELAY = false;
/*

    StandardSocketOptions.TCP_NODELAY
    StandardSocketOptions.SO_KEEPALIVE
    StandardSocketOptions.SO_LINGER
    StandardSocketOptions.SO_RCVBUF
    StandardSocketOptions.SO_SNDBUF
    StandardSocketOptions.SO_REUSEADDR

 */


    public static void main(String[] args) {

        ServerSocket server = null;
        try {
            server = new ServerSocket();
            server.bind(new InetSocketAddress(9090), BACK_LOG);
            server.setReceiveBufferSize(RECEIVE_BUFFER);
            server.setReuseAddress(REUSE_ADDR);
            server.setSoTimeout(SO_TIMEOUT);

        } catch (IOException e) {
            e.printStackTrace();
        }
        System.out.println("server up use 9090!");
        try {
            while (true) {

                // System.in.read();  //分水岭：

                Socket client = server.accept();  //阻塞的，没有 -1  一直卡着不动  accept(4,
                System.out.println("client port: " + client.getPort());

                client.setKeepAlive(CLI_KEEPALIVE);
                client.setOOBInline(CLI_OOB);
                client.setReceiveBufferSize(CLI_REC_BUF);
                client.setReuseAddress(CLI_REUSE_ADDR);
                client.setSendBufferSize(CLI_SEND_BUF);
                client.setSoLinger(CLI_LINGER, CLI_LINGER_N);
                client.setSoTimeout(CLI_TIMEOUT);
                client.setTcpNoDelay(CLI_NO_DELAY);

                //client.read   //阻塞   没有  -1 0
                new Thread(
                        () -> {
                            try {
                                InputStream in = client.getInputStream();
                                BufferedReader reader = new BufferedReader(new InputStreamReader(in));
                                char[] data = new char[1024];
                                while (true) {

                                    int num = reader.read(data);

                                    if (num > 0) {
                                        System.out.println("client read some data is :" + num + " val :" + new String(data, 0, num));
                                    } else if (num == 0) {
                                        System.out.println("client readed nothing!");
                                        continue;
                                    } else {
                                        System.out.println("client readed -1...");
                                        System.in.read();
                                        client.close();
                                        break;
                                    }
                                }

                            } catch (IOException e) {
                                e.printStackTrace();
                            }

                        }
                ).start();

            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                server.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

    }
}

package com.bjmashibing.system.io;

import java.io.*;
import java.net.Socket;

/**
 * @author: 马士兵教育
 * @create: 2020-05-17 16:18
 */
public class SocketClient {

    public static void main(String[] args) {

        try {
            Socket client = new Socket("192.168.150.11",9090);

            client.setSendBufferSize(20);
            client.setTcpNoDelay(true);
            OutputStream out = client.getOutputStream();

            InputStream in = System.in;
            BufferedReader reader = new BufferedReader(new InputStreamReader(in));

            while(true){
                String line = reader.readLine();
                if(line != null ){
                    byte[] bb = line.getBytes();
                    for (byte b : bb) {
                        out.write(b);
                    }
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

连接一台服务器：服务器程序
javac SocketIOPropertities.java && java SocketIOPropertities

----------------------------------
另一个窗口：查看网络连接
netstat -natp

==客户端启动以后，建立了一个socket连接，但是socket没有分配使用；Recv-Q=4

netstat -natp

==服务端回车：socket连接分配了，分配给了7932/java

----------------------------------
再开一个窗口:打开TCP监控,开启监听，抓取数据包
tcpdump -nn -i eth0 port 9090
    服务端会开启LISTEN状态，监听端口号9090
    
jps   得到服务端程序的进程号是7932

lsof -p 7932    可以看到文件描述符为5， TYPE=IPv4   NODE=TCP   NAME=*:websm(LISTEN)  是LISTEN状态

==客户端启动以后，抓到三次握手

lsof -p 7932   文件描述符还是5

lsof -p 7932   文件描述符多了6  TYPE=IPv4 NODE=TCP  NAME=node01:websm->node02:47513(ESTABLISHED)

==========================
连接另一台服务器：客户端程序
javac SocketClient.java && java SocketClient

==========================

1.服务器刚启动的时候
    1）TCP会开启LISTEN状态，监听端口号9090
    
    2）服务器进程的文件描述符为5，TYPE=IPv4, NODE=TCP,NAME=*:websm(LISTEN)  是LISTEN状态

2.启动客户端
    1）服务器抓到三次握手
    
    2）服务器内核建立了一个socket连接，但是socket没有分配使用;Recv-Q=4
        说明什么是连接，连接不是物理的，双方通过三次握手开辟了资源，可以为对方提供服务了，那这个连接就已经有了；它看不见摸不着，是通过资源来代表的
        
3.服务器端回车
    1）服务器打印：client port:47513
    client read some data is :4 val:1111   内核中缓存的4个字节也读到了
    
    2）socket连接分配了，分配给了7932/java
    
    3）服务器进程多了文件描述符6

三次握手：
客户端发送syn到服务端；
服务端发送syn+ack到客户端
客户端再发送ack到服务器

client.setSendBufferSize(20);//发送的缓冲区为20字节
client.setTcpNoDelay(false);//默认为起优化的状态：

TestSocket

/usr/java/j2sdk1.4.2_18/bin/javac TestSocket.java    用jdk1.4.2编译代码

starace -ff -o out  /usr/java/j2sdk1.4.2_18/bin/java TestSocket
    -ff  抓取所有跑的线程
    -o   给出输出文件的前缀，追踪每一个线程对内核的系统调用，并每一个线程都独立输出

man man

man tcp

man ip

man bash

man 2 socket

这套系统调用是：
Socket返回文件描述符，例如FD3
bind绑定，例如绑定到8090端口：bind(fd3,8090)
listen监听FD3

可以通过netstat -natp 进行查看结果，结果：0.0.0.0:8090  0.0.0.0:* LISTEN

应用程序走完上面这几步，才能拿到这个Listen状态

有了Listen状态，调用accept，例如accept(fd3,      
等待客户端的连接，这时进入阻塞状态

客户端连接以后，得到另一个文件描述符，例如FD5
需要注意：有两个socket，一个是服务端的Listen状态的socket，一个客户端连接以后的socket

有了FD5以后，想读，需要receive()，这时又有可能进入一个阻塞状态：等待数据传输

java代码中有两处会出现阻塞：一个是等待客户端连接；一个是读取数据阻塞

是如何解决这两个阻塞的呢？抛出去一个线程（进行数据的读写）

主线程等待客户端连接，客户端连接以后clone一个线程

clone的线程：阻塞，读取一个连接