采用管道进行通讯的例子

最新推荐文章于 2024-11-02 23:13:57 发布
最新推荐文章于 2024-11-02 23:13:57 发布
阅读量88 收藏
点赞数
CC 4.0 BY-SA版权
文章标签： runtime
原文链接：https://yq.aliyun.com/articles/576311
本文介绍了一种使用管道技术进行进程间通讯的方法，并提供了一个在1.8G双核计算机上每秒能发送180M数据的示例。文中详细展示了服务器端和客户端的管道类实现，并附带了必要的API封装。

作者：肖波
    用Remoting做进程间通讯，效率较低，于是做了一个采用管道技术进行进程间通讯的例子，在1.8G 双核计算机上每秒钟可以发送180M数据。下面给出源码
   
    Server端的管道类

using System;
using System.Collections.Generic;
using System.Text;
using System.Threading;
using Pipe.Win32;

namespace Pipe.Server
{
    public delegate void ReceiveMessageFunc(System.IO.MemoryStream m);
    public delegate void ReceiveMessageErrorFunc(Exception e);

    public class PipeServer : IDisposable
    {
        enum State
        {
            Idle = 0,
            Begining = 1,
            Reading = 2,
        }

        String m_PipeName;
        uint m_Handle;
        uint m_BufferSize;
        State m_State = State.Idle;

        const ulong SYNC_HEAD = 0xf8c7a1ca13db307e;
        const uint NMPWAIT_USE_DEFAULT_WAIT = 0x00000000;
        const int DEFAULT_BUFFER_SIZE = 1024;

        ReceiveMessageFunc m_ReceiveMessage;
        ReceiveMessageErrorFunc m_ReceiveMessageError;

        public ReceiveMessageFunc OnReceiveMessage
        {
            get
            {
                return m_ReceiveMessage;
            }

            set
            {
                m_ReceiveMessage = value;
            }
        }

        public ReceiveMessageErrorFunc OnReceiveMessageError
        {
            get
            {
                return m_ReceiveMessageError;
            }

            set
            {
                m_ReceiveMessageError = value;
            }
        }

        public String PipeName
        {
            get
            {
                return m_PipeName;
            }
        }

        public uint BufferSize
        {
            get
            {
                return m_BufferSize;
            }
        }

        public String PipeUri
        {
            get
            {
                return @"\\.\pipe\" + m_PipeName;
            }
        }

        private bool IsSyncHead(byte[] buf, uint len, out int msgLen)
        {
            msgLen = 0;

            if (len != 12)
            {
                return false;
            }

            if (SYNC_HEAD != BitConverter.ToUInt64(buf, 0))
            {
                return false;
            }

            msgLen = BitConverter.ToInt32(buf, sizeof(ulong));

            if (msgLen < 0)
            {
                return false;
            }

            return true;
        }

        private void ProcessMessage(System.IO.MemoryStream m)
        {
            if (OnReceiveMessage != null)
            {
                m.Position = 0;
                OnReceiveMessage(m);
            }
        }

        private void ThreadProc()
        {
        }

        public PipeServer(String pipeName)
        {
            m_PipeName = pipeName;
            m_BufferSize = DEFAULT_BUFFER_SIZE;
        }

        public PipeServer(String pipeName, uint bufferSize)
        {
            m_PipeName = pipeName;
            m_BufferSize = bufferSize;
        }


        public void Listen()
        {
            while (true)
            {
                try
                {

                    m_Handle = NTKernel.CreateNamedPipe(PipeUri, (uint)FileAccess.PIPE_ACCESS_DUPLEX,
                        (uint)PipeMode.PIPE_READMODE_MESSAGE | (uint)PipeMode.PIPE_TYPE_MESSAGE | (uint)PipeMode.PIPE_WAIT,
                        NTKernel.PIPE_UNLIMITED_INSTANCES, m_BufferSize, m_BufferSize, NMPWAIT_USE_DEFAULT_WAIT, new SecurityAttributes());

                    if (m_Handle == NTKernel.INVAILD_HANDLE)
                    {
                        throw new Exception(String.Format("CreateNamedPipe fail, err={0}", NTKernel.GetLastError()));
                    }

                    if (!NTKernel.ConnectNamedPipe(m_Handle, IntPtr.Zero))
                    {
                        uint err = NTKernel.GetLastError();
                        NTKernel.CloseHandle(m_Handle);
                        throw new Exception(String.Format("ConnectNamedPipe fail, err={0}", err));
                    }

                    byte[] buf = new byte[m_BufferSize];

                    uint relSize = 0;
                    int msgLen = 0;
                    int offset = 0;
                    System.IO.MemoryStream m = new System.IO.MemoryStream();

                    while (NTKernel.ReadFile(m_Handle, buf, m_BufferSize, out relSize, IntPtr.Zero))
                    {
                        switch (m_State)
                        {
                            case State.Idle:
                                if (IsSyncHead(buf, relSize, out msgLen))
                                {
                                    m_State = State.Begining;
                                }

                                break;
                            case State.Begining:
                                offset = 0;
                                m = new System.IO.MemoryStream();
                                m.Write(buf, 0, (int)relSize);
                                offset += (int)relSize;
                                if (offset >= msgLen)
                                {
                                    m_State = State.Idle;

                                    if (offset == msgLen)
                                    {
                                        ProcessMessage(m);
                                    }
                                    else
                                    {
                                        if (OnReceiveMessageError != null)
                                        {
                                            OnReceiveMessageError(new Exception("Message overflow!"));
                                        }
                                    }

                                }
                                else
                                {
                                    m_State = State.Reading;
                                }

                                break;
                            case State.Reading:
                                m.Write(buf, 0, (int)relSize);
                                offset += (int)relSize;
                                if (offset >= msgLen)
                                {
                                    m_State = State.Idle;

                                    if (offset == msgLen)
                                    {
                                        ProcessMessage(m);
                                    }
                                    else
                                    {
                                        if (OnReceiveMessageError != null)
                                        {
                                            OnReceiveMessageError(new Exception("Message overflow!"));
                                        }
                                    }
                                }

                                break;

                        }


                    }


                    NTKernel.DisconnectNamedPipe(m_Handle);
                    NTKernel.CloseHandle(m_Handle);
                    System.Threading.Thread.Sleep(10);
                }
                catch (Exception e)
                {
                    if (OnReceiveMessageError != null)
                    {
                        OnReceiveMessageError(e);
                    }
                }
            }
        }

        public void Dispose()
        {
            lock (this)
            {
                if (m_Handle != NTKernel.INVAILD_HANDLE)
                {
                    NTKernel.CloseHandle(m_Handle);
                    m_Handle = NTKernel.INVAILD_HANDLE;
                }
            }
        }

        ~PipeServer()
        {
            Dispose();
        }
    }

}


Client 端的管道类

using System;
using System.Collections.Generic;
using System.Text;
using System.Diagnostics;
using Pipe.Win32;

namespace Pipe.Client
{
    public class PipeClient : IDisposable
    {
        String m_PipeName;
        String m_ComputerName;
        uint m_Handle;
        uint m_BufferSize;
        const ulong SYNC_HEAD = 0xf8c7a1ca13db307e;
        byte[] m_SendBuf;

        Propertys

        private void Connect()
        {
            int file_not_find_times = 0;

            while (true)
            {
                m_Handle = NTKernel.CreateFile(PipeUri, (uint)FileAccess.GENERIC_READ | (uint)FileAccess.GENERIC_WRITE,
                    0, new SecurityAttributes(), (uint)CreateMode.OPEN_EXISTING, 0, 0);

                if (m_Handle == NTKernel.INVAILD_HANDLE)
                {
                    uint err = NTKernel.GetLastError();

                    if (err == NTKernel.ERROR_FILE_NOT_FOUND)
                    {
                        if (file_not_find_times++ < 2000)
                        {
                            System.Threading.Thread.Sleep(20);
                            continue;
                        }
                    }

                    if (err == NTKernel.ERROR_PIPE_BUSY)
                    {
                        NTKernel.WaitNamedPipeA(PipeUri, 20);
                        continue;
                    }
                    else
                    {
                        throw new Exception(String.Format("Create File for pipe fail, err={0}", NTKernel.GetLastError()));
                    }
                }

                break;
            }

        }

        private void WriteBuf(byte[] buf)
        {
            uint relSize;

            if (!NTKernel.WriteFile(m_Handle, buf, (uint)buf.Length, out relSize, IntPtr.Zero))
            {
                throw new Exception(String.Format("Send message to pipe fail, err={0}", NTKernel.GetLastError()));
            }
        }

        public void Close()
        {
            lock (this)
            {
                if (m_Handle != NTKernel.INVAILD_HANDLE)
                {
                    bool ret = NTKernel.CloseHandle(m_Handle);
                    m_Handle = NTKernel.INVAILD_HANDLE;
                }
            }
        }

        public PipeClient(String pipeName, uint bufferSize)
        {
            m_PipeName = pipeName;
            m_BufferSize = bufferSize;
            m_Handle = NTKernel.INVAILD_HANDLE;
            m_SendBuf = new byte[bufferSize];
        }

        public void Dispose()
        {
            Close();
        }

        public void Send(byte[] buf)
        {
            if (m_Handle == NTKernel.INVAILD_HANDLE)
            {
                Connect();
            }

            //Build Message Head
            byte[] syncHead = BitConverter.GetBytes(SYNC_HEAD);
            byte[] length = BitConverter.GetBytes(buf.Length);
            byte[] lengthBuf = new byte[syncHead.Length + length.Length];
            
            syncHead.CopyTo(lengthBuf, 0);
            
            for (int i = syncHead.Length; i < lengthBuf.Length; i++)
            {
                lengthBuf[i] = length[i - syncHead.Length];
            }

            WriteBuf(lengthBuf);

            //write content
            if (buf.Length < m_BufferSize)
            {
                WriteBuf(buf);
            }
            else
            {
                //the length of buf lardge than m_BufferSize

                int offset = 0;

                int len = Math.Min((int)m_BufferSize, buf.Length - offset);

                byte[] sendbuf;

                while (len > 0)
                {
                    if (len == m_BufferSize)
                    {
                        sendbuf = m_SendBuf;
                    }
                    else
                    {
                        sendbuf = new byte[len];
                    }

                    System.IO.MemoryStream m = new System.IO.MemoryStream(sendbuf);
                    m.Write(buf, offset, len);
                    m.Close();
                    offset += len;
                    len = Math.Min((int)m_BufferSize, buf.Length - offset);
                    WriteBuf(sendbuf);
                }
            }
        }

        ~PipeClient()
        {
            Dispose();
        }
    }
}


NTKernel.cs 
这个程序文件Client 和 Server 都要，封装了相应的API函数

using System;
using System.Collections.Generic;
using System.Text;
using System.Runtime.InteropServices;


namespace Pipe.Win32
{

    Data Structures

    public class NTKernel
    {
        public const uint PIPE_UNLIMITED_INSTANCES = 255;
        public const uint INVAILD_HANDLE = 0xFFFFFFFF;
        public const uint ERROR_FILE_NOT_FOUND = 2;
        public const uint ERROR_PIPE_BUSY = 231;

        internal const uint INFINITE = 0xFFFFFFFF;


        [DllImport("kernel32", EntryPoint = "GetLastError", SetLastError = true, CharSet = CharSet.Unicode)]
        public static extern uint GetLastError();

        [DllImport("kernel32.dll", SetLastError = true)]
        public static extern uint CreateNamedPipe(string lpName, uint dwOpenMode,
           uint dwPipeMode, uint nMaxInstances, uint nOutBufferSize, uint nInBufferSize,
           uint nDefaultTimeOut, SecurityAttributes lpSecurityAttributes);

        [DllImport("kernel32.dll")]
        public static extern bool ConnectNamedPipe(uint hNamedPipe,
           IntPtr lpOverlapped);

        [DllImport("kernel32.dll")]
        public static extern bool DisconnectNamedPipe(uint hNamedPipe);
        
        [DllImport("kernel32.dll", SetLastError=true)] 
        public static extern int WaitNamedPipeA (string lpNamedPipeName, int nTimeOut);

        [DllImport("kernel32.dll")]
        public static extern bool ReadFile(uint hFile, byte[] lpBuffer,
           uint nNumberOfBytesToRead, out uint lpNumberOfBytesRead, IntPtr lpOverlapped);

        [DllImport("kernel32.dll")]
        public static extern bool WriteFile(uint hFile, byte[] lpBuffer,
           uint nNumberOfBytesToWrite, out uint lpNumberOfBytesWritten,
           IntPtr lpOverlapped);

        [DllImport("kernel32.dll", SetLastError = true)]
        public static extern bool CloseHandle(uint hHandle);

        [DllImport("kernel32.dll", CharSet = CharSet.Auto, CallingConvention = CallingConvention.StdCall, SetLastError = true)]
        public static extern uint CreateFile(
              string lpFileName,
              uint dwDesiredAccess,
              uint dwShareMode,
              SecurityAttributes lpSecurityAttributes,
              uint dwCreationDisposition,
              uint dwFlagsAndAttributes,
              int hTemplateFile
              );

        Mutex


        Semaphore

        Event

    }

    class Mutex : IDisposable
    {
        IntPtr m_Handle;

        public Mutex(SecurityAttributes lpEventAttributes, bool bInitialOwner, string lpName)
        {
            m_Handle = NTKernel.CreateMutex(lpEventAttributes, bInitialOwner, lpName);

            if (m_Handle == IntPtr.Zero)
            {
                uint err = NTKernel.GetLastError();
                throw new Exception(String.Format("Create Event fail, error={0}",
                    err));
            }
        }

        public Mutex(bool bInitialOwner, string lpName)
        {
            m_Handle = NTKernel.CreateMutex(null, bInitialOwner, lpName);

            if (m_Handle == IntPtr.Zero)
            {
                uint err = NTKernel.GetLastError();
                throw new Exception(String.Format("Create Event fail, error={0}",
                    err));
            }
        }

        public bool WaitOne(uint dwMilliseconds)
        {
            WaitForState waitForState = (WaitForState)NTKernel.WaitForSingleObject((uint)m_Handle, dwMilliseconds);

            if (waitForState == WaitForState.WAIT_OBJECT_0)
            {
                return true;
            }
            else if (waitForState == WaitForState.WAIT_TIMEOUT)
            {
                return false;
            }
            else
            {
                throw new System.Threading.AbandonedMutexException();
            }


        }

        public bool WaitOne()
        {
            return WaitOne(NTKernel.INFINITE);
        }

        public void ReleaseMutex()
        {
            NTKernel.ReleaseMutex(m_Handle);
        }

        public void Close()
        {
            lock (this)
            {
                if (m_Handle != IntPtr.Zero)
                {
                    if (NTKernel.CloseHandle((uint)m_Handle))
                    {
                        m_Handle = IntPtr.Zero;
                    }
                }
            }
        }

        ~Mutex()
        {
            Dispose();
        }

        IDisposable Members

    }

    public class Event : IDisposable
    {
        IntPtr m_Handle;

        public Event()
        {
        }

        public Event(SecurityAttributes lpEventAttributes, bool bManualReset, bool bInitialState, string lpName)
        {
            m_Handle = NTKernel.CreateEvent(lpEventAttributes, bManualReset, bInitialState, lpName);

            if (m_Handle == IntPtr.Zero)
            {
                uint err = NTKernel.GetLastError();
                throw new Exception(String.Format("Create Event fail, error={0}",
                    err));
            }
        }

        public bool Open(EventAccess dwDesiredAccess, bool bInheritHandle, string lpName)
        {
            m_Handle = NTKernel.OpenEvent((uint)dwDesiredAccess, bInheritHandle, lpName);

            if (m_Handle == IntPtr.Zero)
            {
                return false;
            }
            else
            {
                return true;
            }
        }

        public WaitForState WaitFor(uint dwMilliseconds)
        {
            return (WaitForState)NTKernel.WaitForSingleObject((uint)m_Handle, dwMilliseconds);
        }

        public WaitForState WaitFor()
        {
            return WaitFor(NTKernel.INFINITE);
        }

        public void SetEvent()
        {
            NTKernel.SetEvent(m_Handle);
        }

        public void Release()
        {
            NTKernel.ResetEvent(m_Handle);
        }

        public void Close()
        {
            lock (this)
            {
                if (m_Handle != IntPtr.Zero)
                {
                    if (NTKernel.CloseHandle((uint)m_Handle))
                    {
                        m_Handle = IntPtr.Zero;
                    }
                }
            }
        }

        ~Event()
        {
            Dispose();
        }

        IDisposable Members
    }
}


客户端调用

            byte[] buf = new byte[10240];
            Pipe.Client.PipeClient client = new Pipe.Client.PipeClient("test", 102400);

            for (int i = 0; i < 10000; i++)
             {
                try
                {
                    client.Send(buf);
                }
                catch (Exception e)
                {
                    Console.WriteLine(e.Message);
                }
                finally
                {
                }
            }


服务器调用

        static bool begin = true;
        static System.Diagnostics.Stopwatch watch = new System.Diagnostics.Stopwatch();
        static int count = 0;
        static object lockObj = new object();

        static void ReceiveMessage(System.IO.MemoryStream m)
         {
            //Console.WriteLine(msg.Event);

            lock (lockObj)
            {

                if (begin)
                {
                    watch.Start();
                    begin = false;
                }

                count++;

                if (count == 10000)
                {
                    watch.Stop();
                    float len = m.Length;

                    Console.WriteLine(String.Format("{0} MB", (len * 10000 * 1000 / watch.ElapsedMilliseconds) / (1024 * 1024)));
                    Console.WriteLine(String.Format("{0} ms", watch.ElapsedMilliseconds));
               
                }
            }
        }

        static void ReceiveMessageError(Exception e)
        {
            Console.WriteLine(e.Message);
        }

        static void Main(string[] args)
        {
            Pipe.Server.PipeServer server = new Pipe.Server.PipeServer("Test", 102400);
            server.OnReceiveMessage = ReceiveMessage;
            server.OnReceiveMessageError = ReceiveMessageError;
            server.Listen();


        }


源码下载位置

使用C++将守护进程和主进程设计成windows服务，并使用命名管道进行通讯
qq_28107929的博客
12-04 994
由于项目需求，需要设计一个守护进程来守护主进程。 守护进程的实现方式： 1. 设计成进程 2. 设计成服务 因为希望主服务随windows开机启动即启动，所以将守护进程和主进程设计成windows服务。 守护服务于主服务间的通讯方式： 1. socket 2. 管道（分为匿名管道和命名管道） 3. WM_COPYDATA消息 　　WM_COPYDATA是一种非常强大却鲜为人知的消息。当一个应用向另...
dotnet 替换 ASP.NET Core 的底层通讯为命名管道的 IPC 库
dotNET跨平台
02-11 461
这是一个用于本机多进程进行 IPC 通讯的库，此库的顶层 API 是采用 ASP.NET Core 的 MVC 框架，其底层通讯不是传统的走网络的方式，而是通过 dotnetCampus....
管道通信实例（阻塞管道）
05-17
Windows下实现的C++管道通信，PipeTest是服务器端，Test里是客户端，从服务器端读入一个文件（test.txt），客户端将文件内容打印出来。
命名管道通信完整实例
12-09
MSDN上管道实现进程间通信的例子太敷衍了，由于项目中以前用的进程通信模块用的第三方在某些电脑上出现了未知bug，最后自己重新写了个进程间通信的模块在项目中使用。本例子将管道通信逻辑在PipeChanel类里实现，方便使用。在VS2010下调试运行通过。有bug欢迎评论指出。
pipe函数管道通信小例子
11-09
一些小程序 大家支持一下 下载后评论 既不浪费 又是支持~~~
VC与Flash通讯例子
07-29
标题中的“VC与Flash通讯例子”意味着我们将讨论如何在VC编写的程序中嵌入Flash内容，并实现两者之间的数据交换。这种交互通常用于提升用户界面的动态性或实现复杂的业务逻辑。 1. **ActiveX技术**：在早期，VC通过...
C#与C++交互开发系列（十八）：跨进程通信之命名管道（Named Pipes）
最新发布
dotnet研习社
11-02 1994
在 C# 和 C++ 应用程序之间进行数据交换时，命名管道（Named Pipes）是一种简单高效的进程间通信（IPC）方式。命名管道提供了可靠的双向通信通道，适合用于同一台机器上的跨进程通信。本文将深入介绍如何在 C# 和 C++ 程序中使用命名管道进行数据传输，包括详细的示例代码，帮助读者在实践中使用并调试这一技术。命名管道是 Windows 提供的一种 IPC 机制，支持双向数据流。与匿名管道不同，命名管道可以跨进程、跨用户访问。
【雕爷学编程】Arduino智慧交通之使用RF24库进行无线通信设置写入管道
雕爷学编程
04-30 1177
总结而言，Arduino智慧交通具有实时数据采集和处理、智能交通控制和优化、交通事故预警和安全管理、用户信息服务和智能导航等主要特点。通过部署传感器和摄像头，实时监测车辆流量、限速情况等，并提供交通事故预警和安全管理服务，提高高速公路的安全性和通行效率。2、智能交通控制和优化功能：系统可以根据采集到的数据，实现智能的交通控制和优化。5、创新：Arduino可以让你用电子的方式来表达你的创意和想象，你可以用Arduino来制作各种有趣和有用的项目，如机器人、智能家居、艺术装置等。
C# 命名管道 异步通信的例子
07-05
网上很多关于命名管道通信的代码都是同步通信的，这个例子是使用命名管道异步通信的。实现了两个Application之间利用命名管道异步通信。想了解C# 命名管道异步通信的很值得一看。
管道通信示例
wozaidengnihaojiu的博客
07-01 238
进程间通信--管道示例
一个LINUX下管道通信的例子
buaa_shang的专栏
08-30 2205
client端------现在有问题........... #include #include #include #include #include #include #include #include #include #define FIFO_HANDLE_NAME "/tmp/fifo_handle " #define FIFO_CLIENT_NAME "/tmp/
通过命令管道，在进程之间进行通信的简单例子
weixin_34204057的博客
10-27 199
write_to_named_pipe.py import os if __name__ == "__main__": named_pipe = "my_pipe" if not os.path.exists(named_pipe): os.mkfifo(named_pipe) def write_mes...
命名管道的通信举例
qq_38211852的博客
05-26 578
fifo_read.c#include &lt;stdio.h&gt;#include &lt;stdlib.h&gt;#include &lt;fcntl.h&gt;#include &lt;string.h&gt;#include &lt;unistd.h&gt;int main(int argc,char **argv){    if(argc&lt;2)    {       printf...
Linux进程间通信 之 管道通信 及 代码示例 [Linux高并发服务器开发]
Appleeatingboy的博客
01-09 4036
进程是一个独立的资源分配单元，不同进程（通常指用户进程）之间的资源是独立的，没有关联，不能在一个进程中直接访问另一个进程的资源。 但是进程不是孤立的，不同的进程之间需要进行信息的交互和状态的传递等，因此需要进程间通信。
双进程有名管道通信应用实例
佳佳鸽的博客
08-05 633
更多资料请点击：我的目录 本篇仅用于记录自己所学知识及应用，代码仍可优化，仅供参考，如果发现有错误的地方，尽管留言于我，谢谢。 要求： p1和p2两个进程通信，用有名管道实现 需要两个管道文件 第一个管道 p1写入，p2读取，第二个管道 p2写入，p1读取 p1写入数据 p2把读到的数据做简单处理后返回给p1，反之亦然 所谓的简单处理： 如p1写入"123456"，p2收到之后，反馈给p1 “received:123456” p1收到该反馈信息后，会和之前的信息确认，没有错误才发送下一个信
进程通信的实例－－管道(pipe)
热门推荐
thinkinwm的专栏
03-23 1万+
4.7.5 进程通信的实例－－管道(pipe) 1.管道pipe     进程通信的使用例子之一是UNIX系统的管道通信。UNIX系统从System V 开始，提供有名管道和无名管道两种通信方式，这里介绍无名管道。 无名管道为建立管道的进程及其子孙提供一条以比特流方式传送消息的通信管道。该管道再逻辑上被看作管道文件，在物理上则由文件系统的高速缓冲区构成，而很少启动外设。发送进程利用文件系统
Linux进程管道通信示例
锅锅的博客
03-28 354
Linux管道通信示例 因为进程的变量内存独立，所以进程之间的通信不能用全局变量或者指针等，只能使用文件作为相互通信方式，管道、信号、共享内存实质都是文件，操作方式都是文件操作 管道通信有两种，有名管道和匿名管道，匿名管道是内核4k空间只能用在父子进程，有名管道是硬盘上没有限制， 还要注意以下 　1、管道通信单向的，只能一个进程写，另一个进程读，要实现双向通信就必须建两个管道 　2、管道文件最大4...
掌握Netty：淘宝实战例子与深层原理分析
4. **ChannelPipeline（通道管道）**：是一个围绕ChannelHandler链表的容器，处理数据时，数据会按照添加到管道中的顺序流动。 5. **BootStrap（引导程序）**：用于配置并启动Netty服务器或者客户端。在服务器端使用...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值