高并发编程（死锁排查、阻塞、非阻塞、多路复用IO、信号驱动IO、异步I/O模型、同步、异步、JAVA NIO）

为学不间断
当如行云流水
不可以已
耐得住寂寞，经得起诱惑
自律是一个人最大的雄心

---

死锁排查

什么是死锁？

线程之间的相互等待对方锁的释放而卡住的情况称之为死锁。
比如：

有2把锁，lockA，lockB
线程A：
lockA{
//业务逻辑
lockB{
//业务逻辑
}
}
线程B：
lockB{
//业务逻辑
lockA{
//业务逻辑
}
}

线程A等待锁B的释放，线程B等待锁A的释放，双方都执行不下去就出现了死锁的情况。

如何排查死锁？

在控制台执行 jps -l，找到我们的java进程，然后执行jstack 进程号，就可以找到死锁。

如何避免死锁

锁的顺序相同或者避免相同的锁相互持有

阻塞

阻塞IO是常见的内存模型，在读写数据时客户端会发生阻塞。阻塞IO模型的工作流程为：在用户线程发出IO请求之后，内核会检查数据是否就绪，此时用户线程会一直阻塞等待内核线程的响应，在内核数据准备就绪之后，内核将数据复制到用户线程中，并返回I/O执行结果到用户线程，此时用户线程将解除阻塞状态斌开始处理数据。典型的阻塞IO的例子为：data=socket.read().如果内核数据没有准备就绪，socket就会一直在read()方法中阻塞等待，等待内核的就绪。

问题
用户线程的阻塞

非阻塞

非阻塞IO指用户线程发起一个IO操作后，无须阻塞便可以马上得到内核的返回的一个结果，如果内核返回的false，则代表内核还没有准备好，需要稍后再次发送IO请求。一旦内核准备好了，并且再次收到用户线程的亲戚，内核就会立刻将数据复制到用户线程中并复制的结果通知用户线程。

用户线程需要不间断的询问内核是否准备就绪，如果没有准备就绪内核数据可以执行其他的操作，准备就绪后就可以立即获取数据并进行相应的操作。

问题：
需要多次访问内核状态，浪费IO资源

多路复用IO

非阻塞情况下无可用数据时，应用程序每次轮询内核看数据是否准备好了也耗费CPU，能否不让它轮询，当内核缓冲区数据准备好了，以事件通知当机制告知应用进程数据准备好了呢？应用进程在没有收到数据准备好的事件通知信号时可以忙些其他的工作。此时 IO多路复用就派上用场了。

在多路复用IO模型当中，有个一个被称之为selector的线程不断的轮询socket的状态，只有socket有读写事件的时候，才会通知用户线程进行IO的读写。

因为在多路复用IO模型中只需要一个selector管理多个socket线程（不必每个socket都进行线程监听）因此大大的节约了系统的资源。

问题:
当单个socket线程处理信息大时，容易引起socket的线程的数据堆积。导致资源的堆积

信号驱动IO

在信号驱动IO模型中，在用户发起一个IO请求时，系统会为该请求对应的socket注册一个信号函数，在内核数据准备就绪时，系统会发送一个信号到用户线程。用户线程在接收到该信号，会在信号函数中调用对应的I/O读写操作完成实际的I/O操作.

问题：
用户线程接收到内核信号后，需要用户调用IO函数进行实际的IO读写操作，将数据读取到用户线程。并不是异步的，是需要一步一步同步执行。

异步I/O模型

异步线程模型就是解决信号驱动I/O模型中的同步问题。流程为以下：

用户线程会发起一个asynchronous read操作到内核，内核在接收到asynchronous read请求后会立刻返回一个状态，来说明请求是否成功发起，在此过程中用户线程不会发起任何阻塞。接着，内核会等待数据准备完成并将数据复制到用户线程中，在数据复制完成后内核会发一个消息信号到用户线程，通知用户线程asynchronous读操作已经完成。

在整个异步IO中，用户线程不需要取关心数据读取和如何工作的，只要判断信号是否完成就行，因此不会阻塞线程。

同步

同步跟异步的区别在于数据从内核空间拷贝到用户空间是否由用户线程完成，这里又分为同步阻塞跟同步非阻塞两种。

1. 同步阻塞：此时一个线程维护一个连接，该线程完成数据到读写跟处理到全部过程，数据读写时时线程是被阻塞的。
2. 同步非阻塞：非阻塞的意思是用户线程发出读请求后，读请求不会阻塞当前用户线程，不过用户线程还是要不断的去主动判断数据是否准备OK了。此时还是会阻塞等待内核复制数据到用户进程。他与同步BIO区别是使用一个连接全程等待

同步IO流程：

异步

对于异步来说，用户进行读或者写后，将立刻返回，由内核去完成数据读取以及拷贝工作，完成后通知用户，并执行回调函数（用户提供的callback），此时数据已从内核拷贝到用户空间，用户线程只需要对数据进行处理即可，不需要关注读写，用户不需要等待内核对数据的复制操作，用户在得到通知时数据已经被复制到用户空间。我们以如下的真实异步非阻塞为例。

JAVA NIO

JAVA NIO基于多路复用，主要实现有三大核心内容：Selector（选择器），Channel（通道），Buffer（缓冲区）。

Selector：用于监听多个Channel事件，打开或数据到达，一个线程可以管理多个数据Channel的事件。

Channel：双向流，可以用于读也可以用于写。NIO实现主要有：FileChannel，DatagramChannel，SocketChannel，ServerSocketChannel，分别对应的文件是：IO，UDP，TCP I/O，Socket Client和Socker Server操作。

Buffer： Buffer实际上是一个容器，其内部通过一个连续的字节数组存储I/O上的数据。在NIO中，Channel在文件、网络上对数据的读取或写入都必须经过Buffer。

JAVA NIO和传统IO的最大区别如下：

1）IO是面向流的，NIO是面向缓存区的：在面向流的操作中，数据只能在一个流中连续进行读写，数据没有缓存区，因此字节无法前后移动，而在NIO中每次都是将数据从一个Channel读取到一个Buffer中，再从Buffer中写入Channel中，因此可以进行前后移动，该功能在应用层主要用于数据的粘包，拆包等操作，在网络不可靠的环境尤为重要。

2） 传统IO是流操作是阻塞模式的，NIO是非阻塞的。在传统IO，read（）或write（）进行读写操作时，该线程将一直被阻塞，知道数据完全读取或完全写入。NIO是通过selector监听Channel事件的变化，在数据发送变化时通知该线程进行读写操作。
对于读来说：在buffer没有数据的时候，监听状态没有变化，线程可以执行其他业务操作。对于操作而言，在使用一个线程执行操作时，只需要将Channel的值写入Buffer即可，用户线程不需要等待整个数据完全写入channel就可以执行其他业务操作了。

NIO样例：

public class NIOBase {
​
    // 线程中的通道管理器
    public Selector selector;
    public String from,to;//server or client
​
    public NIOBase(String from,String to){
        this.from = from;
        this.to = to;
    }
​
    /**
     * 初始化 该线程中的通道管理器Selector
     */
    public void initSelector() throws IOException {
        this.selector = Selector.open();
    }
​
​
    /**
     * 采用轮询的方式监听selector上是否有需要处理的事件,如果有,则循环处理
     * 这里主要监听连接事件以及读事件
     */
    public void listen() throws IOException {
        //轮询访问select
        while(true){
            //当注册的事件到达时,方法返回;否则将一直阻塞
            selector.select();
            //获得selector中选中的项的迭代器,选中的项为注册的事件
            Iterator<SelectionKey> iterator = selector.selectedKeys().iterator();
            //循环处理注册事件
            /**
             * 一共有四种事件:
             * 1. 服务端接收客户端连接事件: SelectionKey.OP_ACCEPT
             * 2. 客户端连接服务端事件:    SelectionKey.OP_CONNECT
             * 3. 读事件:                SelectionKey.OP_READ
             * 4. 写事件:                SelectionKey.OP_WRITE
             */
            while(iterator.hasNext()){
                SelectionKey key = iterator.next();
                //手动删除已选的key,以防重复处理
                iterator.remove();
                //判断事件性质
                if (key.isAcceptable()){//服务端接收客户端连接事件
                    accept(key);
                }else if (key.isReadable()){//读事件
                    read(key);
                }else if (key.isConnectable()) {//客户端连接事件
                    connect(key);
                }
            }
        }
    }
​
    /**
     * 当监听到读事件后的处理函数
     * @param key 事件key,可以从key中获取channel,完成事件的处理
     */
    public void read(SelectionKey key) throws IOException {
        //step1. 得到事件发生的通道
        SocketChannel socketChannel = (SocketChannel) key.channel();
​
        //step2. 创建读取的缓冲区.将数据读取到缓冲区中
        ByteBuffer byteBuffer = ByteBuffer.allocate(10);
        int len = socketChannel.read(byteBuffer);
        String msg = "";
        byte[] arr = null;
        while (len > 0){
            byteBuffer.flip();
            arr = new byte[len];
            byteBuffer.get(arr,0,len);
            msg += new String(arr);
            byteBuffer.clear();
            len = socketChannel.read(byteBuffer);
        }
        System.out.println(from + " received data from " + to + ":" + msg);
        //step3. 再将消息回发给客户端
        if (from.equals("server"))socketChannel.write(ByteBuffer.wrap(new String(" server send some data back to client").getBytes()));
    }
​
    /**
     * 当监听到服务端接收客户端连接事件后的处理函数
     * @param key 事件key,可以从key中获取channel,完成事件的处理
     */
    public void accept(SelectionKey key) throws IOException{}
​
    /**
     * 当监听到客户端连接事件后的处理函数
     * @param key 事件key,可以从key中获取channel,完成事件的处理
     */
    public void connect(SelectionKey key) throws IOException{}
}

服务端线程类：

/**
 * 采用NIO的方式,开启服务线程
 * 该线程存在一个Selector,通道管理器,管理所有的channel
 * step1.服务初始化时,会初始化一个ServerSocektChannel,并注册到Selector中,注册"服务端接收客户端连接"事件
 *
 * step2.之后开启监听,轮询判断Selector上是否有需要处理的事件,如果有则循环处理;
 *
 * step2.1 客户端连接事件:在处理的过程中,获取与客户端连接的通道 socketChannel,并注册到Selector中,通过该通道,与客户端进行读写操作
 *
 * step2.2 读事件,利用读取缓冲区与通道结合进行
 */
public class NIOServerThread extends NIOBase implements Runnable{
​
    public NIOServerThread(String from, String to) {
        super(from, to);
    }
​
    //服务端线程中的通道管理器,使用它,可以在同一个线程中管理多个通道
​
​
​
    @Override
    public void run() {
        try {
            initSelector();//初始化通道管理器Selector
            initServer(Constant.IP,Constant.PORT);//初始化ServerSocketChannel,开启监听
            listen();//轮询处理Selector选中的事件
        } catch (IOException e) {
            e.printStackTrace();
        }
​
    }
​
​
    /**
     * 获得一个ServerSocket通道,并通过port对其进行初始化
     * @param port    监听的端口号
     */
    private void initServer(String ip,int port) throws IOException {
        //step1. 获得一个ServerSocketChannel
        ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
​
        //step2. 初始化工作
        serverSocketChannel.configureBlocking(false);//设置通道为非阻塞
        serverSocketChannel.socket().bind(new InetSocketAddress(ip,port));
​
        //step3. 将该channel注册到Selector上,并为该通道注册SelectionKey.OP_ACCEPT事件
        //这样一来,当有"服务端接收客户端连接"事件到达时,selector.select()方法会返回,否则将一直阻塞
        serverSocketChannel.register(this.selector,SelectionKey.OP_ACCEPT);
    }
​
​
    /**
     * 当监听到服务端接收客户端连接事件后的处理函数
     * @param key 事件key,可以从key中获取channel,完成事件的处理
     */
    @Override
    public void accept(SelectionKey key) throws IOException {
​
        //step1. 获取serverSocketChannel
        ServerSocketChannel serverSocketChannel = (ServerSocketChannel) key.channel();
​
        //step2. 获得和客户端连接的socketChannel
        SocketChannel socketChannel = serverSocketChannel.accept();
        socketChannel.configureBlocking(false);//设置为非阻塞
​
        //step3. 通过socketChannel给客户端发送信息
        socketChannel.write(ByteBuffer.wrap(new String("server has a connection with client").getBytes()));
​
        //step4. 注册该socketChannel
        socketChannel.register(selector,SelectionKey.OP_READ);//为了接收客户端的消息,注册读事件
    }
}

客户端线程类：

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SelectionKey;
import java.nio.channels.SocketChannel;
​
/**
 * NIO 客户端线程
 */
public class NIOClientThread extends NIOBase implements Runnable{
​
​
    public NIOClientThread(String from, String to) {
        super(from, to);
    }
​
    @Override
    public void run() {
        try {
            initSelector();//初始化通道管理器
            initClient(Constant.IP,Constant.PORT);//初始化客户端连接scoketChannel
            listen();//开始轮询处理事件
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
​
    /**
     * 获得一个SocketChannel,并对该channel做一些初始化工作,并注册到
     * @param ip
     * @param port
     */
    private void initClient(String ip,int port) throws IOException {
        //step1. 获得一个SocketChannel
        SocketChannel socketChannel = SocketChannel.open();
​
        //step2. 初始化该channel
        socketChannel.configureBlocking(false);//设置通道为非阻塞
​
​
        //step3. 客户端连接服务器,其实方法执行并没有实现连接,需要再listen()方法中调用channel.finishConnect()方法才能完成连接
        socketChannel.connect(new InetSocketAddress(ip,port));
​
        //step4. 注册该channel到selector中,并为该通道注册SelectionKey.OP_CONNECT事件和SelectionKey.OP_READ事件
        socketChannel.register(this.selector,SelectionKey.OP_CONNECT|SelectionKey.OP_READ);
    }
​
    /**
     * 当监听到客户端连接事件后的处理函数
     * @param key 事件key,可以从key中获取channel,完成事件的处理
     */
    @Override
    public void connect(SelectionKey key) throws IOException {
        super.connect(key);
        //step1. 获取事件中的channel
        SocketChannel socketChannel = (SocketChannel) key.channel();
​
        //step2. 如果正在连接,则完成连接
        if (socketChannel.isConnectionPending()){
            socketChannel.finishConnect();
        }
        socketChannel.configureBlocking(false);//将连接设置为非阻塞
        //step3. 连接后,可以给服务端发送消息
        socketChannel.write(ByteBuffer.wrap(new String("client send some data to server").getBytes()));
​
    }
}

常量类：

public class Constant {
    public static final int PORT = 8080;
    public static final String IP = "127.0.0.1";
}

运行主类：

public class NIOMain {
    public static void main(String[] args) {
​
        new Thread(new NIOServerThread("server","client")).start();
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        new Thread(new NIOClientThread("client","server")).start();
​
    }
}