在介绍阻塞和非阻塞之前，我们先来了解一下多线程间一个重要的概念——临界区。

临界区——一种公有的资源或者共享数据，它可以被多个线程使用。临界区资源一次只能被一个线程使用，其它线程必须等待上一个线程
执行完成之后，才能使用。临界区资源是多线程之间重要保护对象，当临界区资源同时被多个线程访问时，容易出现错误。
代码示例：
/**
 * @author php
 * @date 2018/7/2
 */
public class CriticalRegion {
    //定义1000元
    public static Integer money = 1000;

    public static void main(String[] args) throws InterruptedException {
        //定义公共资源
        CriticalRegion criticalRegion = new CriticalRegion();
        //定义10个线程来购物
        ExecutorService executorService = Executors.newFixedThreadPool(10);
        for (int i = 0; i < 10; i++) {
            executorService.execute(() -> {
                criticalRegion.shop();
            });
        }
        Thread.sleep(1000);
        System.out.println("最终还有：" + CriticalRegion.money);
        executorService.shutdown();
    }

    //我们每次购物使用100块钱
    public  void shop() {
        money = money - 100;
        System.out.println("使用了100元，我还有：" + CriticalRegion.money);
    }
}

执行结果：从中可以看出，多个线程，同时操作临界区资源时，容易导致操作资源错误。在大部分情况下，这是一个很严重的问题。
大家可以多执行几次，看看结果有什么不同。

现在，我们修改一下shop()方法，在方法上加上sychronized。执行结果：sychronized可以让临界区资源，一次只能被一个线程访问，
从而结果正确。

临界区资源，在使用多线程时，要格外的注意，以免结果千奇百怪。

在我们了解临界区之后，再来了解阻塞和非阻塞的概念。

阻塞和非阻塞通常被用来形容多线程间的相互影响。当一个线程占用了临界区资源，那么其它需要使用这个资源的线程都必须在这个临界区上等待。等待会导致线程挂起，这样就形成了阻塞。如果占用资源的线程一直没有释放资源，那么其它的线程在这个临界区上都不能继续工作。

相反，非阻塞表明多个线程之间的执行是不会相互影响的。

通常，我们使用synchronized关键字，ReentrantLock（重入锁）时，我们得到的线程就是阻塞线程。阻塞线程在执行代码前，都会尝试得到临界区资源的锁，如果得不到，线程就会一直挂起，直到临界区资源释放。

一、socket阻塞和非阻塞有哪些不同
1. 建立连接
阻塞方式下，connect首先发送SYN请求到服务器，当客户端收到服务器返回的SYN的确认时，则connect返回，否则的话一直阻塞。
非阻塞方式，connect将启用TCP协议的三次握手，但是connect函数并不等待连接建立好才返回，而是立即返回，返回的错误码为EINPROGRESS,表示正在进行某种过程。
2. 接收连接
阻塞模式下调用accept()函数，而且没有新连接时，进程会进入睡眠状态，直到有可用的连接，才返回。
非阻塞模式下调用accept()函数立即返回，有连接返回客户端套接字描述符，没有新连接时，将返回EWOULDBLOCK错误码，表示本来应该阻塞。
3. 读操作
阻塞模式下调用read(),recv()等读套接字函数会一直阻塞住，直到有数据到来才返回。当socket缓冲区中的数据量小于期望读取的数据量时，返回实际读取的字节数。当sockt的接收缓冲区中的数据大于期望读取的字节数时，读取期望读取的字节数，返回实际读取的长度。
对于非阻塞socket而言，socket的接收缓冲区中有没有数据，read调用都会立刻返回。接收缓冲区中有数据时，与阻塞socket有数据的情况是一样的，如果接收缓冲区中没有数据，则返回错误号为EWOULDBLOCK，表示该操作本来应该阻塞的，但是由于本socket为非阻塞的socket，因此立刻返回。遇到这样的情况，可以在下次接着去尝试读取。如果返回值是其它负值，则表明读取错误。
因此，非阻塞的read调用一般这样写:
if ((nread = read(sock_fd, buffer, len)) < 0)
{
   if (errno == EWOULDBLOCK)
   {
       return 0;	//表示没有读到数据
    }
   else return -1; 	//表示读取失败
}
else return nread;	//读到数据长度

读取指定字节数据可封装readn()函数为：
ssize_t readn(int fd, void *vptr, size_t n)
{
	int32 nleft = 0;
	int32 nread = 0;
	int8 *pread_buf = NULL;

	pread_buf = (int8 *)vptr;
	nleft = n;

	while (nleft > 0)
	{
		nread = recv(fd,  (char *)pread_buf, nleft, 0);
		if (nread < 0)
		{
			if (EINTR == errno || EWOULDBLOCK == errno || EAGAIN == errno)
			{
				nread = 0;
			}
			else
			{
				return -1;
			}
		}
		else if (nread == 0)
		{
			break;
		}
		else
		{
			nleft -= nread;
			pread_buf += nread;
		}
	}
	return (ssize_t)(n - nleft);
}

4.写操作
对于阻塞Socket而言，如果发送缓冲区没有空间或者空间不足的话，write操作会直接阻塞住，如果有足够空间，则拷贝所有数据到发送缓冲区，然后返回.
对于写操作write,原理和read是类似的，非阻塞socket在发送缓冲区没有空间时会直接返回错误号EWOULDBLOCK,表示没有空间可写数据，如果错误号是别的值，则表明发送失败。如果发送缓冲区中有足够空间或者是不足以拷贝所有待发送数据的空间的话，则拷贝前面N个能够容纳的数据，返回实际拷贝的字节数。
非阻塞的write操作一般写法是:
ssize_t writen(int connfd, const void *pbuf, size_t nums)
{
	int32 nleft = 0;
	int32 nwritten = 0;
	char *pwrite_buf = NULL;

	if ((connfd <= 0) || (NULL == pbuf) || (nums < 0))
	{
		return -1;
	}

	pwrite_buf = (char *)pbuf;
	nleft = nums;

	while(nleft>0)
	{
		if (-1 == (nwritten = send(connfd, pwrite_buf, nleft, MSG_NOSIGNAL)))
		{
			if (EINTR == errno || EWOULDBLOCK == errno || EAGAIN == errno)
			{
				nwritten = 0;
			}
			else
			{
				errorf("%s,%d, Send() -1, 0x%x\n", __FILE__, __LINE__, errno);
				return -1;
			}
		}
		nleft -= nwritten;
		pwrite_buf += nwritten;
	}

	return(nums);
}

尤其注意非阻塞的socket，在建立连接时要兼容处理返回EINPROGRESS情况，在接收连接、读操作、写操作时要兼容处理返回EWOULDBLOCK错误码的情况，以上情况并非连接异常，而是网络延时或者套接字缓冲区满造成的，一般不宜做异常处理（如返回异常关闭套接字）。
简单点理解就是：

同步，就是我调用一个功能，该功能没有结束前，我死等结果。
异步，就是我调用一个功能，不需要知道该功能结果，该功能有结果后通知我（回调通知）。
阻塞，就是调用我（函数），我（函数）没有接收完数据或者没有得到结果之前，我不会返回。
非阻塞，就是调用我（函数），我（函数）立即返回，通过select通知调用者

同步IO和异步IO的区别就在于：数据拷贝的时候进程是否阻塞

阻塞IO和非阻塞IO的区别就在于：应用程序的调用是否立即返回
二、设置套接字阻塞或非阻塞
socket()函数创建的套接字默认是阻塞的，可通过如下方式将socket套接字设置为非阻塞：
方式一：fcntl函数		//文件控制函数
//设置套接字非阻塞
if (fcntl(sock_v4, F_SETFL, fcntl(sock_v4, F_GETFL) | O_NONBLOCK) == -1)
{
	printf( "set sockfd nonblock -1, errno=%d\n", errno);	//fcntl返回-1表示失败
}


方式二：ioctl       //设备控制接口函数
int b_on = 1;
ioctl (fd, FIONBIO, &b_on);

设置套接字阻塞后，也可再设置会阻塞：
方式一：fcntl函数		//文件控制函数
//设置套接字非阻塞
if (fcntl(sock_v4, F_SETFL, fcntl(sock_v4, F_GETFL) & ~O_NONBLOCK) == -1)
{
	printf( "set sockfd nonblock -1, errno=%d\n", errno);	//fcntl返回-1表示失败
}


方式二：ioctl       //设备控制接口函数
int b_on = 0;
ioctl (fd, FIONBIO, &b_on);

针对fcntl函数可做如下封装：
/** @fn	set_nonblock(int32 sock_fd, bool b_set)
 *  @brief	设置socket fd为阻塞模式或者非阻塞模式
 *  @param[in]  sock_fd 已经连接成功的连接fd。范围:大于0
 *  @param[in]  b_set 是否设置为非阻塞模式。0-否，非0-是；
 *  @param[out] 无
 *  @return 成功返回0；失败返回-1
 */
int set_nonblock(int32 sock_fd, bool b_set)
{
	int32 flags = 0;

	flags = fcntl(sock_fd, F_GETFL, 0);
	if (-1 == flags)
	{
		printf("get sockfd flag -1, errno=%d\n", errno);
		return -1;
	}

	if (b_set)
	{
		if (fcntl(sock_fd, F_SETFL, flags | O_NONBLOCK) == -1)
		{
			printf("set sockfd nonblock -1, errno=%d\n", errno);
			return -1;
		}
	}
	else
	{
		if (fcntl(sock_fd, F_SETFL, flags & (~O_NONBLOCK)) == -1)
		{
			printf("set sockfd nonblock -1, errno=%d\n", errno);
			return -1;
		}
	}

	return 0;
}

三、Linux fcntl函数介绍
功能描述：根据文件描述词来操作文件的特性。

fcntl系统调用可以用来对已打开的文件描述符进行各种控制操作以改变已打开文件的的各种属性。
头文件：
#include <unistd.h>
#include <fcntl.h>

函数原型：
int fcntl(int fd, int cmd);
int fcntl(int fd, int cmd, long arg);        
int fcntl(int fd, int cmd, struct flock *lock);

参数：
fd：文件描述词。 
cmd：操作命令。 
arg：供命令使用的参数。 
lock：同上。

描述：

fcntl()针对(文件)描述符提供控制。参数fd是被参数cmd操作(如下面的描述)的描述符。针对cmd的值，fcntl能够接受第三个参数arg。
返回值：  与命令有关。如果出错，所有命令都返回－1，如果成功则返回某个其他值。

下列三个命令有特定返回值：F_DUPFD,F_GETFD,F_GETFL以及F_GETOWN。

F_DUPFD   返回新的文件描述符

F_GETFD   返回相应标志

F_GETFL , F_GETOWN   返回一个正的进程ID或负的进程组ID
fcntl函数有5种功能：

复制一个现有的描述符(cmd=F_DUPFD).
获得／设置文件描述符标记(cmd=F_GETFD或F_SETFD).
获得／设置文件状态标记(cmd=F_GETFL或F_SETFL).
获得／设置异步I/O所有权(cmd=F_GETOWN或F_SETOWN).
获得／设置记录锁(cmd=F_GETLK , F_SETLK或F_SETLKW).

cmd 选项：

F_DUPFD：返回一个如下描述的(文件)描述符:

　　　　（1）最小的大于或等于arg的一个可用的描述符

　　　　（2）与原始操作符一样的某对象的引用

　　　　（3）如果对象是文件(file)的话,返回一个新的描述符,这个描述符与arg共享相同的偏移量(offset)

　　　　（4）相同的访问模式(读,写或读/写)

　　　　（5）相同的文件状态标志(如:两个文件描述符共享相同的状态标志)

　　　　（6）与新的文件描述符结合在一起的close-on-exec标志被设置成交叉式访问execve(2)的系统调用

F_GETFD：取得与文件描述符fd联合close-on-exec标志,类似FD_CLOEXEC.如果返回值和FD_CLOEXEC进行与运算结果是0的话,文件保持交叉式访问exec(),　　　　　　     否则如果通过exec运行的话,文件将被关闭(arg被忽略)

F_SETFD：设置close-on-exec旗标。该旗标以参数arg的FD_CLOEXEC位决定。

F_GETFL：取得fd的文件状态标志,如同下面的描述一样(arg被忽略)

F_SETFL：设置给arg描述符状态标志,可以更改的几个标志是：O_APPEND， O_NONBLOCK，O_SYNC和O_ASYNC。

F_GETOWN：取得当前正在接收SIGIO或者SIGURG信号的进程id或进程组id,进程组id返回成负值(arg被忽略)

F_SETOWN：设置将接收SIGIO和SIGURG信号的进程id或进程组id,进程组id通过提供负值的arg来说明,否则,arg将被认为是进程id
F_GETFL和F_SETFL的标志如下面的描述:

O_NONBLOCK：非阻塞I/O;如果read(2)调用没有可读取的数据,或者如果write(2)操作将阻塞,read或write调用返回-1和EAGAIN错误               　　　　   O_APPEND     ：强制每次写(write)操作都添加在文件大的末尾,相当于open(2)的O_APPEND标志

O_DIRECT      ：最小化或去掉reading和writing的缓存影响.系统将企图避免缓存你的读或写的数据.

如果不能够避免缓存,那么它将最小化已经被缓存了的数 据造成的影响.如果这个标志用的不够好,将大大的降低性能

O_ASYNC       ：当I/O可用的时候,允许SIGIO信号发送到进程组,例如:当有数据可以读的时候
注意：      在修改文件描述符标志或文件状态标志时必须谨慎，先要取得现在的标志值，然后按照希望修改它，最后设置新标志值。不能只是执行F_SETFD或F_SETFL命令，这样会关闭以前设置的标志位。
参考资料：

https://www.cnblogs.com/sunziying/p/6501045.html

文章目录
操作系统I/O：阻塞和非阻塞
调用阻塞I/O时，应用程序需等待I/O完成才返结果
调用非阻塞I/O为调用之后立即返回，
轮询技术主要有以下四种：
select
poll
epoll
kequeue
参考链接
阻塞和非阻塞系统调用
阻塞
非阻塞
参考链接

操作系统I/O：阻塞和非阻塞

OS内核对于I/O只有两方式：阻塞和非阻塞。

调用阻塞I/O时，应用程序需等待I/O完成才返结果

调用之后要等到系统内核层面完成所有操作后，调用才结束。

调用非阻塞I/O为调用之后立即返回，

返回后
CPU的时间片可用来处理其他事务，此时性能是提升的。
问题是：
由于完整的I/O没完成，立即返回的并不是业务层期望的数据，而仅仅是当前调用的状态。
为获取完整的数据，程序需要重复调用I/O操作来确认是否完成。
这种重复调用判断操作是否完成的技术叫做轮询

轮询技术主要有以下四种：

read
最原始、性能最低，
重复调用来检查I/O的状态来完成完整数据的读取。
在得到数据前，CPU一直耗在等待上。

select

改进read，通过对文件描述符上的事件状态来进行判断。
有一个较弱的限制为
它采用一个1024长的数组存储状态，
所以最多可同时检查1024个文件描述符。

poll

对select改进，采用链表方式避免数组长度的限制，其次它能避免不需要的检查。
但当文件描述符较多时，它性能还是低。

epoll

LInux下效率最高的I/O事件通知机制，在进入轮询的时候如果没有检查到I/O事件，将会进行休眠，直到事件发生将它唤醒。
它是真实利用了事件通知、执行回调的方式，而不是遍历查询，所以不浪费CPU，执行效率高。

kequeue

与epoll类似，仅FreeBSD系统下存在。

参考链接

https://blog.csdn.net/u014744118/article/details/54564224

阻塞和非阻塞系统调用
阻塞

调用结果返回之前，当前线程会被挂起。

函数只有在得到结果之后才会返回。


有人把阻塞调用和同步调用等同起来，实际上是不同的。
对同步调用来说，很多时候当前线程还是激活的，只是从逻辑上当前函数有返回而已。
例如，我们在CSocket中调用Receive函数，如果缓冲区中没有数据，这个函数就会一直等待，直到有数据才返回。
而此时，当前线程还会继续处理各种各样的消息。
如果主窗口和调用函数在同一个线程中，除非你在特殊的界面操作函数中调用，其实主界面还是应该可以刷新。
socket接收数据的另外一个函数recv则是一个阻塞调用的例子。
当socket工作在阻塞模式的时候，如果没有数据的情况下调用该函数，则当前线程就会被挂起，直到有数据为止。

非阻塞

指在不能立刻得到结果之前，该函数不阻塞当前线程，立刻返。
对象的阻塞模式和阻塞函数调用 对象是否处于阻塞模式和函数是不是阻塞调用有很强的相关性，但并不是一一对应。
阻塞对象上可以有非阻塞的调用方式，可通过API去轮询状态，在适当时调用阻塞函数，就可避免阻塞。
对非阻塞对象，调用特殊的函数也可进入阻塞调用。
函数select就是这样的一个例子。

参考链接

https://blog.csdn.net/u011244839/article/details/72823648

说明

网络编程中有两种模式：阻塞和非阻塞，默认是采用阻塞方式。

什么是阻塞和非阻塞

阻塞和非阻塞是对操作请求者在等待返回结果时的状态描述，阻塞时，在操作请求结果返回前，当前线程会被挂起，得到结果之后返回；非阻塞时，如果不能立刻得到结果，系统不会挂起当前线程，而是直接返回错误信息，因此对应非阻塞的情况，调用者需要定时轮询查看处理状态。
本质：阻塞和非阻塞本质上是本地系统对socket的不同处理方式，并不影响socket链接，也不会影响通信对方，通信双方可以自由选择阻塞还是非阻塞，例如：客户端设置成阻塞，服务器端accept 后可以设置成非阻塞都是可以的。
非阻塞是阻塞方式的改进方案，在大部分情况下可以获得更好的性能。

阻塞模式下什么情况下会阻塞

不管是TCP还是UDP，accept，connect，send，recv等操作都可以分类为发送数据和接收数据，connect和accept本质上也是发送和接收数据。
对于接收数据，当然需要对方有发送数据，自己能接收到数据，不然就会阻塞。
对于发送数据，数据的发送是由系统管理的，应用层操作只是将数据写入内存缓冲区，因此大部分情况下是不阻塞的，只有当缓冲区满，才会阻塞，（缓冲区不足以保存当前请求发送的数据，不确定是否会阻塞，还是只拷贝内存空闲大小数据）。

阻塞可能导致的问题

阻塞会导致线程挂起，如果是单线程处理，其它操作会被中断，得不到响应。
一直阻塞会导致程序无法使用，例如：如果对端未发送数据，接收端会一直阻塞在recv函数，导致接收端也无法发送数据了，除非使用多线程处理。

阻塞的改进方法
设置超时时间

socket支持设置选项：


SO_RCVTIMEO ：接收超时时间
SO_SNDTIMEO ：发送超时时间


这两个选项对send, sendmsg, recv, recvmsg, accept, connect等都有效，特别注意对accept 和connect同样有效。
这两个选项设置后，若执行超时，函数返回-1，并设置errno为EAGAIN或EWOULDBLOCK；如果是connect超时，返回-1,但errno设置为EINPROGRESS。
connect超时: 读Linux内核源码的时候偶然发现其connect的超时参数竟然和用SO_SNDTIMO操作的参数一致,如下：

File: net/ipv4/af_inet.c
 
timeo = sock_sndtimeo(sk, flags & O_NONBLOCK);
if ((1 << sk->sk_state) & (TCPF_SYN_SENT | TCPF_SYN_RECV)) {
    /* Error code is set above */
    if (!timeo || !inet_wait_for_connect(sk, timeo))
        goto out;
    err = sock_intr_errno(timeo);
    if (signal_pending(current))
        goto out;
}

非阻塞

设置超时时间虽然可以解决阻塞导致的问题，但是需要占用一定的时长，并且时间并不好设置，时间设置过小，容易导致操作中止，设置过长又没太大意义；因此系统实现了非阻塞方式，配合异步编程，效率得到了很大的提升。