IO模型学习笔记

最新推荐文章于 2021-12-27 18:42:59 发布
最新推荐文章于 2021-12-27 18:42:59 发布
阅读量138 收藏
点赞数
分类专栏： IO 文章标签： BIO NIO IO多路复用
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/czxlylc/article/details/116402018
版权

系统调用追踪指令

# 跟踪SocketBIO程序
strace -ff -o out java SocketBIO
# 模拟客户端，连接服务器
nc localhost 9090
# 查看系统连接状态
netstat -natp

IO模型

无论BIO、NIO、多路复用器，都是同步 IO 模型

BIO

Java代码

public static void main(String[] args) {
    try {
        ServerSocket serverSocket = new ServerSocket(8090);
        System.out.println("Step1：new ServerSocket(8090)");
        while (true) {
            Socket client = serverSocket.accept();
            System.out.println("Step2: client\t" + client.getPort());
            new Thread(() -> {
                try {
                    InputStream in = client.getInputStream();
                    BufferedReader reader = new BufferedReader(new InputStreamReader(in));
                    while (true) {
                        Thread.sleep(1000);
                        System.out.println(Thread.currentThread().getName() + " readLine data : " + reader.readLine());
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }).start();
        }
    } catch (IOException e) {
        e.printStackTrace();
    }
}

内核执行流程

  • 当执行 new ServerSocket(8090)，系统内核会调用 socket，bind，listen 创建服务端socket，绑定端口，开启监听

    # 创建socket，得到 fd = 5
socket(AF_INET6, SOCK_STREAM, IPPROTO_IP) = 5
# 绑定端口
bind(5, {sa_family=AF_INET6, sin6_port=htons(8090)，....) = 0
# 开启监听
listen(5, 50) = 0

  • 在 JDK1.4 会执行accept系统调用阻塞，等待客户端连接

    # 阻塞，等待客户端连接
accept(5,
# 接收 端口号为46552的客户端连接，得到客户端连接 fd = 6
accept(5, {sa_family=AF_INET6, sin6_port=htons(46552), ....) = 6
# 创建子线程，处理客户端读写
clone(child_stack=0x7fc475b09fb0, flags=CLONE_VM|CLONE_FS|CLONE_FILES|CLONE_SIGHAND|CLONE_THREAD|CLONE_SYSVSEM|CLONE_SETTLS|CLONE_PARENT_SETTID|CLONE_CHILD_CLEARTID, parent_tidptr=0x7fc475b0a9d0, tls=0x7fc475b0a700, child_tidptr=0x7fc475b0a9d0) = 23019
# 在子进程out.23019文件中，调用recv阻塞读取客户端数据
recv(6, 
# 当客户端有数据输入
recv(6, "test\n", 8192, 0, NULL, NULL) = 5
write(1, "Thread-0 readLine data : test", 29) = 29

  • 使用JDK1.8 执行 accept 系统调用，会使用 poll 系统调用阻塞，等待客户端连接

    # 使用poll多路复用器阻塞，等待客户端连接
poll([{fd=5, events=POLLIN|POLLERR}], 1, -1
# 当有客户端连接进来后，接收到 POLLIN 事件
poll([{fd=5, events=POLLIN|POLLERR}], 1, -1) = 1 ([{fd=5, revents=POLLIN}])
# 接收 端口号为46552的客户端连接，得到客户端连接 fd = 6
accept(5, {sa_family=AF_INET6, sin6_port=htons(46552), ....) = 6
# 通过clone创建子线程，处理客户端读写
clone(child_stack=0x7fc475b09fb0, flags=CLONE_VM|CLONE_FS|CLONE_FILES|CLONE_SIGHAND|CLONE_THREAD|CLONE_SYSVSEM|CLONE_SETTLS|CLONE_PARENT_SETTID|CLONE_CHILD_CLEARTID, parent_tidptr=0x7fc475b0a9d0, tls=0x7fc475b0a700, child_tidptr=0x7fc475b0a9d0) = 23019
# 在子进程out.23019文件中，调用recv阻塞读取客户端数据
recvfrom(6, 
# 当客户端有数据输入
recvfrom(6, "test\n", 8192, 0, NULL, NULL) = 5
write(1, "Thread-0 readLine data : test", 29) = 29

伪代码

socket() = 5;
bind(5, 8090);
listen(5, 50);
while(true){
	// 阻塞，接收客户端连接
	accept(5,) = fd;
    // 创建线程，处理客户端数据
	clone() = while(true){
        // 阻塞，接收客户端数据
		recv(fd,);
	}
}

总结

可以看到，真正的BIO是在jdk1.4之前，之后使用poll多路复用器来获取连接

  • 概念：BIO，对于每个客户端连接，都会创建一个线程来处理客户端数据。一连接，一线程

  • 缺点：

    • 大量连接接入时，需要创建很多线程，浪费系统资源
    • CPU在给线程分配资源的时候，需要频繁的进行内核空间与用户空间的切换，造成大量切换的开销
    • 阻塞，建立连接阻塞，读取数据阻塞

  • 解决方案：采用非阻塞方式，于是就有了NIO的诞生

NIO

Java代码

public static void main(String[] args) {
    LinkedList<SocketChannel> clients = new LinkedList<>();
    try {
        ServerSocketChannel channel = ServerSocketChannel.open();
        channel.bind(new InetSocketAddress(9090));
        channel.configureBlocking(false);

        while (true) {
            Thread.sleep(2000);
            SocketChannel socketChannel = channel.accept();
            if (socketChannel == null) {
                System.out.println("socketChannel is null...");
            } else {
                socketChannel.configureBlocking(false);
                int port = socketChannel.socket().getPort();
                System.out.println("Client port : " + port);
                clients.add(socketChannel);
            }

            ByteBuffer byteBuffer = ByteBuffer.allocateDirect(4096);
            for (SocketChannel sc : clients) {
                int num = sc.read(byteBuffer);
                if (num > 0) {
                    byteBuffer.flip();
                    byte[] a = new byte[byteBuffer.limit()];
                    byteBuffer.get(a);
                    String b = new String(a);
                    System.out.println(sc.socket().getPort() + ":" + b);
                    byteBuffer.clear();
                }
            }
        }
    } catch (Exception e) {
        e.printStackTrace();
    }
}

内核执行流程

  • 创建socket、绑定端口、开启监听

    socket(AF_INET6, SOCK_STREAM, IPPROTO_IP) = 6
bind(6, {sa_family=AF_INET6, sin6_port=htons(9090), ...) = 0
listen(6, 50)                           = 0

  • 设置获取客户端连接非阻塞

    fcntl(6, F_SETFL, O_RDWR|O_NONBLOCK)    = 0

  • 执行channel.accept，进行系统调用，不阻塞，获取结果为null，往下继续执行

    # 当没有客户端连接时，返回 -1
accept(6, 0x7fe3181045c0, [28])         = -1 EAGAIN (资源暂时不可用)
write(1, "socketChannel is null...", 24) = 24

  • 当有客户端连接进来后，得到客户端连接 fd = 7

    accept(6, {sa_family=AF_INET6, sin6_port=htons(58400), ...) = 7
# 设置客户端读取数据非阻塞
fcntl(7, F_SETFL, O_RDWR|O_NONBLOCK)    = 0

  • 执行read读取客户端数据，进行系统调用，不阻塞，没有数据返回 -1

    # 当客户端没有数据发送，返回 -1
read(7, 0x7fe31810aa70, 4096)           = -1 EAGAIN (资源暂时不可用)

  • 当有客户端数据发送时

    # 读取到数据
read(7, "hello\n", 4096)                = 6

伪代码

socket() = 6;
bind(6,9090);
listen(6,50);
fcntl(6, F_SETFL, O_RDWR|O_NONBLOCK);
while(true){
	// 非阻塞，接收客户端连接，没有客户端连接返回-1
	accept(6, {sa_family=AF_INET6, sin6_port=htons(58400), ...) = 7 或 -1 (资源暂时不可用)
	// 遍历客户端连接，读取数据
	for(fd)
        // 非阻塞，读取客户端数据，没有数据则返回 -1
		read(7, "hello\n", 4096)                = 6 或 -1 (资源暂时不可用)
	}
}

总结

  • 概念：NIO，通过一个线程来创建客户连接，读写客户端数据；在Java层面NIO是指New IO，在操作系统层面NIO是指Non Blocking IO
  • 优点：面对大量连接，避免了创建大量线程的问题，通过一个线程处理N个连接以及读写
  • 缺点：在有大量连接的情况下，若只有1个客户端有数据，每次循环必须向内核发送一次 read 系统调用，造成很多系统调用都是无效的。
  • 解决方案：通过IO多路复用器，将所有fd传递给内核，由系统来检测哪些fd是可读状态，遍历可读写的fd，减少read系统调用次数

多路复用器

服务端采用单线程，通过 select 、poll、epoll 等系统调用传递 fd 列表到内核，内核遍历有事件的 fd 进行 accept、recv 等操作

IO 多路复用是一种同步 IO 模型，实现一个线程可以监视多个 fd ，一旦某个 fd 就绪，就能通知应用程序进行相对应的读写操作；没有 fd 就绪时就会阻塞程序，交出 CPU

多路是指多个网络连接，复用指的是一次系统调用，通过一次系统调用将多个连接传递给内核

select、poll

  • select：系统调用传递的FD有限，通过 FD_SETSIZE 设置，默认1024
  • poll：没有 FD 限制

优点：通过一次系统调用，把 fds 传递给内核，获取可执行 fd 的数量；在内核中进行遍历，减少了系统调用的次数

int select(int nfds, fd_set *readfds, fd_set *writefds,
                  fd_set *exceptfds, struct timeval *timeout);

int poll(struct pollfd *fds, nfds_t nfds, int timeout);

缺点：

  • 每次调用 select，poll 都需要把 fd 集合传递给内核空间，从用户态拷贝到内核态，这个在 fd 很多时开销很大
  • 每次 select ，poll 都需要重新遍历全量的 fd

epoll

  • 通过在内核开辟空间，使用红黑树存储 fd ，避免 fd 集合从用户态到内核态的多次拷贝

Java代码

static ServerSocketChannel server = null;
static Selector selector = null;

public static void main(String[] args) {
    initServer();
    System.out.println("服务器启动了....");
    try {
        while (true) {
            Set<SelectionKey> selectionKeys = selector.keys();
            System.out.println("keys.size = " + selectionKeys.size());
            while (selector.select() > 0) {
                // 遍历有状态的key
                Set<SelectionKey> keys = selector.selectedKeys();
                Iterator<SelectionKey> iterator = keys.iterator();
                while (iterator.hasNext()) {
                    SelectionKey selectionKey = iterator.next();
                    iterator.remove();
                    if (selectionKey.isAcceptable()) {
                        handleAccept(selectionKey);
                    } else if (selectionKey.isReadable()) {
                        handleRead(selectionKey);
                    }
                }
            }
        }
    } catch (IOException e) {
        e.printStackTrace();
    }

}

public static void initServer() {
    try {
        server = ServerSocketChannel.open();
        server.bind(new InetSocketAddress(9090));
        server.configureBlocking(false);

        selector = Selector.open();
        server.register(selector, SelectionKey.OP_ACCEPT);
    } catch (Exception e) {
        e.printStackTrace();
    }
}

public static void handleAccept(SelectionKey key) {
    try {
        ServerSocketChannel serverSocketChannel = (ServerSocketChannel) key.channel();
        SocketChannel client = serverSocketChannel.accept();
        client.configureBlocking(false);

        ByteBuffer byteBuffer = ByteBuffer.allocateDirect(4098);
        client.register(selector, SelectionKey.OP_READ, byteBuffer);

        System.out.println("client address : " + client.getRemoteAddress());
    } catch (Exception e) {
        e.printStackTrace();
    }
}

public static void handleRead(SelectionKey key) {
    SocketChannel socketChannel = (SocketChannel) key.channel();
    ByteBuffer byteBuffer = (ByteBuffer) key.attachment();
    byteBuffer.clear();
    int read = 0;
    try {
        while (true) {
            read = socketChannel.read(byteBuffer);
            if (read > 0) {
                byteBuffer.flip();
                byte[] a = new byte[byteBuffer.limit()];
                byteBuffer.get(a);
                String b = new String(a);
                System.out.println("read data : " + b);
                byteBuffer.clear();
            }
        }
    } catch (Exception e) {
        e.printStackTrace();
    }
}

内核执行流程

  • 创建socket、绑定端口、开启监听
socket(AF_INET6, SOCK_STREAM, IPPROTO_IP) = 6
bind(6, {sa_family=AF_INET6, sin6_port=htons(9090), ....) = 0
listen(6, 50)   =  0
  • 在内核开辟存储空间，存储 fd，得到内核空间的文件描述符 = 9
# 在内核开辟内存空间
epoll_create(256) = 9
  • 往内核空间中添加socket连接
# 往内核空间9中添加 fd=6 的socket
epoll_ctl(9, EPOLL_CTL_ADD, 6, {EPOLLIN, {u32=6, u64=140651589009414}}) = 0
  • 通过 epoll_wait 系统调用，在超时时间内阻塞等待客户端连接
epoll_wait(9,
  • 当有客户端连接，epoll_wait检测到有客户端连接
# epoll_wait 返回1，发现 fd=6 上有事件触发
epoll_wait(9, [{EPOLLIN, {u32=6, u64=140651589009414}}], 4096, -1) = 1
# 通过accept系统调用，在 socket=6 上，创建客户端连接 fd = 10
accept(6, {sa_family=AF_INET6, sin6_port=htons(58420), ....) = 10
# 将客户端连接 fd 添加到 系统内核中
epoll_ctl(9, EPOLL_CTL_ADD, 10, {EPOLLIN, {u32=10, u64=140651589009418}}) = 0
# 阻塞，等待fd上有事件发生
epoll_wait(9,
  • 客户端又数据写入
# epoll_wait 返回1，发现 fd=10 上有事件触发
epoll_wait(9, [{EPOLLIN, {u32=10, u64=140651589009418}}], 4096, -1) = 1
# 读取数据
read(10, "hello epoll\n", 4098)         = 12
# 打印数据
write(1, "read data : hello epoll\n", 24) = 24
# 不阻塞，继续循环读取，客户端数据，
read(10, 0x7fec0c120520, 4098)          = -1 EAGAIN (资源暂时不可用)
read(10, 0x7fec0c120520, 4098)          = -1 EAGAIN (资源暂时不可用)

伪代码

// 创建socket，绑定端口，开启监听
socket() = 6
bind(6, 9090) 
listen(6, 50)
fcntl(6, F_SETFL, O_RDWR|O_NONBLOCK);

// 开辟内核空间
epoll_create(256) = 9
// 将socket添加到内核
epoll_ctl(9, EPOLL_CTL_ADD, 6, {EPOLLIN, {u32=6, u64=140651589009414}}) = 0
epoll_wait(9,  // 阻塞，当有 fd 事件发生，返回结果大于0
// epoll_wait(9, [{EPOLLIN, {u32=6, u64=140651589009414}}], 4096, -1) = 1
// epoll_wait(9, [{EPOLLIN, {u32=10, u64=140651589009418}}], 4096, -1) = 1
while(epoll_wait(9) > 0) {
    if (key.isAcceptable()) {
        // 创建客户端连接 fd
        accept(6, {sa_family=AF_INET6, sin6_port=htons(58420), ...) = 10
        // 设置客户端非阻塞
        fcntl(10, F_SETFL, O_RDWR|O_NONBLOCK)   = 0
        // 将客户端连接添加到内核
        epoll_ctl(9, EPOLL_CTL_ADD, 10, {EPOLLIN, {u32=10, u64=140651589009418}}) = 0
    } else if (key.isReadable()) {
        // 读取数据
        while(true) {
            // 非阻塞，当没有数据读取，返回-1  
            // read(10, 0x7fec0c120520, 4098)          = -1 EAGAIN (资源暂时不可用)
            read(10, "hello epoll\n", 4098)  =  12  (当没有数据读取，返回-1)
        }
    }
}

总结

  • 通过 epoll_create，epoll_ctl，epoll_wait三个系统调用实现

  • epoll_create ：在内核开辟一块空间，存储文件描述符 fd，返回一个内核空间的描述符epfd

  • epoll_ctl：内核空间操作

    • EPOLL_CTL_ADD：往内核空间中注册一个 fd
    • EPOLL_CTL_MOD：修改内核空间中注册的fd
    • EPOLL_CTL_DEL：从内核空间中删除注册的fd

  • epoll_wait：在超时时间内阻塞等待IO事件发生，当有事件发生，则返回发生事件的 fd 数量

每当fd就绪，系统注册回调函数就会被调用，将就绪的fd放到readyList中

附录一、案例追踪

Redis

# 在内核开辟空间，得到空间fd=5
epoll_create(1024) = 5
# 创建socket，fd=7
socket(AF_INET, SOCK_STREAM, IPPROTO_TCP) = 7
# 在fd=7上绑定6379端口
bind(7, {sa_family=AF_INET, sin_port=htons(6379), sin_addr=inet_addr("0.0.0.0")}, 16) = 0
# 开启监听
listen(7, 511)  = 0
# 将fd=7添加到内核空间
epoll_ctl(5, EPOLL_CTL_ADD, 7, {EPOLLIN, {u32=7, u64=7}}) = 0
# 非阻塞，等待事件触发
epoll_wait(5, [], 10128, 0)             = 0
epoll_wait(5, [], 10128, 100)           = 0
################################################
# 有客户端连接接入
epoll_wait(5, [{EPOLLIN, {u32=7, u64=7}}], 10128, 100) = 1
# 创建客户端连接，得到fd=8
accept(7, {sa_family=AF_INET, sin_port=htons(36250), sin_addr=inet_addr("127.0.0.1")}, [128->16]) = 8
# 将fd=8添加到内核空间
epoll_ctl(5, EPOLL_CTL_ADD, 8, {EPOLLIN, {u32=8, u64=8}}) = 0
# 有数据写入
epoll_wait(5, [{EPOLLIN, {u32=8, u64=8}}], 10128, 15) = 1
# 非阻塞，等待事件触发
epoll_wait(5, [], 10128, 1)             = 0
epoll_wait(5, [], 10128, 100)             = 0
# 客户端fd=8有数据写入，epoll_wait监听到事件发生，执行read
epoll_wait(5, [{EPOLLIN, {u32=8, u64=8}}], 10128, 100) = 1
read(8, "*2\r\n$3\r\nget\r\n$4\r\nname\r\n", 16384) = 23

附录二、系统调用函数

// 创建一个socket文件描述符，sockfd
int socket(int domain, int type, int protocol);
// 为socket绑定一个端口
int bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen);
// 在socket上开启监听
int listen(int sockfd, int backlog);
// 在socket上接收客户端连接
int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen);
// 读取 socket fd 上的数据，返回数据长度
ssize_t recv(int sockfd, void *buf, size_t len, int flags);
ssize_t recvfrom(int sockfd, void *buf, size_t len, int flags,
                        struct sockaddr *src_addr, socklen_t *addrlen);
// 读取 fd 上的数据，返回数据长度
ssize_t read(int fd, void *buf, size_t count);

// 在内核开辟空间，返回内核空间文件描述符，epfd
int epoll_create(int size);
// op=add：在内核空间中注册目标fd的事件
// op=mod：修改内核空间中注册的目标fd事件
// op=del：删除内核空间中的fd
int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event);
// 等待内核空间fd有事件发生，可设置超时时间，timeout=-1阻塞，timeout=0 直接返回
int epoll_wait(int epfd, struct epoll_event *events, int maxevents, int timeout);

附录三、系统调用追踪日志

系统调用流程

在这里插入图片描述

BIO主线程

在这里插入图片描述

BIO子线程

在这里插入图片描述

NIO

在这里插入图片描述

EPOLL

在这里插入图片描述

参考资料

  • 《UNIX网络编程_卷1_套接字联网API》
湘水友独
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
操作系统IO模型
qq_45602114的博客
04-11 130
IO模型 阻塞IO 同步IO 要等待两个阶段 1.DMA从硬盘考贝数据到内存缓存区，然后通知CPU数据准备好了 2.CPU把内存缓冲区的数据 考到用户缓冲区，然后用户进程开始漫长的拷贝数据阶段，同步操作 用户read操作后，就会一直阻塞等待数据 非阻塞IO 1.用户进程发起read命令，cpu给dma发取读取命令，如果dma没有把数据准备好，内核会立刻给用户进程返回一个error 2.用户进程角度，虽然用户进程不会被阻塞，但是它会一直轮询，直到数据准备好了，停止轮询，开始漫长的数据拷贝，这是同步操作 用户r
Ruby学习笔记
09-28
中间的Io和prolog就被华丽丽的跳过了，因为prolog语法太奇葩，Io有没什么好的资料可以看，尽管我觉的Io应该会是一个强大的工具，而且语法超级简单。对象模型比起JavaScript好的不是一点两点，clone关键字真是为原型...
linux下strace命令跟踪java进程
feinifi的博客
07-15 1462
strace命令的使用，是看了马士兵老师讲的netty底层原理课程，里面举了一个例子，使用java程序编写一个简单的socket服务器，然后等待客户端连接。 本身，这个程序很简单，但是通过strace命令跟踪，可以看到，jvm底层调用了linux系统内核的socket，出现了一系列bind,listen,accept等等命令。 strace这个命令并不是linux自带的，需要安装，centos系列可以直接通过yum安装。 下面直接看示例： SocketTes...
select、poll、epoll - IO模型超详解
热门推荐
XueyinGuo的博客
01-24 1万+
Linux操作系统有关IO的知识铺垫 1. Pagecache Linux内核所使用的的主要磁盘高速缓存。内核读写磁盘的时候都要用到这个PageCache。如果程序想要读的部分不在高速缓存，则先申请一个4KB大小的新页框加到PageCache，然后再用磁盘读到的数据填充。 写操作的时候，先把要写的数据写到pageCache，标记当前页面为脏，然后要么程序自己调用系统调用刷盘，要么就等着内核到了自己的默认设置去给你刷回去。 如果没有及时写出现了断电，那么你就白写了。 2. 文件描述符 创建文件描述符，文件描述
计算机操作系统学习笔记(12)——I/O 多路复⽤：select/poll/epoll
BookSea的博客
12-27 926
文章目录一、最基本的 Socket 模型二、建立Socket的过程三、如何服务更多的⽤户？四、多进程模型五、多线程模型六、I/O 多路复⽤select/pollepoll 这篇的内容相当重要的 一、最基本的 Socket 模型 Socket 的中⽂名叫作插⼝，双⽅要进⾏⽹络通信前，各⾃得创建⼀个 Socket，这相当于客户端和服务器都开了⼀个“⼝⼦”，双⽅读取和发送数据的时候都通过这个“⼝⼦”。这样⼀看，是不是觉得很像弄了⼀根⽹线，⼀头插在客户端，⼀头插在服务端，然后进⾏通信。 二、建立Socket的
Netty学习笔记—IO模型
08-26 1673
netty是一个流行的NIO的框架，它的健壮性、性能、功能都特别的好。既然是一个NIO的框架，那么今天就来聊一聊IO模型。 BIO模型 在网络编程中，基本的模型也就是常见的Client/Server模型，这也就是常见的两个进程之间的相互通信。也非常的简单，服务端暴漏自己的ip和端口，客户端通过地址信息向服务端发起连接请求，经过三次请求的握手进行建立连接，如果连接成功，双方就可以开始进行通信。 上面
TensorFlow学习笔记1——Session会话控制
01-06
TensorFlow的运行机制属于“定义”与“运行”相分离，从操作层面可以抽象成两种：构造模型和模型运行。 一个TensorFlow图描述了计算的过程，为了进行计算，图必须在会话Session里启动。Session拥有和管理物理资源CPU...
python机器学习算法（赵志勇）学习笔记( Logistic Regression，LR模型)
12-22
Logistic Regression模型 线性可分和线性不可分 对于一个分类问题，通常可以分为线性可分与线性不可分两种。如果一个分类问题可以使用线性判别函数正确分类，则称该问题为线性可分否则为线性不可分问题 Logistic
calm-notebooks:于alivecode.io使用的笔记本
05-02
Scikit指标您如何自定义指标以选择正确的模型。 课程可以在找到，笔记本可以在找到。Scikit-Meta 如何在scikit-learn中应用后处理。 课程可以在找到，笔记本可以在找到。Scikit预处理预处理可以突然使算法起作用吗？...
Markdown学习笔记
04-30
Markdown学习笔记
热塑性弹性体，全球前21强生产商排名及市场份额.docx
04-30
热塑性弹性体，全球前21强生产商排名及市场份额
配合eclipse svn插件subclipse-4.3.4版本的javahl
04-30
配合eclipse svn插件subclipse-4.3.4版本的javahl，将其中的features和plugins目录解压到与subclipse-4.3.4插件同一目录下即可。在eclipse 4.31版本上验证有效。
一个基于epoll的多线程 linux c http web服务器.zip
04-30
一个基于epoll的多线程 linux c http web服务器.zip
Bash脚本教程：优雅地管理Java应用.zip
04-30
本Bash脚本用于自动化管理Java JAR应用的启动、停止及监控。首先检查JAR进程是否在运行，如在运行则安全终止。随后，使用预设的Java参数启动JAR文件，并将输出和错误日志重定向至日志文件。启动后，脚本持续监控JAR进程状态，确保其在预设时间内成功启动。本脚本提供了灵活的配置和错误处理机制，为Java应用的运维管理带来了便捷与可靠性。
嗨淘V12刷任务点赞系统源码+手动派单版本.rar
04-30
嗨淘V12刷任务点赞系统源码+手动派单版本.rar嗨淘V12刷任务点赞系统源码+手动派单版本.rar
Bash脚本教程：Java JAR应用快速启动与监控.zip
04-30
本Bash脚本用于自动化管理Java JAR应用的启动、停止及监控。首先检查JAR进程是否在运行，如在运行则安全终止。随后，使用预设的Java参数启动JAR文件，并将输出和错误日志重定向至日志文件。启动后，脚本持续监控JAR进程状态，确保其在预设时间内成功启动。本脚本提供了灵活的配置和错误处理机制，为Java应用的运维管理带来了便捷与可靠性。
秒懂傅里叶变换matlab程序实现过程
04-30
秒懂傅里叶变换matlab程序实现过程
某大型集团管控制度流程 qy.pptx
最新发布
04-30
某大型集团管控制度流程 qy.pptx
mysql的io模型
01-23
MySQL的IO模型是指MySQL服务器在处理客户端请求时，如何进行输入输出操作。MySQL的IO模型主要有两种：BIO（同步阻塞IO）和NIO（异步非阻塞IO）。 1. BIO模型： BIO模型是MySQL最早采用的IO模型，也是典型的阻塞IO...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值