Tan RD

@Bean
@ConditionalOnBean({ReactiveDiscoveryClient.class})
@ConditionalOnMissingBean
@ConditionalOnProperty(
    value = {"spring.cloud.loadbalancer.configurations"},
    havingValue = "health-check"
)
public ServiceInstanceListSupplier healthCheckDiscoveryClientServiceInstanceListSupplier(ConfigurableApplicationContext context) {
    return ServiceInstanceListSupplier.builder().withDiscoveryClient().withHealthChecks().withCaching().build(context);
}

public Person findCurrentUser() {
    if (isAuthenticated()) return new Person("Jane", "Doe");
    else return null;
}

public Optional<Person> findCurrentUser() {
    if (isAuthenticated()) return Optional.of(new Person("Jane", "Doe"));
    else return Optional.empty();
}

public class BIOServer {
    public static void main(String[] args) {
        try {
            ServerSocket serverSocket = new ServerSocket(8888);
            System.out.println("Waiting for client...");
            //执行到accept开始阻塞等待客户端连接
            Socket socket = serverSocket.accept();
            System.out.println("Client connected.");
            BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(socket.getInputStream()));
            System.out.println("Server received:");
            String line;
            while ((line = bufferedReader.readLine()) != null) {
                //不断输出用户传输的数据
                System.out.println(line);
                //收到客户端传输的exit则退出
                if (line.equals("exit")) {
                    break;
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

public class BIOClient {
    public static void main(String[] args) {
        try {
            Socket socket = new Socket("127.0.0.1", 8888);
            String input;
            while (true) {
                input = (new BufferedReader(new InputStreamReader(System.in))).readLine();
                BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
                writer.write(input + "\n");
                writer.flush();
            }


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

public class BIOServer2 {
    public static void main(String[] args) {
        try {
            ServerSocket serverSocket = new ServerSocket(8888);
            while (true) {
                System.out.println("Waiting for client...");
                //执行到accept开始阻塞等待客户端连接
                Socket socket = serverSocket.accept();
                System.out.println("Client connected.");
                BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(socket.getInputStream()));
                System.out.println("Server received:");
                String line;
                while ((line = bufferedReader.readLine()) != null) {
                    //不断输出用户传输的数据
                    System.out.println(line);
                    //收到客户端传输的exit则退出
                    if (line.equals("exit")) {
                        break;
                    }
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

public class BIOServer3 {
    public static void main(String[] args) {
        try {
            ServerSocket serverSocket = new ServerSocket(8888);
            while (true) {
                System.out.println("Waiting for client...");
                //执行到accept开始阻塞等待客户端连接
                Socket socket = serverSocket.accept();
                System.out.println("Client connected.");
                new Thread(() -> {
                    BufferedReader bufferedReader;
                    try {
                        bufferedReader = new BufferedReader(new InputStreamReader(socket.getInputStream()));
                        System.out.println("Server received:");
                        String line;
                        while ((line = bufferedReader.readLine()) != null) {
                            //不断输出用户传输的数据
                            System.out.println(line);
                            //收到客户端传输的exit则退出
                            if (line.equals("exit")) {
                                break;
                            }
                        }
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }).start();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

public class NIOServer {
    public static void main(String[] args) {
        try {
            ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
            serverSocketChannel.configureBlocking(false);
            ServerSocket serverSocket = serverSocketChannel.socket();
            serverSocket.bind(new InetSocketAddress(8888));
            Selector selector = Selector.open();
            serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);
            while (true) {
                //等待SelectionKey事件到来
                selector.select();
                Iterator<SelectionKey> iterator = selector.selectedKeys().iterator();
                while (iterator.hasNext()) {
                    SelectionKey selectionKey = iterator.next();
                    //删除key，否则下一次还将会读取到
                    iterator.remove();
                    SelectableChannel channel = selectionKey.channel();
                    if (selectionKey.isValid() && selectionKey.isAcceptable()) {
                        ServerSocketChannel serSocketChannel = (ServerSocketChannel) channel;
                        SocketChannel socketChannel = serSocketChannel.accept();
                        socketChannel.configureBlocking(false);
                        //取到了客户端的socketChannel后，注册读取事件到Selector
                        socketChannel.register(selector, SelectionKey.OP_READ);
                    } else if (selectionKey.isValid() && selectionKey.isReadable()) {
                        //可读SelectionKey到达，读取数据
                        SocketChannel socketChannel = (SocketChannel) channel;
                        ByteBuffer buffer = ByteBuffer.allocate(128);
                        socketChannel.read(buffer);
                        byte[] data = buffer.array();
                        String msg = new String(data);
                        System.out.println(msg);
                    }
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }

    }
}

public class AsyncThread{
 public void doWork(){
    while(queue.Count>0){
        String log = queue.dequeue();
        IOUtil.WriteLine(log);
        IOUtil.flush();
    }
  }
}

public class AsyncThread{
 public void doWork(){
    while(queue.Count>0){
        String log = queue.dequeue();
        IOUtil.WriteLine(log);
    }
    IOUtil.flush();
  }
}

public class Test{
 public static void main(String[] args){

        LinkedList<Integer> list = new LinkedList<>();
        for (int i = 0; i < 1000; i++) {
            list.add(i);
        }

        long t1 = System.currentTimeMillis();
        list.stream().toArray(Integer[]::new);
        long t2 = System.currentTimeMillis();
        System.out.println(t2 - t1);

        long t3 = System.currentTimeMillis();
        Integer[] res = new Integer[list.size()];
        int j = 0;
        for (Integer i : list) {
            res[j++] = i;
        }
        long t4 = System.currentTimeMillis();
        System.out.println(t4 - t3);

    }
  }