IO 模型知多少 (2)

最新推荐文章于 2023-04-06 09:52:16 发布
最新推荐文章于 2023-04-06 09:52:16 发布
阅读量253 收藏
点赞数
分类专栏： 计算机原理 文章标签： I/O
原文链接：https://mp.weixin.qq.com/s/JVmk5lEfNwHhGVjVbIOYnA
版权

文章目录

1. 引言

之前的一篇介绍 IO 模型的文章 IO 模型知多少(1) 比较偏理论，很多同学反应不是很好理解。这一篇咱们换一个角度，从代码角度来分析一下。

2. Socket 编程基础

开始之前，我们先来梳理一下，需要提前了解的几个概念：

socket: 直译为“插座”，在计算机通信领域，socket 被翻译为“套接字”，它是计算机之间进行通信的一种约定或一种方式。通过 socket 这种约定，一台计算机可以接收其他计算机的数据，也可以向其他计算机发送数据。我们把插头插到插座上就能从电网获得电力供应，同样，应用程序为了与远程计算机进行数据传输，需要连接到因特网，而 socket 就是用来连接到因特网的工具。

另外还需要知道的是，socket 编程的基本流程。
在这里插入图片描述

2. 同步阻塞 IO

先回顾下概念：阻塞IO是指，应用进程中线程在发起IO调用后至内核执行IO操作返回结果之前，若发起系统调用的线程一直处于等待状态，则此次IO操作为阻塞IO。

public static void Start()
{
    //1. 创建Tcp Socket对象
    var serverSocket = new Socket(AddressFamily.InterNetwork, 
                                   SocketType.Stream, ProtocolType.Tcp);
    var ipEndpoint = new IPEndPoint(IPAddress.Loopback, 5001);
    //2. 绑定Ip端口
    serverSocket.Bind(ipEndpoint);
    //3. 开启监听，指定最大连接数
    serverSocket.Listen(10);   
    Console.WriteLine($"服务端已启动({ipEndpoint})-等待连接...");

    while(true)
    {
        //4. 等待客户端连接
        var clientSocket = serverSocket.Accept();//阻塞
        Console.WriteLine($"{clientSocket.RemoteEndPoint}-已连接");
        Span<byte> buffer = new Span<byte>(new byte[512]);
        Console.WriteLine($"{clientSocket.RemoteEndPoint}-开始接收数据...");
        int readLength = clientSocket.Receive(buffer);//阻塞
        var msg = Encoding.UTF8.GetString(buffer.ToArray(), 0, readLength);
        Console.WriteLine($"{clientSocket.RemoteEndPoint}-接收数据：{msg}");
        var sendBuffer = Encoding.UTF8.GetBytes($"received:{msg}");
        clientSocket.Send(sendBuffer);    
    }
}

在这里插入图片描述

代码很简单，直接看注释就OK了，运行结果如上图所示，但有几个问题点需要着重说明下：

  • 等待连接处 serverSocket.Accept()，线程阻塞！

  • 接收数据处 clientSocket.Receive(buffer)，线程阻塞！

会导致什么问题呢：

  • 只有一次数据读取完成后，才可以接受下一个连接请求

  • 一个连接，只能接收一次数据

3. 同步非阻塞 IO

看完，你可能会说，这两个问题很好解决啊，创建一个新线程去接收数据就是了。于是就有了下面的代码改进。

public static void Start2()    
{          
    //1. 创建Tcp Socket对象          
    var serverSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, 
                                   ProtocolType.Tcp  );         
    var ipEndpoint = new IPEndPoint(IPAddress.Loopback, 5001);          
    //2. 绑定Ip端口        
    serverSocket.Bind(ipEndpoint);          
    //3. 开启监听，指定最大连接数        
    serverSocket.Listen(10);          
    Console.WriteLine($"服务端已启动({ipEndpoint})-等待连接...");              
    while(true)          
    {              
        //4. 等待客户端连接             
        var clientSocket = serverSocket.Accept();//阻塞              
        Task.Run(() => ReceiveData(clientSocket));         
    }    
}        
 
private static void ReceiveData(Socket clientSocket)    
{          
    Console.WriteLine($"{clientSocket.RemoteEndPoint}-已连接");          
    Span<byte> buffer = new Span<byte>(new byte[512]);             
    while(true)          
    {              
        if(clientSocket.Available == 0)     
            continue  ;              
        Console.WriteLine($"{clientSocket.RemoteEndPoint}-开始接收数据...");              
        int readLength = clientSocket.Receive(buffer);  //阻塞              
        var msg = Encoding.UTF8.GetString(buffer.ToArray(), 0, readLength);              
        Console.WriteLine($"{clientSocket.RemoteEndPoint}-接收数据：{msg}");              
        var sendBuffer = Encoding.UTF8.GetBytes($"received:{msg}");            
        clientSocket.Send(sendBuffer);          
    }    
}

在这里插入图片描述
是的，多线程解决了上述的问题，但如果你观察以上动图后，你应该能发现个问题：才建立4个客户端连接，CPU的占用率就开始直线上升了。

而这个问题的本质就是，服务端的IO模型为阻塞IO模型，为了解决阻塞导致的问题，采用重复轮询，导致无效的系统调用，从而导致CPU持续走高。

4. IO 多路复用

既然知道原因所在，咱们就来予以改造。适用异步方式来处理连接、接收和发送数据。

public static class NioServer 
{  
	private static ManualResetEvent _acceptEvent = new ManualResetEvent(true);  
	private static ManualResetEvent _readEvent = new ManualResetEvent(true);  

	public static void Start ()  
	{  
		//1. 创建Tcp Socket对象  
		var serverSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, 
		                               ProtocolType.Tcp);  
		// serverSocket.Blocking = false;//设置为非阻塞  
		var ipEndpoint = new IPEndPoint(IPAddress.Loopback, 5001);  
		//2. 绑定Ip端口  
		serverSocket.Bind(ipEndpoint);  
		//3. 开启监听，指定最大连接数  
		serverSocket.Listen(10);  
		Console.WriteLine($ "服务端已启动({ipEndpoint})-等待连接...");   
	
		while(true)  
		{  
			_acceptEvent.Reset (); //重置信号量  
			serverSocket.BeginAccept(OnClientConnected, serverSocket);  
			_acceptEvent.WaitOne (); //阻塞  
		}  
	}
  
	private static void OnClientConnected(IAsyncResult ar)  
	{  
		_acceptEvent.Set (); //当有客户端连接进来后，则释放信号量  
		var serverSocket = ar.AsyncState as Socket;  
		Debug.Assert(serverSocket != null, nameof(serverSocket) + " != null");   
		
		var clientSocket = serverSocket.EndAccept(ar);  
		Console.WriteLine($ "{clientSocket.RemoteEndPoint}-已连接");  
		
		while(true)  
		{  
			_readEvent.Reset (); //重置信号量   
			var stateObj = new StateObject { ClientSocket = clientSocket };  
			clientSocket.BeginReceive(stateObj.Buffer, 0, stateObj.Buffer.Length, 
			                       SocketFlags.None, OnMessageReceived, stateObj);  
			_readEvent.WaitOne (); //阻塞等待  
		}  
	}  
	
	private static void OnMessageReceived(IAsyncResult ar)  
	{  
		var state = ar.AsyncState as StateObject;  
		Debug.Assert(state != null, nameof(state) + " != null");  
		var receiveLength = state.ClientSocket.EndReceive(ar);  
		
		if(receiveLength > 0)  
		{   
			var msg = Encoding.UTF8.GetString(state.Buffer, 0, receiveLength);   
			Console.WriteLine($ "{state.ClientSocket.RemoteEndPoint}-接收数据：{msg}");   
			
			var sendBuffer = Encoding.UTF8.GetBytes($ "received:{msg}");  
			state.ClientSocket.BeginSend(sendBuffer, 0, sendBuffer.Length, 
			                    SocketFlags.None, SendMessage, state.ClientSocket);  
		} 
	}  
	
	private static void SendMessage(IAsyncResult ar)  
	{  
		var clientSocket = ar.AsyncState as Socket;  
		Debug.Assert(clientSocket != null, nameof(clientSocket) + " != null");  
		clientSocket.EndSend(ar);  
		_readEvent.Set (); //发送完毕后，释放信号量  
	}
} 

public class StateObject
{  
	// Client socket.  
	public Socket ClientSocket = null;  
	// Size of receive buffer.  
	public const int BufferSize = 1024;  
	// Receive buffer.  
	public byte[] Buffer = new byte[BufferSize]; 
}

首先来看运行结果，从下图可以看到，除了建立连接时CPU出现抖动外，在消息接收和发送阶段，CPU占有率趋于平缓，且占用率低。
在这里插入图片描述
分析代码后我们发现：

  • CPU使用率是下来了，但代码复杂度上升了。

  • 使用异步接口处理客户端连接： BeginAccept和 EndAccept

  • 使用异步接口接收数据： BeginReceive和 EndReceive

  • 使用异步接口发送数据： BeginSend和 EndSend

  • 使用 ManualResetEvent进行线程同步，避免线程空转

那你可能好奇，以上模型是何种 IO 多路复用模型呢？
好问题，我们来一探究竟。

5. 验证 I/O 模型

要想验证应用使用的何种 IO 模型，只需要确定应用运行时发起了哪些系统调用即可。对于 Linux 系统来说，我们可以借助strace命令来跟踪指定应用发起的系统调用和信号。

5.1 验证同步阻塞I/O发起的系统调用

可以使用 VSCode Remote 连接到自己的 Linux 系统上，然后新建项目 Io.Demo，以上面非阻塞 IO 的代码进行测试，执行以下启动跟踪命令：

shengjie@ubuntu:~/coding/dotnet$ ls 
Io.Demo 
shengjie@ubuntu:~/coding/dotnet$ strace -ff -o Io.Demo /strace /io dotnet run --project Io.Demo/
Press any key to start! 
服务端已启动(127.0.0.1:5001)-等待连接... 
127.0.0.1:36876-已连接 
127.0.0.1:36876-开始接收数据... 
127.0.0.1:36876-接收数据：1

另起命令行，执行 nc localhost 5001模拟客户端连接。

shengjie@ubuntu:~/coding/dotnet/Io.Demo$ nc localhost 5001
1
received:1

使用 netstat命令查看建立的连接。

shengjie@ubuntu:/proc/3763$ netstat -natp | grep 5001 
(Not all processes could be identified, non-owned process info  
will not be shown, you would have to be root to see it all.) 
tcp     0    0  127.0.0.1 : 5001      0.0.0.0 :*            LISTEN      3763/Io.Demo      
tcp     0    0  127.0.0.1 : 36920     127.0.0.1 : 5001      ESTABLISHED 3798/nc        
tcp     0    0  127.0.0.1 : 5001      127.0.0.1 : 36920     ESTABLISHED 3763/Io.Demo

另起命令行，执行ps-h|grep dotnet抓取进程 Id。

shengjie@ubuntu:~/coding/ dotnet/Io.Demo$ ps -h | grep dotnet  
3694 pts/1   S+    0:11 strace -ff -o Io.Demo/strace/io dotnet run --project Io.Demo/ 
3696 pts/1   Sl+   0:01 dotnet run --project Io.Demo/ 
3763 pts/1   Sl+   0:00 /home/shengjie/coding/dotnet/Io.Demo/bin/Debug/netcoreapp3.0/Io.Demo  
3779 pts/2   S+    0:00 grep --color = auto dotnet 
shengjie@ubuntu:~/coding/ dotnet$ ls Io.Demo/strace/ # 查看生成的系统调用文件 
io.3696  io.3702  io.3708  io.3714  io.3720  io.3726  io.3732  io.3738  io.3744  io.3750  io.3766  io.3772  io.3782  io.3827 
io.3697  io.3703  io.3709  io.3715  io.3721  io.3727  io.3733  io.3739  io.3745  io.3751  io.3767  io.3773  io.3786  io.3828 
io.3698  io.3704  io.3710  io.3716  io.3722  io.3728  io.3734  io.3740  io.3746  io.3752  io.3768  io.3774  io.3787 
io.3699  io.3705  io.3711  io.3717  io.3723  io.3729  io.3735  io.3741  io.3747  io.3763  io.3769  io.3777  io.3797 
io.3700  io.3706  io.3712  io.3718  io.3724  io.3730  io.3736  io.3742  io.3748  io.3764  io.3770  io.3780  io.3799 
io.3701  io.3707  io.3713  io.3719  io.3725  io.3731  io.3737  io.3743  io.3749  io.3765  io.3771  io.3781  io.3800

有上可知，进程Id为3763，依次执行以下命令可以查看该进程的线程和产生的文件描述符：

shengjie@ubuntu:~/coding/dotnet/Io.Demo$ cd /proc/3763  # 进入进程目录
shengjie@ubuntu:/proc/3763$ ls 
attr    cmdline     environ io     mem     ns       pagemap   sched   smaps_rollup syscall    wchan 
autogroup  comm       exe   limits   mountinfo  numa_maps   patch_state schedstat stack     task 
auxv    coredump_filter fd    loginuid  mounts   oom_adj    personality sessionid stat     timers 
cgroup   cpuset      fdinfo  map_files mountstats oom_score   projid_map  setgroups statm     timerslack_ns 
clear_refs cwd       gid_map maps    net     oom_score_adj root     smaps   status    uid_map 
shengjie@ubuntu:/proc/3763$ ll task # 查看当前进程启动的线程 
total 0 
dr-xr-xr-x 9 shengjie shengjie 0  5 月  10  16:36  ./
dr-xr-xr-x 9 shengjie shengjie 0  5 月  10  16:34  ../
dr-xr-xr-x 7 shengjie shengjie 0  5 月  10  16:36  3763/
dr-xr-xr-x 7 shengjie shengjie 0  5 月  10  16:36  3765/
dr-xr-xr-x 7 shengjie shengjie 0  5 月  10  16:36  3766/
dr-xr-xr-x 7 shengjie shengjie 0  5 月  10  16:36  3767/
dr-xr-xr-x 7 shengjie shengjie 0  5 月  10  16:36  3768/
dr-xr-xr-x 7 shengjie shengjie 0  5 月  10  16:36  3769/
dr-xr-xr-x 7 shengjie shengjie 0  5 月  10  16:36  3770/
shengjie@ubuntu:/proc/3763$ ll fd # 查看当前进程系统调用产生的文件描述符 
total 0 
dr-x------ 2 shengjie shengjie  0  5 月  10  16:36  ./
dr-xr-xr-x 9 shengjie shengjie  0  5 月  10  16:34  ../
lrwx------ 1 shengjie shengjie 64  5 月  10  16:37  0 ->  /dev/pts/1 
lrwx------ 1 shengjie shengjie 64  5 月  10  16:37  1 ->  /dev/pts/1 
lrwx------ 1 shengjie shengjie 64  5 月  10  16:37  10 ->  'socket:[44292]' 
lr-x------ 1 shengjie shengjie 64  5 月  10  16:37  100 ->  /dev/random 
lrwx------ 1 shengjie shengjie 64  5 月  10  16:37  11 ->  'socket:[41675]' 
lr-x------ 1 shengjie shengjie 64  5 月  10  16:37  13 ->  'pipe:[45206]' 
l-wx------ 1 shengjie shengjie 64  5 月  10  16:37  14 ->  'pipe:[45206]' 
lr-x------ 1 shengjie shengjie 64  5 月  10  16:37  15 ->  /home/shengjie/coding/dotnet/Io.Demo/bin/Debug/netcoreapp3.0/Io.Demo.dll 
lr-x------ 1 shengjie shengjie 64  5 月  10  16:37  16 ->  /home/shengjie/coding/dotnet/Io.Demo/bin/Debug/netcoreapp3.0/Io.Demo.dll 
lr-x------ 1 shengjie shengjie 64  5 月  10  16:37  17 ->  /usr/share/dotnet/shared/Microsoft.NETCore.App/3.0.0/System.Runtime.dll 
lr-x------ 1 shengjie shengjie 64  5 月  10  16:37  18 ->  /usr/share/dotnet/shared/Microsoft.NETCore.App/3.0.0/System.Console.dll 
lr-x------ 1 shengjie shengjie 64  5 月  10  16:37  19 ->  /usr/share/dotnet/shared/Microsoft.NETCore.App/3.0.0/System.Threading.dll 
lrwx------ 1 shengjie shengjie 64  5 月  10  16:37  2 ->  /dev/pts/1 
lr-x------ 1 shengjie shengjie 64  5 月  10  16:37  20 ->  /usr/share/dotnet/shared/Microsoft.NETCore.App/3.0.0/System.Runtime.Extensions.dll 
lrwx------ 1 shengjie shengjie 64  5 月  10  16:37  21 ->  /dev/pts/1 
lr-x------ 1 shengjie shengjie 64  5 月  10  16:37  22 ->  /usr/share/dotnet/shared/Microsoft.NETCore.App/3.0.0/System.Text.Encoding.Extensions.dll 
lr-x------ 1 shengjie shengjie 64  5 月  10  16:37  23 ->  /dev/urandom 
lr-x------ 1 shengjie shengjie 64  5 月  10  16:37  24 ->  /usr/share/dotnet/shared/Microsoft.NETCore.App/3.0.0/System.Net.Sockets.dll 
lr-x------ 1 shengjie shengjie 64  5 月  10  16:37  25 ->  /usr/share/dotnet/shared/Microsoft.NETCore.App/3.0.0/System.Net.Primitives.dll 
lr-x------ 1 shengjie shengjie 64  5 月  10  16:37  26 ->  /usr/share/dotnet/shared/Microsoft.NETCore.App/3.0.0/Microsoft.Win32.Primitives.dll 
lr-x------ 1 shengjie shengjie 64  5 月  10  16:37  27 ->  /usr/share/dotnet/shared/Microsoft.NETCore.App/3.0.0/System.Diagnostics.Tracing.dll 
lr-x------ 1 shengjie shengjie 64  5 月  10  16:37  28 ->  /usr/share/dotnet/shared/Microsoft.NETCore.App/3.0.0/System.Threading.Tasks.dll 
lrwx------ 1 shengjie shengjie 64  5 月  10  16:37  29 ->  'socket:[43429]' 
lr-x------ 1 shengjie shengjie 64  5 月  10  16:37  3 ->  'pipe:[42148]' 
lr-x------ 1 shengjie shengjie 64  5 月  10  16:37  30 ->  /usr/share/dotnet/shared/Microsoft.NETCore.App/3.0.0/System.Threading.ThreadPool.dll 
lrwx------ 1 shengjie shengjie 64  5 月  10  16:37  31 ->  'socket:[42149]' 
lr-x------ 1 shengjie shengjie 64  5 月  10  16:37  32 ->  /usr/share/dotnet/shared/Microsoft.NETCore.App/3.0.0/System.Memory.dll 
l-wx------ 1 shengjie shengjie 64  5 月  10  16:37  4 ->  'pipe:[42148]' 
lr-x------ 1 shengjie shengjie 64  5 月  10  16:37  42 ->  /dev/urandom 
lrwx------ 1 shengjie shengjie 64  5 月  10  16:37  5 ->  /dev/pts/1 
lrwx------ 1 shengjie shengjie 64  5 月  10  16:37  6 ->  /dev/pts/1 
lrwx------ 1 shengjie shengjie 64  5 月  10  16:37  7 ->  /dev/pts/1 
lr-x------ 1 shengjie shengjie 64  5 月  10  16:37  9 ->  /usr/share/dotnet/shared/Microsoft.NETCore.App/3.0.0/System.Private.CoreLib.dll 
lr-x------ 1 shengjie shengjie 64  5 月  10  16:37  99 ->  /dev/urandom

从上面的输出来看，.NET Core控制台应用启动时启动了多个线程，并在10、11、29、31号文件描述符启动了socket监听。那哪一个文件描述符监听的是5001端口呢。

shengjie@ubuntu:~/coding/dotnet/Io.Demo$ cat/proc/net/tcp | grep 1389  # 查看5001端口号相关的tcp链接（0x1389 为5001十六进制)   
4: 0100007F:1389  00000000:0000  0A  00000000:00000000  00:00000000  00000000  1000     0  43429  1  0000000000000000  100  0  0  10  0              
12: 0100007F:9038  0100007F:1389  01  00000000:00000000  00:00000000  00000000  1000     0  44343  1  0000000000000000  20  4  30  10  - 1             
13: 0100007F:1389  0100007F:9038  01  00000000:00000000  00:00000000  00000000  1000     0  42149  1  0000000000000000  20  4  29  10  - 1

从中可以看到inode为 [43429] 的 socket 监听在 5001 端口号，所以可以找到上面的输出行lrwx------1shengjie shengjie645月1016:3729->'socket:[43429]'，进而判断监听 5001 端口号 socket 对应的文件描述符为 29。

当然，也可以从记录到 strace目录的日志文件找到线索。在文中我们已经提及，socket 服务端编程的一般流程，都要经过 socket->bind->accept->read->write流程。所以可以通过抓取关键字，查看相关系统调用。

shengjie@ubuntu:~/coding/dotnet/Io.Demo$ grep 'bind' strace/ -rn 
strace/io.3696:4570:bind(10,{sa_family = AF_UNIX,sun_path = "/tmp/dotnet-diagnostic-3696-327175-socket"}, 110) =  0 
strace/io.3763:2241:bind(11,{sa_family = AF_UNIX,sun_path = "/tmp/dotnet-diagnostic-3763-328365-socket"}, 110) =  0 
strace/io.3763:2949:bind(29,{sa_family = AF_INET,sin_port = htons(5001 ),sin_addr = inet_addr("127.0.0.1" )}, 16) =  0 
strace/io.3713:4634:bind(11,{sa_family = AF_UNIX,sun_path = "/tmp/dotnet-diagnostic-3713-327405-socket"}, 110) =  0

从上可知，在主线程也就是 io.3763线程的系统调用文件中，将29号文件描述符与监听在 127.0.0.1:5001 的 socket 进行了绑定。同时也明白了 .NET Core 自动建立的另外 2 个 socket 是与 diagnostic 相关。
接下来咱们重点看下3763号线程产生的系统调用。

shengjie@ubuntu :~ /coding/dotnet/Io.Demo$ cd strace/
shengjie@ubuntu :~ /coding/dotnet/Io.Demo/strace$ cat io.3763  # 仅截取相关片段 
socket(AF_INET,SOCK_STREAM | SOCK_CLOEXEC,IPPROTO_TCP) =  29 
setsockopt(29,SOL_SOCKET,SO_REUSEADDR, [ 1 ],  4) =  0 
bind(29, {sa_family = AF_INET,sin_port = htons(5001), sin_addr = inet_addr("127.0.0.1")}, 16) =  0 
listen(29,10)   
write(21, "\346\234\215\345\212\241\347\253\257\345\267\262\345\220\257\345\212\250(127.0.0.1:500" ...,  51) = 51 
accept4(29, {sa_family = AF_INET,sin_port = htons(36920 ), sin_addr = inet_addr("127.0.0.1")},  [16], SOCK_CLOEXEC) = 31 
write(21, "127.0.0.1:36920-\345\267\262\350\277\236\346\216\245\n", 26) =  26 
write(21, "127.0.0.1:36920-\345\274\200\345\247\213\346\216\245\346\224\266\346\225\260\346" ...,  38) =  38 
recvmsg(31, { msg_name = NULL,msg_namelen = 0,msg_iov =[{ iov_base = "1\n",iov_len = 512 }], msg_iovlen = 1,msg_controllen = 0,msg_flags = 0 },  0) =  2 
write(21, "127.0.0.1:36920-\346\216\245\346\224\266\346\225\260\346\215\256\357\274\2321" ...,  34) =  34 
sendmsg(31, { msg_name = NULL,msg_namelen = 0,msg_iov =[{ iov_base = "received:1\n",iov_len = 11 }], msg_iovlen = 1,msg_controllen = 0,msg_flags = 0 },  0) =  11 
accept4(29, 0x7fecf001c978, [ 16 ], SOCK_CLOEXEC) =  ? ERESTARTSYS(To be restarted if SA_RESTART is  set)
--- SIGWINCH { si_signo = SIGWINCH,si_code = SI_KERNEL }  ---

从中我们可以发现几个关键的系统调用：socket、bind、listen、accept4、recvmsg、sendmsg 通过命令man命令可以查看下accept4和 recvmsg系统调用的相关说明：

shengjie@ubuntu:~/coding/dotnet/Io.Demo/strace$ man accept4 
If no pending connections are present on the queue, and the socket is  not marked as nonblocking,accept () blocks the caller until a  
      connection  is  present. 
	  
shengjie@ubuntu:~/coding/dotnet/Io.Demo/strace$ man recvmsg 
If no messages are available at the socket,the receive calls wait for a message to arrive, unless the socket is nonblocking (see fcntl (2))

也就是说 accept4和 recvmsg是阻塞式系统调用。

5.2 验证I/O多路复用发起的系统调用

同样以上面I/O多路复用的代码进行验证，验证步骤类似：

shengjie@ubuntu:~/coding/dotnet$ strace -ff -o Io.Demo/strace2/io dotnet run --project Io.Demo/
Press any key to start! 
服务端已启动(127.0.0.1:5001)-等待连接... 
127.0.0.1:37098 -已连接 
127.0.0.1:37098 -接收数据：1  

127.0.0.1:37098 -接收数据：2  

shengjie@ubuntu:~/coding/dotnet/Io.Demo$ nc localhost 5001 
1
received:1 
2
received:2  

shengjie@ubuntu:/proc/2449 $ netstat -natp | grep 5001 
(Not all processes could be identified, non -owned process info  
will not be shown, you would have to be root to see it all .) 
tcp     0    0  127.0.0.1:5001      0.0.0.0 :*          LISTEN      2449/Io.Demo      
tcp     0    0  127.0.0.1:5001      127.0.0.1:56296     ESTABLISHED 2449/Io.Demo      
tcp     0    0  127.0.0.1:56296     127.0.0.1:5001      ESTABLISHED 2499/nc     
 
shengjie@ubuntu:~/coding/dotnet/Io.Demo$ ps -h | grep dotnet  
2400 pts/3   S+    0:10 strace -ff -o ./Io.Demo/strace2/io dotnet run --project Io.Demo/
2402 pts/3   Sl+   0:01 dotnet run --project Io.Demo/
2449 pts/3   Sl+   0:00 /home/shengjie/coding/dotnet/Io.Demo/bin/Debug/netcoreapp3.0/Io.Demo  
2516 pts/5   S+    0:00 grep --color = auto dotnet   


shengjie@ubuntu:~/coding/dotnet/Io.Demo$ cd/proc/2449/
shengjie@ubuntu:/proc/2449 $ ll task 
total 0 
dr-xr-xr-x 11 shengjie shengjie 0  5 月  10  22:15  ./
dr-xr-xr-x  9 shengjie shengjie 0  5 月  10  22:15  ../
dr-xr-xr-x  7 shengjie shengjie 0  5 月  10  22:15  2449/
dr-xr-xr-x  7 shengjie shengjie 0  5 月  10  22:15  2451/
dr-xr-xr-x  7 shengjie shengjie 0  5 月  10  22:15  2452/
dr-xr-xr-x  7 shengjie shengjie 0  5 月  10  22:15  2453/
dr-xr-xr-x  7 shengjie shengjie 0  5 月  10  22:15  2454/
dr-xr-xr-x  7 shengjie shengjie 0  5 月  10  22:15  2455/
dr-xr-xr-x  7 shengjie shengjie 0  5 月  10  22:15  2456/
dr-xr-xr-x  7 shengjie shengjie 0  5 月  10  22:15  2459/
dr-xr-xr-x  7 shengjie shengjie 0  5 月  10  22:15  2462/
shengjie@ubuntu:/proc/2449 $ ll fd 
total 0 
dr-x------ 2 shengjie shengjie  0  5 月  10  22:15  ./
dr-xr-xr-x 9 shengjie shengjie  0  5 月  10  22:15  ../
lrwx------ 1 shengjie shengjie 64  5 月  10  22:16  0  ->  /dev/pts/3 
lrwx------ 1 shengjie shengjie 64  5 月  10  22:16  1  ->  /dev/pts/3 
lrwx------ 1 shengjie shengjie 64  5 月  10  22:16  10  ->  'socket:[35001]' 
lr-x------ 1 shengjie shengjie 64  5 月  10  22:16  100  ->  /dev/random 
lrwx------ 1 shengjie shengjie 64  5 月  10  22:16  11  ->  'socket:[34304]' 
lr-x------ 1 shengjie shengjie 64  5 月  10  22:16  13  ->  'pipe:[31528]' 
l-wx------ 1 shengjie shengjie 64  5 月  10  22:16  14  ->  'pipe:[31528]' 
lr-x------ 1 shengjie shengjie 64  5 月  10  22:16  15  ->  /home/shengjie/coding/dotnet/Io.Demo/bin/Debug/netcoreapp3.0/Io.Demo.dll 
lr-x------ 1 shengjie shengjie 64  5 月  10  22:16  16  ->  /home/shengjie/coding/dotnet/Io.Demo/bin/Debug/netcoreapp3.0/Io.Demo.dll 
lr-x------ 1 shengjie shengjie 64  5 月  10  22:16  17  ->  /usr/share/dotnet/shared/Microsoft.NETCore.App/3.0.0/System.Runtime.dll 
lr-x------ 1 shengjie shengjie 64  5 月  10  22:16  18  ->  /usr/share/dotnet/shared/Microsoft.NETCore.App/3.0.0/System.Console.dll 
lr-x------ 1 shengjie shengjie 64  5 月  10  22:16  19  ->  /usr/share/dotnet/shared/Microsoft.NETCore.App/3.0.0/System.Threading.dll 
lrwx------ 1 shengjie shengjie 64  5 月  10  22:16  2  ->  /dev/pts/3 
lr-x------ 1 shengjie shengjie 64  5 月  10  22:16  20  ->  /usr/share/dotnet/shared/Microsoft.NETCore.App/3.0.0/System.Runtime.Extensions.dll 
lrwx------ 1 shengjie shengjie 64  5 月  10  22:16  21  ->  /dev/pts/3 
lr-x------ 1 shengjie shengjie 64  5 月  10  22:16  22  ->  /usr/share/dotnet/shared/Microsoft.NETCore.App/3.0.0/System.Text.Encoding.Extensions.dll 
lr-x------ 1 shengjie shengjie 64  5 月  10  22:16  23  ->  /dev/urandom 
lr-x------ 1 shengjie shengjie 64  5 月  10  22:16  24  ->  /usr/share/dotnet/shared/Microsoft.NETCore.App/3.0.0/System.Net.Sockets.dll 
lr-x------ 1 shengjie shengjie 64  5 月  10  22:16  25  ->  /usr/share/dotnet/shared/Microsoft.NETCore.App/3.0.0/System.Net.Primitives.dll 
lr-x------ 1 shengjie shengjie 64  5 月  10  22:16  26  ->  /usr/share/dotnet/shared/Microsoft.NETCore.App/3.0.0/Microsoft.Win32.Primitives.dll 
lr-x------ 1 shengjie shengjie 64  5 月  10  22:16  27  ->  /usr/share/dotnet/shared/Microsoft.NETCore.App/3.0.0/System.Diagnostics.Tracing.dll 
lr-x------ 1 shengjie shengjie 64  5 月  10  22:16  28  ->  /usr/share/dotnet/shared/Microsoft.NETCore.App/3.0.0/System.Threading.Tasks.dll 
lrwx------ 1 shengjie shengjie 64  5 月  10  22:16  29  ->  'socket:[31529]' 
lr-x------ 1 shengjie shengjie 64  5 月  10  22:16  3  ->  'pipe:[32055]' 
lr-x------ 1 shengjie shengjie 64  5 月  10  22:16  30  ->  /usr/share/dotnet/shared/Microsoft.NETCore.App/3.0.0/System.Threading.ThreadPool.dll 
lr-x------ 1 shengjie shengjie 64  5 月  10  22:16  31  ->  /usr/share/dotnet/shared/Microsoft.NETCore.App/3.0.0/System.Collections.Concurrent.dll 
lrwx------ 1 shengjie shengjie 64  5 月  10  22:16  32  ->  'anon_inode:[eventpoll]' 
lr-x------ 1 shengjie shengjie 64  5 月  10  22:16  33  ->  'pipe:[32059]' 
l-wx------ 1 shengjie shengjie 64  5 月  10  22:16  34  ->  'pipe:[32059]' 
lrwx------ 1 shengjie shengjie 64  5 月  10  22:16  35  ->  'socket:[35017]' 
lr-x------ 1 shengjie shengjie 64  5 月  10  22:16  36  ->  /usr/share/dotnet/shared/Microsoft.NETCore.App/3.0.0/System.Memory.dll 
lr-x------ 1 shengjie shengjie 64  5 月  10  22:16  37  ->  /dev/urandom 
lr-x------ 1 shengjie shengjie 64  5 月  10  22:16  38  ->  /usr/share/dotnet/shared/Microsoft.NETCore.App/3.0.0/System.Diagnostics.Debug.dll 
l-wx------ 1 shengjie shengjie 64  5 月  10  22:16  4  ->  'pipe:[32055]' 
lrwx------ 1 shengjie shengjie 64  5 月  10  22:16  5  ->  /dev/pts/3 
lrwx------ 1 shengjie shengjie 64  5 月  10  22:16  6  ->  /dev/pts/3 
lrwx------ 1 shengjie shengjie 64  5 月  10  22:16  7  ->  /dev/pts/3 
lr-x------ 1 shengjie shengjie 64  5 月  10  22:16  9  ->  /usr/share/dotnet/shared/Microsoft.NETCore.App/3.0.0/System.Private.CoreLib.dll 
lr-x------ 1 shengjie shengjie 64  5 月  10  22:16  99  ->  /dev/urandom 
shengjie@ubuntu:/proc/2449 $ cat/proc/net/tcp | grep 1389   
 0: 0100007F:1389  00000000:0000  0A  00000000:00000000  00:00000000  00000000  1000     0  31529  1  0000000000000000  100  0  0  10  0              
 8: 0100007F:1389  0100007F:DBE8 01  00000000:00000000  00:00000000  00000000  1000     0  35017  1  0000000000000000  20  4  29  10  -1             
12: 0100007F:DBE8 0100007F:1389  01  00000000:00000000  00:00000000  00000000  1000     0  28496  1  0000000000000000  20  4  30  10  -1

过滤 strace2 目录日志，抓取监听在 localhost:5001 socket 对应的文件描述符。

shengjie@ubuntu:~/coding/dotnet/Io.Demo$ grep 'bind' strace2/ -rn
strace2/io.2449:2243:bind(11, {sa_family=AF_UNIX, sun_path="/tmp/dotnet-diagnostic-2449-23147-socket"}, 110) = 0
strace2/io.2449:2950:bind(29, {sa_family=AF_INET, sin_port=htons(5001), sin_addr=inet_addr("127.0.0.1")}, 16) = 0
strace2/io.2365:4568:bind(10, {sa_family=AF_UNIX, sun_path="/tmp/dotnet-diagnostic-2365-19043-socket"}, 110) = 0
strace2/io.2420:4634:bind(11, {sa_family=AF_UNIX, sun_path="/tmp/dotnet-diagnostic-2420-22262-socket"}, 110) = 0
strace2/io.2402:4569:bind(10, {sa_family=AF_UNIX, sun_path="/tmp/dotnet-diagnostic-2402-22042-socket"}, 110) = 0

从中可以看出同样是29号文件描述符，相关系统调用记录中 io.2449文件中，打开文件，可以发现相关系统调用如下：

shengjie@ubuntu:~/coding/dotnet/Io.Demo$ cat strace2/io.2449 # 截取相关系统调用
socket(AF_INET, SOCK_STREAM|SOCK_CLOEXEC, IPPROTO_TCP) = 29
setsockopt(29, SOL_SOCKET, SO_REUSEADDR, [1], 4) = 0
bind(29, {sa_family=AF_INET, sin_port=htons(5001), sin_addr=inet_addr("127.0.0.1")}, 16) = 0
listen(29, 10) 
accept4(29, 0x7fa16c01b9e8, [16], SOCK_CLOEXEC) = -1 EAGAIN (Resource temporarily unavailable)
epoll_create1(EPOLL_CLOEXEC)            = 32
epoll_ctl(32, EPOLL_CTL_ADD, 29, {EPOLLIN|EPOLLOUT|EPOLLET, {u32=0, u64=0}}) = 0
accept4(29, 0x7fa16c01cd60, [16], SOCK_CLOEXEC) = -1 EAGAIN (Resource temporarily unavailable)

从中我们可以发现 accept4直接返回-1而不阻塞，监听在 127.0.0.1:5001的 socket 对应的29号文件描述符最终作为 epoll_ctl 的参数关联到 epoll_create1创建的 32 号文件描述符上。最终32号文件描述符会被 epoll_wait阻塞，以等待连接请求。我们可以抓取 epoll 相关的系统调用来验证：

shengjie@ubuntu:~/coding/dotnet/Io.Demo$ grep 'epoll' strace2/ -rn
strace2/io.2459:364:epoll_ctl(32, EPOLL_CTL_ADD, 35, {EPOLLIN|EPOLLOUT|EPOLLET, {u32=1, u64=1}}) = 0
strace2/io.2462:21:epoll_wait(32, [{EPOLLIN, {u32=0, u64=0}}], 1024, -1) = 1
strace2/io.2462:42:epoll_wait(32, [{EPOLLOUT, {u32=1, u64=1}}], 1024, -1) = 1
strace2/io.2462:43:epoll_wait(32, [{EPOLLIN|EPOLLOUT, {u32=1, u64=1}}], 1024, -1) = 1
strace2/io.2462:53:epoll_wait(32, 
strace2/io.2449:3033:epoll_create1(EPOLL_CLOEXEC)            = 32
strace2/io.2449:3035:epoll_ctl(32, EPOLL_CTL_ADD, 33, {EPOLLIN|EPOLLET, {u32=4294967295, u64=18446744073709551615}}) = 0
strace2/io.2449:3061:epoll_ctl(32, EPOLL_CTL_ADD, 29, {EPOLLIN|EPOLLOUT|EPOLLET, {u32=0, u64=0}}) = 0

因此我们可以断定同步非阻塞I/O的示例使用的时IO多路复用的epoll模型。

关于epoll相关命令，man命令可以查看下 epoll_create1、 epoll_ctl和epoll_wait系统调用的相关说明：

shengjie@ubuntu:~/coding/dotnet/Io.Demo/strace$ man epoll_create
DESCRIPTION
       epoll_create() creates a new epoll(7) instance.  Since Linux 2.6.8, the size argument is ignored, but must be
       greater than zero; see NOTES below.
	   
       epoll_create() returns a file descriptor referring to the new epoll instance.  This file descriptor  is  used
	   for  all  the subsequent calls to the epoll interface.

shengjie@ubuntu:~/coding/dotnet/Io.Demo/strace$ man epoll_ctl
DESCRIPTION
       This  system  call  performs  control  operations on the epoll(7) instance referred to by the file descriptor
       epfd.  It requests that the operation op be performed for the target file descriptor, fd.
	   
       Valid values for the op argument are:
	   
       EPOLL_CTL_ADD
				Register the target file descriptor fd on the epoll instance referred to by the file  descriptor  epfd
				and associate the event event with the internal file linked to fd.
				
	   EPOLL_CTL_MOD
                Change the event event associated with the target file descriptor fd.
				
	   EPOLL_CTL_DEL
                Remove  (deregister)  the  target file descriptor fd from the epoll instance referred to by epfd.  The
				event is ignored and can be NULL (but see BUGS below).
				
shengjie@ubuntu:~/coding/dotnet/Io.Demo/strace$ man epoll_wait
DESCRIPTION
       The  epoll_wait()  system  call  waits for events on the epoll(7) instance referred to by the file descriptor
       epfd.  The memory area pointed to by events will contain the events that will be available  for  the  caller.
       Up to maxevents are returned by epoll_wait().  The maxevents argument must be greater than zero.
	   
       The  timeout  argument  specifies  the number of milliseconds that epoll_wait() will block.  Time is measured
       against the CLOCK_MONOTONIC clock.  The call will block until either:
	   
       *  a file descriptor delivers an event;
	   
       *  the call is interrupted by a signal handler; or
	   
       *  the timeout expires.

简而言之，epoll通过创建一个新的文件描述符来替换旧的文件描述符来完成阻塞工作，当有事件或超时时通知原有文件描述符进行处理，以实现非阻塞的线程模型。

6. 总结

写完这篇文章，对I/O模型的理解有所加深，但由于对Linux系统的了解不深，所以难免有纰漏之处，大家多多指教。

同时也不仅感叹Linux的强大之处，一切皆文件的设计思想，让一切都有迹可循。现在.NET 已经完全实现跨平台了，那么Linux操作系统大家就有必要熟悉起来了。

wnvalentin
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
ario:python轻量级微框架，具有最少的文档功能
05-04
Ario-Python轻量级微型框架 基于flask的框架，可与jinja2和wrekzeug一起使用 该框架是由Wish Team为网站开发目的而开发的。 该项目由该团队维护，希望使Web开发更加轻松快捷。 动机 这个框架的主要概念就像flask。 但这就像调度程序一样工作，您可以轻松使用所需的任何库。 您不依赖于任何第3个特定的库，并且您的URL匹配中也没有任何正则表达式，这可能导致对系统的ReDos。 您可以仅使用@html或@jinja这样的修饰符来指定响应的结果，这仅有助于您专注于开发。 安装方式 使用pip安装和更新： pip install ario 用法 首先，您应该导入所需的类。 RouterController, Endpoint, Application应该被导入，并且json, html, setup_jinja, jinja, redirect, forbidd
Socket高性能IO模型浅析
03-03
（2）同步非阻塞IO（Non-blockingIO）：默认创建的socket都是阻塞的，非阻塞IO要求socket被设置为NONBLOCK。注意这里所说的NIO并非Java的NIO（NewIO）库。（3）IO多路复用（IOMultiplexing）：即经典的Reactor设计...
recv
weixin_41454036的博客
11-20 370
intrecv(SOCKETs, charFAR*buf, intlen, intflags); 不论是客户还是服务器应用程序都用recv函数从TCP连接的另一端接收数据。该函数的第一个参数指定接收端套接字描述符； 第二个参数指明一个缓冲区，该缓冲区用来存放recv函数接收到的数据； 第三个参数指明buf的长度； 第四个参数一般置0。 这里只描述同步Socket的recv函数的执行流程。当应用程序调用recv函数时， （1）recv先等待s的发送缓冲中的数据被协议传送完毕，如果协议在传送s的发送缓冲中的数据
Java网络编程：TCP，UDP，sock编程
笔记别偷看
09-18 398
七：网络 两台机器通讯就是在IP+Port上进行的 常用的通信协议 TCP/IP TCP：（Transmission Control Protocol，传输控制协议） IP：（Internet Protocol，网际协议） HTTP协议：（Hyper Text Transfer Protocol，超文本传输协议） FTP： （File Transfer Protocol，文件传输协议） SMTP： （Simple Mail Transfer Protocol，简单邮件传输协议） POP3/IMAP POP3
Linux套接字地址结构，全面了解struct sockaddr_in等套接字地址
weixin_28673511的博客
04-06 1052
Linux套接字地址完全解析，常用socket地址一篇文章解析完
Linux网络编程基础API
H_qiling的博客
08-19 424
文章目录创建socket：socket()将socket绑定到指定地址：bind()流socket主动和被动socketlisten()accept()connect()close()数据报socket交换数据报：recvfrom()和sendto()在数据包socket上使用connect() 创建socket：socket() 使用socket()系统调用创建一个socket，该系统调用返回一个在后续系统调用中引用该socket的文件描述符： #include<sys/socket.h>
IO模型的比较分析
01-07
到目前为止已经将将四个IO模型都介绍完了。 那么啊阻塞IO、非阻塞IO、同步IO和异步IO的区别在哪？ 阻塞IO和非阻塞IO的区别 调用blocking IO会一直block住对应的进程直到操作完成，而non-blocking IO在kernel还准备...
linux io 模型
01-09
linux io模型，区分阻塞非阻塞同步异步的概念，从底层理解io。
IO模型
01-20
你要叫滴滴打车，有以下几种做法： 叫车之后，就一直在路口等着，车来了自己上去——同步、阻塞 叫车之后，一边等着一边看美女，车来了自己上去——同步，非阻塞 叫车之后，光顾着看美女，司机到了之后打电话给你...
Java三种IO模型原理实例详解
08-19
主要介绍了Java三种IO模型原理实例详解,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
sockaddr_in , sockaddr , in_addr区别Socket编程函数集（非常有用）
810364804
12-07 1864
一、sockaddr和sockaddr_in在字节长度上都为16个BYTE，可以进行转换 struct sockaddr { unsigned short sa_family; //2 char sa_data[14]; //14 }; 上面是通用的socket地址，具体到Internet socket，用下面的结构，二者可以进行类型转换 struct sock...
Linux 阻塞和非阻塞 IO简介
一只青木呀
12-29 1703
Linux 阻塞和非阻塞 IO简介阻塞和非阻塞简介1、阻塞IO2、非阻塞IO 阻塞和非阻塞简介 这里的 IO 指的是 Input/Output，也就是输入/输出，是应用程序对驱动设备的输入/输出操作。当应用程序对设备驱动进行操作的时候，如果不能获取到设备资源，那么阻塞式 IO 就会将应用程序对应的线程挂起，直到设备资源可以获取为止。对于非阻塞 IO，应用程序对应的线程不会挂起，它要么一直轮询等待，直到设备资源可以使用，要么就直接放弃。 1、阻塞IO 图中应用程序调用 read 函数从设备中读取数据，当设备
CPU的工作电压（核心电压，I/O电压）
润泽海色的博客
04-25 1万+
http://hi.baidu.com/halleyzhang/blog/item/78032c125eb0f050f919b846.html CPU的核心电压是指CPU核心芯片工作时所需要的电压，CPU的I/O电压则指驱动I/O电路时所需要的工作电压。为了保证低功耗，高驱动能力。从奔腾开始，CPU就采用双电压供电，并且都采用内核低电压，I/O高电压的模式，这就保证了低功耗，高驱动能力的要求
Linux网络（二）—— 套接字 Socket
qq_41033011的博客
08-04 267
文章目录套接字简介套接字类型1. 流套接字（SOCK_STREAM）2. 数据报套接字（SOCK_DGRAM）3. 原始套接字（SOCK_RAW）重要的数据结构1. 表示套接口的数据结构 struct socket2. 描述套接口通用地址的数据结构 struct sockaddr3. 描述因特网地址结构的数据结构 struct sockaddr_in(1) AF_UNIX 域套接字格式(2) AF_INET 域套接字格式 IPv4(3) AF_INET6 域套接字格式 IPv6基本接口函数1. 创建套接字的
关于IO的一些数字
白乔专栏
08-05 1167
http://static.googleusercontent.com/external_content/untrusted_dlcp/research.google.com/en/us/people/jeff/stanford-295-talk.pdf
socket 事件驱动模型，阻塞IO非阻塞IO多路复用IO的理解 #有学习价值的
jupiter_windy的博客
07-08 178
没用过socket开发，好奇了解了一下 主要是事件驱动模型阻塞IO等看不懂，总觉得少了关键的点解释不了整个过程为什么要这样设计。 问题： 1.socket.read()会阻塞，于是用事件驱动模型，减少用户线程的消耗，那用事件驱动模型一样要消耗用户的线程去调用socket.read()为什么就不会阻塞了。？ 2.理解的socket客户端跟服务端实施通讯传输数据，像http请求一样，A-->B通过数据通道直连，如此一来始终理解不了有啥优化的空间。 后面看socket应用实例才知道，原来socke
时间序列预测（二）—— AR模型
热门推荐
kewei168的博客
05-20 1万+
时间序列预测（二）—— AR模型 文章链接 （一）数据预处理 （二）AR模型（自回归模型） （三）Xgboost模型 （四）LSTM模型 （五）Prophet模型（自回归模型） 模型原理   AR（auto-regressive）模型，亦即是自回归模型，是时间序列分析模型中最简单的两个模型其中之一（另一个是MA/Moving Average/滑动平均模型）。其原理是利用观测点前若干时刻的变量的线...
Linux IO模型
最新发布
08-13
Linux IO 模型是指 Linux 操作系统中的 IO 处理机制。它的目的是解决多个程序同时使用 IO 设备时的资源竞争问题，以及提供一种高效的 IO 处理方式。 Linux IO 模型主要分为三种：阻塞 IO、非阻塞 IO 和 IO 多路复用...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值