UNIX Socket：不同进程之间能够直接交换数据进行进程间通信（IPC）-每日运维

UNIX socket概念

UNIX Socket（也称为本地套接字或IPC套接字）是一种在同一台计算机上进行进程间通信（IPC）的机制。它提供了一种可靠而高效的方式，使不同进程之间能够直接交换数据。UNIX Socket基于文件系统的抽象概念，使用一个特殊的文件来表示套接字。与网络套接字不同，UNIX Socket仅限于同一主机上的进程间通信，不涉及网络协议栈的使用。

UNIX socket特点

同步和异步通信

UNIX Socket允许进程进行同步或异步通信。对于同步通信，发送进程会阻塞直到接收进程接收到数据；对于异步通信，发送进程可以继续执行其他任务而不需要等待接收进程响应。

全双工通信

UNIX Socket允许进程在同一个套接字上进行双向通信，既可以发送数据也可以接收数据。

面向字节流

UNIX Socket以字节流的形式传输数据，不关心数据的消息边界。这意味着发送的数据可以分割成多个部分，也可以将多个消息组合成一个单独的数据块。

高性能

由于UNIX Socket只涉及本地通信，没有网络协议的开销，因此它通常比网络套接字更高效。

UNIX socket优势

由于UNIX Socket 使用套接字的概念，类似于网络套接字，但其使用的是文件系统路径而不是IP地址和端口号。 UNIX Socket 具有以下优点：

可靠性：UNIX Socket 提供可靠的进程间通信机制，数据传输过程中会进行错误检测和重传，确保数据的完整性和可靠性。
高效性：UNIX Socket 是基于内核的通信机制，数据传输过程中减少了不必要的数据拷贝，使得数据传输更加高效。
低延迟：由于 UNIX Socket 在内核层面实现，数据传输不需要经过网络协议栈，因此具有较低的延迟。
安全性：UNIX Socket 基于文件系统路径进行通信，只有相应权限的进程才能进行通信，增强了通信的安全性。
灵活性：UNIX Socket 可以在同一台计算机上的不同进程之间进行通信，使得进程间的交互更加灵活。
支持多种编程语言：UNIX Socket 可以在多种编程语言中使用，如C/C++、Python等，使得不同语言的进程之间可以进行通信。
跨平台兼容性：尽管名字中包含 UNIX，但 UNIX Socket 在许多操作系统上都有支持，包括 Linux、macOS 等。

UNIX Socket适用场景

UNIX Socket可以在不同编程语言中使用，并且广泛应用于各种场景，例如：

进程间通信（IPC）：不同进程之间通过UNIX Socket进行数据交换，例如父子进程、无关进程或者共享内存的进程之间。
本地服务器和客户端：UNIX Socket可用于构建本地服务器，接受来自客户端的连接请求并提供服务。
网络编程的模拟和测试：在本地开发环境中，使用UNIX Socket可以模拟网络连接，方便进行调试和测试。
守护进程和系统服务：UNIX Socket作为进程间通信的一种方式，可用于实现守护进程和系统服务之间的通信。

UNIX Socket 步骤

创建 Socket：

使用 `socket()` 函数创建一个套接字，指定协议组、类型和协议。
常见的协议族有 `AF_UNIX`（用于 UNIX 域套接字）和 `AF_INET`（用于网络套接字）。
常见的类型有 `SOCK_STREAM`（用于可靠的面向连接的通信）和 `SOCK_DGRAM`（用于无连接的通信）。

绑定 Socket 到地址：

对于 UNIX 域套接字，使用 `bind()` 函数将套接字绑定到一个文件路径。
对于网络套接字，使用 `bind()` 函数将套接字绑定到一个 IP 地址和端口号。

监听连接请求（对于面向连接型套接字）：

对于 UNIX 域套接字，使用 `listen()` 函数开始监听连接请求。
对于网络套接字，使用 `listen()` 函数并指定最大等待连接数量。

接受连接请求（对于面向连接型套接字）：

使用 `accept()` 函数接受客户端的连接请求，并创建一个新的套接字用于与客户端进行通信。

进行数据传输：

对于面向连接型套接字，使用 `send()` 和 `recv()` 函数在客户端和服务器之间进行数据传输。
对于无连接型套接字，可以使用 `sendto()` 和 `recvfrom()` 函数进行数据传输。

关闭 Socket：

使用 `close()` 函数关闭套接字，释放相关资源。

WPF 接入 UNIX Socket 开发案例

在WPF应用程序中创建UNIX Socket的服务端和客户端，可以使用System.Net.Sockets.Socket类。

服务端（Server）：

using System;
using System.Net.Sockets;
using System.Text;
using System.Threading.Tasks;
using System.Windows;

namespace UnixSocketExample
{
    public partial class MainWindow : Window
    {
        private const string SocketFilePath = "/path/to/unix/socket"; // UNIX Socket文件路径

        public MainWindow()
        {
            InitializeComponent();
        }

        private async void StartButton_Click(object sender, RoutedEventArgs e)
        {
            try
            {
                var socket = new Socket(AddressFamily.Unix, SocketType.Stream, ProtocolType.Unspecified);

                // 如果Socket文件已存在，则先删除
                if (System.IO.File.Exists(SocketFilePath))
                {
                    System.IO.File.Delete(SocketFilePath);
                }

                // 绑定并开始监听UNIX Socket
                socket.Bind(new UnixDomainSocketEndPoint(SocketFilePath));
                socket.Listen(1);

                await Task.Run(() =>
                {
                    while (true)
                    {
                        var clientSocket = socket.Accept(); // 接受客户端连接

                        byte[] buffer = Encoding.ASCII.GetBytes("Hello from server"); // 要发送的数据
                        clientSocket.Send(buffer); // 向客户端发送数据

                        clientSocket.Close(); // 关闭客户端连接
                    }
                });
            }
            catch (Exception ex)
            {
                MessageBox.Show($"Error: {ex.Message}", "Server Error", MessageBoxButton.OK, MessageBoxImage.Error);
            }
        }
    }
}

客户端（Client）：

using System;
using System.Net.Sockets;
using System.Text;
using System.Windows;

namespace UnixSocketExample
{
    public partial class MainWindow : Window
    {
        private const string SocketFilePath = "/path/to/unix/socket"; // UNIX Socket文件路径

        public MainWindow()
        {
            InitializeComponent();
        }

        private void ConnectButton_Click(object sender, RoutedEventArgs e)
        {
            try
            {
                var socket = new Socket(AddressFamily.Unix, SocketType.Stream, ProtocolType.Unspecified);

                socket.Connect(new UnixDomainSocketEndPoint(SocketFilePath)); // 连接到服务端

                byte[] buffer = new byte[1024];
                int bytesRead = socket.Receive(buffer); // 接收数据
                string receivedData = Encoding.ASCII.GetString(buffer, 0, bytesRead);

                ReceiveTextBox.Text = receivedData; // 显示接收到的数据

                socket.Close(); // 关闭客户端连接
            }
            catch (Exception ex)
            {
                MessageBox.Show($"Error: {ex.Message}", "Connection Error", MessageBoxButton.OK, MessageBoxImage.Error);
            }
        }
    }
}

在这个例子中，主窗口分别包含一个“Start”按钮（服务端）和一个“Connect”按钮（客户端），以及一个用于展示接收到的数据的文本框。服务端代码负责创建UNIX Socket并绑定到指定的文件路径，然后开始监听连接请求。当客户端连接时，服务端向客户端发送一条消息，并关闭连接。客户端代码负责连接到服务端的UNIX Socket，接收服务端发送的数据，并将接收到的数据显示在文本框中。

UNIX Socket进程间通信之序列化

使用UNIX Socket进行进程间通信时，序列化是一个重要的问题。由于UNIX Socket只能传输字节流，而对象是无法直接传输的，因此需要将对象进行序列化成字节流再传输，接收方接收到字节流后再进行反序列化还原为对象。常用的解决方案有：

选择合适的序列化方式：在.NET框架中有多种序列化方式可供选择，例如XML序列化、JSON序列化和二进制序列化等。您可以根据实际需求选择适合的序列化方式。注意，需要确保序列化方式在进程间通信中是兼容的。
定义数据传输的数据结构：使用类或结构体来定义数据传输的格式和结构。这些类或结构体需要进行序列化和反序列化。
序列化和反序列化：在发送方，将要传输的对象进行序列化成字节流，并通过UNIX Socket发送；在接收方，接收到字节流后进行反序列化还原为对象。

案例演示如何使用BinaryFormatter进行对象的二进制序列化和反序列化：

using System;
using System.IO;
using System.Net.Sockets;
using System.Runtime.Serialization.Formatters.Binary;

// 发送方
var socket = new Socket(AddressFamily.Unix, SocketType.Stream, ProtocolType.Unspecified);
socket.Connect(new UnixDomainSocketEndPoint("/path/to/unix/socket"));

var data = new MyData { Name = "Alice", Age = 30 }; // 要传输的对象

var formatter = new BinaryFormatter();
using (var stream = new MemoryStream())
{
    formatter.Serialize(stream, data); // 对象序列化到内存流中
    var buffer = stream.ToArray(); // 获取字节流数据
    socket.Send(buffer); // 发送字节流
}

socket.Close();

// 接收方
var listener = new Socket(AddressFamily.Unix, SocketType.Stream, ProtocolType.Unspecified);
listener.Bind(new UnixDomainSocketEndPoint("/path/to/unix/socket"));
listener.Listen(1);

var clientSocket = listener.Accept();
var receivedBuffer = new byte[1024];
var bytesRead = clientSocket.Receive(receivedBuffer); // 接收字节流

using (var stream = new MemoryStream(receivedBuffer, 0, bytesRead))
{
    var receivedData = formatter.Deserialize(stream) as MyData; // 字节流反序列化为对象
    Console.WriteLine($"Received: {receivedData.Name}, {receivedData.Age}");
}

clientSocket.Close();
listener.Close();

// 要传输的数据结构
[Serializable]
public class MyData
{
    public string Name { get; set; }
    public int Age { get; set; }
}

在这个示例中，发送方将MyData对象进行二进制序列化，并通过UNIX Socket发送字节流。接收方接收到字节流后，使用相同的二进制序列化方式进行反序列化还原为MyData对象。要注意的是，由于不同平台和不同开发环境的序列化机制可能存在差异，因此在进行跨平台的进程间通信时，需要确保序列化方式的兼容性。另外，如果要序列化的对象是自定义类或结构体，需要将其标记为可序列化（使用[Serializable]特性）才能进行序列化和反序列化操作。

UNIX Socket：不同进程之间能够直接交换数据进行进程间通信（IPC）

UNIX socket概念

UNIX socket特点

同步和异步通信

全双工通信

面向字节流

高性能

UNIX socket优势

UNIX Socket适用场景

UNIX Socket 步骤

WPF 接入 UNIX Socket 开发案例

UNIX Socket进程间通信之序列化

相关文章

发布评论取消回复

向阳逐梦

【Rocky 9】Step by Step 从 CentOS 7.9 升级到 Rocky Linux 9.2

oracle查询V$ARCHIVE_GAP慢的问题解决–转瞻Derek

Oracle 11g RAC集群日常运维命令总结

UNIX Socket：不同进程之间能够直接交换数据进行进程间通信（IPC）

UNIX socket概念

UNIX socket特点

同步和异步通信

全双工通信

面向字节流

高性能

UNIX socket优势

UNIX Socket适用场景

UNIX Socket 步骤

WPF 接入 UNIX Socket 开发案例

UNIX Socket进程间通信之序列化

相关文章

发布评论 取消回复

向阳逐梦

【Rocky 9】Step by Step 从 CentOS 7.9 升级到 Rocky Linux 9.2

oracle查询V$ARCHIVE_GAP慢的问题解决–转瞻Derek

Oracle 11g RAC集群日常运维命令总结

发布评论取消回复