AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

linux网络编程（四）多路I/O转接服务器

2022-12-14 127
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： linux网络编程（四）多路I/O转接服务器

1.多路I/O转接服务器


多路IO转接服务器也叫做多任务IO服务器。该类服务器实现的主旨思想是，不再由应用程序自己监视客户端连接，取而代之由内核替应用程序监视文件。


主要使用的方法有三种


2.select 方式的多路I/O转接服务器


1.select能监听的文件描述符个数受限于FD_SETSIZE，一般为1024，单纯改变进程打开的文件描述符个数并不能改变select监听文件个数


2.解决1024以下客户端时使用select是很合适的，但如果链接客户端过多，select采用的是轮询模型，会大大降低服务器响应效率，不应在select上投入更多精力。

#include <sys/select.h>
/* According to earlier standards */
#include <sys/time.h>
#include <sys/types.h>
#include <unistd.h>
int select(int nfds, fd_set *readfds, fd_set *writefds,
    fd_set *exceptfds, struct timeval *timeout);
  nfds:   监控的文件描述符集里最大文件描述符加1，因为此参数会告诉内核检测前多少个文件描述符的状态
  readfds：  监控有读数据到达文件描述符集合，传入传出参数
  writefds： 监控写数据到达文件描述符集合，传入传出参数
  exceptfds：  监控异常发生达文件描述符集合,如带外数据到达异常，传入传出参数
  timeout：  定时阻塞监控时间，3种情况
    1.NULL，永远等下去
    2.设置timeval，等待固定时间
    3.设置timeval里时间均为0，检查描述字后立即返回，轮询
  struct timeval {
  long tv_sec; /* seconds */
  long tv_usec; /* microseconds */
  };
  void FD_CLR(int fd, fd_set *set);  //把文件描述符集合里fd位清0
  int FD_ISSET(int fd, fd_set *set);  //测试文件描述符集合里fd是否置1
  void FD_SET(int fd, fd_set *set);  //把文件描述符集合里fd位置1
  void FD_ZERO(fd_set *set);    //把文件描述符集合里所有位清0
server
/* server.c */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include "wrap.h"
#define MAXLINE 80
#define SERV_PORT 6666
int main(int argc, char *argv[])
{
  int i, maxi, maxfd, listenfd, connfd, sockfd;
  int nready, client[FD_SETSIZE];  /* FD_SETSIZE 默认为 1024 */
  ssize_t n;
  fd_set rset, allset;
  char buf[MAXLINE];
  char str[INET_ADDRSTRLEN];    /* #define INET_ADDRSTRLEN 16 */
  socklen_t cliaddr_len;
  struct sockaddr_in cliaddr, servaddr;
  listenfd = Socket(AF_INET, SOCK_STREAM, 0);
bzero(&servaddr, sizeof(servaddr));
servaddr.sin_family = AF_INET;
servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
servaddr.sin_port = htons(SERV_PORT);
Bind(listenfd, (struct sockaddr *)&servaddr, sizeof(servaddr));
Listen(listenfd, 20);   /* 默认最大128 */
maxfd = listenfd;    /* 初始化 */
maxi = -1;      /* client[]的下标 */
for (i = 0; i < FD_SETSIZE; i++)
  client[i] = -1;   /* 用-1初始化client[] */
FD_ZERO(&allset);
FD_SET(listenfd, &allset); /* 构造select监控文件描述符集 */
for ( ; ; ) {
  rset = allset;    /* 每次循环时都从新设置select监控信号集 */
  nready = select(maxfd+1, &rset, NULL, NULL, NULL);
  if (nready < 0)
  perr_exit("select error");
  if (FD_ISSET(listenfd, &rset)) { /* new client connection */
  cliaddr_len = sizeof(cliaddr);
  connfd = Accept(listenfd, (struct sockaddr *)&cliaddr, &cliaddr_len);
  printf("received from %s at PORT %d\n",
    inet_ntop(AF_INET, &cliaddr.sin_addr, str, sizeof(str)),
    ntohs(cliaddr.sin_port));
  for (i = 0; i < FD_SETSIZE; i++) {
    if (client[i] < 0) {
    client[i] = connfd; /* 保存accept返回的文件描述符到client[]里 */
    break;
    }
  }
  /* 达到select能监控的文件个数上限 1024 */
  if (i == FD_SETSIZE) {
    fputs("too many clients\n", stderr);
    exit(1);
  }
  FD_SET(connfd, &allset);  /* 添加一个新的文件描述符到监控信号集里 */
  if (connfd > maxfd)
    maxfd = connfd;   /* select第一个参数需要 */
  if (i > maxi)
    maxi = i;     /* 更新client[]最大下标值 */
  if (--nready == 0)
    continue;     /* 如果没有更多的就绪文件描述符继续回到上面select阻塞监听,
          负责处理未处理完的就绪文件描述符 */
  }
  for (i = 0; i <= maxi; i++) {  /* 检测哪个clients 有数据就绪 */
    if ( (sockfd = client[i]) < 0)
    continue;
    if (FD_ISSET(sockfd, &rset)) {
    if ( (n = Read(sockfd, buf, MAXLINE)) == 0) {
      Close(sockfd);  /* 当client关闭链接时，服务器端也关闭对应链接 */
      FD_CLR(sockfd, &allset); /* 解除select监控此文件描述符 */
      client[i] = -1;
    } else {
      int j;
      for (j = 0; j < n; j++)
      buf[j] = toupper(buf[j]);
      Write(sockfd, buf, n);
    }
    if (--nready == 0)
      break;
    }
  }
  }
  close(listenfd);
  return 0;
}
client
/* client.c */
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <netinet/in.h>
#include "wrap.h"
#define MAXLINE 80
#define SERV_PORT 6666
int main(int argc, char *argv[])
{
  struct sockaddr_in servaddr;
  char buf[MAXLINE];
  int sockfd, n;
  sockfd = Socket(AF_INET, SOCK_STREAM, 0);
  bzero(&servaddr, sizeof(servaddr));
  servaddr.sin_family = AF_INET;
  inet_pton(AF_INET, "127.0.0.1", &servaddr.sin_addr);
  servaddr.sin_port = htons(SERV_PORT);
  Connect(sockfd, (struct sockaddr *)&servaddr, sizeof(servaddr));
  while (fgets(buf, MAXLINE, stdin) != NULL) {
  Write(sockfd, buf, strlen(buf));
  n = Read(sockfd, buf, MAXLINE);
  if (n == 0)
    printf("the other side has been closed.\n");
  else
    Write(STDOUT_FILENO, buf, n);
  }
  Close(sockfd);
  return 0;
}


pselect

pselect原型如下。此模型应用较少，有需要的同学可参考select模型自行编写C/S

#include <sys/select.h>
int pselect(int nfds, fd_set *readfds, fd_set *writefds,
    fd_set *exceptfds, const struct timespec *timeout,
    const sigset_t *sigmask);
  struct timespec {
  long tv_sec; /* seconds */
  long tv_nsec; /* nanoseconds */
  };
  用sigmask替代当前进程的阻塞信号集，调用返回后还原原有阻塞信号集


3.poll 方式的多路I/O转接服务器


#include <poll.h>
int poll(struct pollfd *fds, nfds_t nfds, int timeout);
  struct pollfd {
  int fd; /* 文件描述符 */
  short events; /* 监控的事件 */
  short revents; /* 监控事件中满足条件返回的事件 */
  };
  POLLIN    普通或带外优先数据可读,即POLLRDNORM | POLLRDBAND
  POLLRDNORM  数据可读
  POLLRDBAND  优先级带数据可读
  POLLPRI   高优先级可读数据
  POLLOUT  普通或带外数据可写
  POLLWRNORM  数据可写
  POLLWRBAND  优先级带数据可写
  POLLERR   发生错误
  POLLHUP   发生挂起
  POLLNVAL    描述字不是一个打开的文件
  nfds    监控数组中有多少文件描述符需要被监控
  timeout   毫秒级等待
  -1：阻塞等，#define INFTIM -1    Linux中没有定义此宏
  0：立即返回，不阻塞进程
  >0：等待指定毫秒数，如当前系统时间精度不够毫秒，向上取值


如果不再监控某个文件描述符时，可以把pollfd中，fd设置为-1，poll不再监控此pollfd，下次返回时，把revents设置为0。

相较于select而言，poll的优势：


传入、传出事件分离。无需每次调用时，重新设定监听事件。

文件描述符上限，可突破1024限制。能监控的最大上限数可使用配置文件调整。

server
/* server.c */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <poll.h>
#include <errno.h>
#include "wrap.h"
#define MAXLINE 80
#define SERV_PORT 6666
#define OPEN_MAX 1024
int main(int argc, char *argv[])
{
  int i, j, maxi, listenfd, connfd, sockfd;
  int nready;
  ssize_t n;
  char buf[MAXLINE], str[INET_ADDRSTRLEN];
  socklen_t clilen;
  struct pollfd client[OPEN_MAX];
  struct sockaddr_in cliaddr, servaddr;
  listenfd = Socket(AF_INET, SOCK_STREAM, 0);
  bzero(&servaddr, sizeof(servaddr));
  servaddr.sin_family = AF_INET;
  servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
  servaddr.sin_port = htons(SERV_PORT);
  Bind(listenfd, (struct sockaddr *)&servaddr, sizeof(servaddr));
  Listen(listenfd, 20);
  client[0].fd = listenfd;
  client[0].events = POLLIN;      /* listenfd监听普通读事件 */
  for (i = 1; i < OPEN_MAX; i++)
  client[i].fd = -1;        /* 用-1初始化client[]里剩下元素 */
  maxi = 0;           /* client[]数组有效元素中最大元素下标 */
  for ( ; ; ) {
  nready = poll(client, maxi+1, -1);    /* 阻塞 */
  if (client[0].revents & POLLIN) {   /* 有客户端链接请求 */
    clilen = sizeof(cliaddr);
    connfd = Accept(listenfd, (struct sockaddr *)&cliaddr, &clilen);
    printf("received from %s at PORT %d\n",
      inet_ntop(AF_INET, &cliaddr.sin_addr, str, sizeof(str)),
      ntohs(cliaddr.sin_port));
    for (i = 1; i < OPEN_MAX; i++) {
    if (client[i].fd < 0) {
      client[i].fd = connfd;  /* 找到client[]中空闲的位置，存放accept返回的connfd */
      break;
    }
    }
    if (i == OPEN_MAX)
    perr_exit("too many clients");
    client[i].events = POLLIN;    /* 设置刚刚返回的connfd，监控读事件 */
    if (i > maxi)
    maxi = i;       /* 更新client[]中最大元素下标 */
    if (--nready <= 0)
    continue;       /* 没有更多就绪事件时,继续回到poll阻塞 */
  }
  for (i = 1; i <= maxi; i++) {    /* 检测client[] */
    if ((sockfd = client[i].fd) < 0)
    continue;
    if (client[i].revents & POLLIN) {
    if ((n = Read(sockfd, buf, MAXLINE)) < 0) {
      if (errno == ECONNRESET) { /* 当收到 RST标志时 */
      /* connection reset by client */
      printf("client[%d] aborted connection\n", i);
      Close(sockfd);
      client[i].fd = -1;
      } else {
      perr_exit("read error");
      }
    } else if (n == 0) {
      /* connection closed by client */
      printf("client[%d] closed connection\n", i);
      Close(sockfd);
      client[i].fd = -1;
    } else {
      for (j = 0; j < n; j++)
      buf[j] = toupper(buf[j]);
      Writen(sockfd, buf, n);
    }
    if (--nready <= 0)
      break;      /* no more readable descriptors */
    }
  }
  }
  return 0;
}
client
/* client.c */
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <netinet/in.h>
#include "wrap.h"
#define MAXLINE 80
#define SERV_PORT 6666
int main(int argc, char *argv[])
{
  struct sockaddr_in servaddr;
  char buf[MAXLINE];
  int sockfd, n;
  sockfd = Socket(AF_INET, SOCK_STREAM, 0);
  bzero(&servaddr, sizeof(servaddr));
  servaddr.sin_family = AF_INET;
  inet_pton(AF_INET, "127.0.0.1", &servaddr.sin_addr);
  servaddr.sin_port = htons(SERV_PORT);
  Connect(sockfd, (struct sockaddr *)&servaddr, sizeof(servaddr));
  while (fgets(buf, MAXLINE, stdin) != NULL) {
  Write(sockfd, buf, strlen(buf));
  n = Read(sockfd, buf, MAXLINE);
  if (n == 0)
    printf("the other side has been closed.\n");
  else
    Write(STDOUT_FILENO, buf, n);
  }
  Close(sockfd);
  return 0;
}


ppoll

GNU定义了ppoll（非POSIX标准），可以支持设置信号屏蔽字，大家可参考poll模型自行实现C/S。

#define _GNU_SOURCE /* See feature_test_macros(7) */
#include <poll.h>
int ppoll(struct pollfd *fds, nfds_t nfds,
     const struct timespec *timeout_ts, const sigset_t *sigmask);


4.epoll 方式的多路I/O转接服务器


epoll是Linux下多路复用IO接口select/poll的增强版本，它能显著提高程序在大量并发连接中只有少量活跃的情况下的系统CPU利用率，因为它会复用文件描述符集合来传递结果而不用迫使开发者每次等待事件之前都必须重新准备要被侦听的文件描述符集合，另一点原因就是获取事件的时候，它无须遍历整个被侦听的描述符集，只要遍历那些被内核IO事件异步唤醒而加入Ready队列的描述符集合就行了。

目前epoll是linux大规模并发网络程序中的热门首选模型。 epoll除了提供select/poll那种IO事件的电平触发（Level Triggered）外，还提供了边沿触发（Edge

Triggered），这就使得用户空间程序有可能缓存IO状态，减少epoll_wait/epoll_pwait的调用，提高应用程序效率。

可以使用cat命令查看一个进程可以打开的socket描述符上限。

cat /proc/sys/fs/file-max

如有需要，可以通过修改配置文件的方式修改该上限值。

sudo vi /etc/security/limits.conf

在文件尾部写入以下配置,soft软限制，hard硬限制。如下图所示。

* soft nofile 65536
* hard nofile 100000

1670952487008.jpg

1.创建一个epoll句柄，参数size用来告诉


内核监听的文件描述符的个数，跟内存大小有关。

#include <sys/epoll.h>
int epoll_create(int size)  
  size：监听数目（内核参考值）
  返回值：成功：非负文件描述符；失败：-1，设置相应的errno


基础API

1.控制某个epoll监控的文件描述符上的事件：注册、修改、删除。

#include <sys/epoll.h>
  int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event)
  epfd： 为epoll_creat的句柄
  op：  表示动作，用3个宏来表示：
    EPOLL_CTL_ADD (注册新的fd到epfd)，
    EPOLL_CTL_MOD (修改已经注册的fd的监听事件)，
    EPOLL_CTL_DEL (从epfd删除一个fd)；
  event：  告诉内核需要监听的事件
  struct epoll_event {
    __uint32_t events; /* Epoll events */
    epoll_data_t data; /* User data variable */
  };
  typedef union epoll_data {
    void *ptr;
    int fd;
    uint32_t u32;
    uint64_t u64;
  } epoll_data_t;
  EPOLLIN ： 表示对应的文件描述符可以读（包括对端SOCKET正常关闭）
  EPOLLOUT： 表示对应的文件描述符可以写
  EPOLLPRI： 表示对应的文件描述符有紧急的数据可读（这里应该表示有带外数据到来）
  EPOLLERR： 表示对应的文件描述符发生错误
  EPOLLHUP： 表示对应的文件描述符被挂断；
  EPOLLET：  将EPOLL设为边缘触发(Edge Triggered)模式，这是相对于水平触发(Level Triggered)而言的
  EPOLLONESHOT：只监听一次事件，当监听完这次事件之后，如果还需要继续监听这个socket的话，需要再次把这个socket加入到EPOLL队列里
  返回值：成功：0；失败：-1，设置相应的errno


1.等待所监控文件描述符上有事件的产生，类似于select()调用。

#include <sys/epoll.h>
  int epoll_wait(int epfd, struct epoll_event *events, int maxevents, int timeout)
  events：  用来存内核得到事件的集合，可简单看作数组。
  maxevents：  告之内核这个events有多大，这个maxevents的值不能大于创建epoll_create()时的size，
  timeout：  是超时时间
    -1： 阻塞
    0：  立即返回，非阻塞
    >0： 指定毫秒
  返回值：  成功返回有多少文件描述符就绪，时间到时返回0，出错返回-1
server
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <sys/epoll.h>
#include <errno.h>
#include "wrap.h"
#define MAXLINE 80
#define SERV_PORT 6666
#define OPEN_MAX 1024
int main(int argc, char *argv[])
{
  int i, j, maxi, listenfd, connfd, sockfd;
  int nready, efd, res;
  ssize_t n;
  char buf[MAXLINE], str[INET_ADDRSTRLEN];
  socklen_t clilen;
  int client[OPEN_MAX];
  struct sockaddr_in cliaddr, servaddr;
  struct epoll_event tep, ep[OPEN_MAX];
  listenfd = Socket(AF_INET, SOCK_STREAM, 0);
  bzero(&servaddr, sizeof(servaddr));
  servaddr.sin_family = AF_INET;
  servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
  servaddr.sin_port = htons(SERV_PORT);
  Bind(listenfd, (struct sockaddr *) &servaddr, sizeof(servaddr));
  Listen(listenfd, 20);
  for (i = 0; i < OPEN_MAX; i++)
  client[i] = -1;
  maxi = -1;
  efd = epoll_create(OPEN_MAX);
  if (efd == -1)
  perr_exit("epoll_create");
  tep.events = EPOLLIN; tep.data.fd = listenfd;
  res = epoll_ctl(efd, EPOLL_CTL_ADD, listenfd, &tep);
  if (res == -1)
  perr_exit("epoll_ctl");
  while (1) {
  nready = epoll_wait(efd, ep, OPEN_MAX, -1); /* 阻塞监听 */
  if (nready == -1)
    perr_exit("epoll_wait");
  for (i = 0; i < nready; i++) {
    if (!(ep[i].events & EPOLLIN))
    continue;
    if (ep[i].data.fd == listenfd) {
    clilen = sizeof(cliaddr);
    connfd = Accept(listenfd, (struct sockaddr *)&cliaddr, &clilen);
    printf("received from %s at PORT %d\n", 
      inet_ntop(AF_INET, &cliaddr.sin_addr, str, sizeof(str)), 
      ntohs(cliaddr.sin_port));
    for (j = 0; j < OPEN_MAX; j++) {
      if (client[j] < 0) {
      client[j] = connfd; /* save descriptor */
      break;
      }
    }
    if (j == OPEN_MAX)
      perr_exit("too many clients");
    if (j > maxi)
      maxi = j;   /* max index in client[] array */
    tep.events = EPOLLIN; 
    tep.data.fd = connfd;
    res = epoll_ctl(efd, EPOLL_CTL_ADD, connfd, &tep);
    if (res == -1)
      perr_exit("epoll_ctl");
    } else {
    sockfd = ep[i].data.fd;
    n = Read(sockfd, buf, MAXLINE);
    if (n == 0) {
      for (j = 0; j <= maxi; j++) {
      if (client[j] == sockfd) {
        client[j] = -1;
        break;
      }
      }
      res = epoll_ctl(efd, EPOLL_CTL_DEL, sockfd, NULL);
      if (res == -1)
      perr_exit("epoll_ctl");
      Close(sockfd);
      printf("client[%d] closed connection\n", j);
    } else {
      for (j = 0; j < n; j++)
      buf[j] = toupper(buf[j]);
      Writen(sockfd, buf, n);
    }
    }
  }
  }
  close(listenfd);
  close(efd);
  return 0;
}



client
/* client.c */
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <netinet/in.h>
#include "wrap.h"
#define MAXLINE 80
#define SERV_PORT 6666
int main(int argc, char *argv[])
{
  struct sockaddr_in servaddr;
  char buf[MAXLINE];
  int sockfd, n;
  sockfd = Socket(AF_INET, SOCK_STREAM, 0);
  bzero(&servaddr, sizeof(servaddr));
  servaddr.sin_family = AF_INET;
  inet_pton(AF_INET, "127.0.0.1", &servaddr.sin_addr);
  servaddr.sin_port = htons(SERV_PORT);
  Connect(sockfd, (struct sockaddr *)&servaddr, sizeof(servaddr));
  while (fgets(buf, MAXLINE, stdin) != NULL) {
  Write(sockfd, buf, strlen(buf));
  n = Read(sockfd, buf, MAXLINE);
  if (n == 0)
    printf("the other side has been closed.\n");
  else
    Write(STDOUT_FILENO, buf, n);
  }
  Close(sockfd);
  return 0;
}
文章标签：
监控
Linux
API
缓存
开发者
关键词：
Linux服务器
Linux网络
云服务器 ECS Linux
网络i/o
网络服务器
6agucrwnzwl4a
目录
相关文章
追逐时光者
|
1天前
|
运维 监控 Linux
推荐几个不错的 Linux 服务器管理工具
推荐几个不错的 Linux 服务器管理工具
追逐时光者
28 5
龙大吉
|
30天前
|
存储 缓存 监控
Docker容器性能调优的关键技巧，涵盖CPU、内存、网络及磁盘I/O的优化策略，结合实战案例，旨在帮助读者有效提升Docker容器的性能与稳定性。
本文介绍了Docker容器性能调优的关键技巧，涵盖CPU、内存、网络及磁盘I/O的优化策略，结合实战案例，旨在帮助读者有效提升Docker容器的性能与稳定性。
龙大吉
89 7
W9
|
1月前
|
运维 关系型数据库 MySQL
轻松管理Linux服务器的5个优秀管理面板
Websoft9 应用管理平台，github 2k star 开源软件，既有200+的优秀开源软件商店，一键安装。又有可视化的Linux管理面板，文件、数据库、ssl证书方便快捷管理。
W9
102 1
蓝易云
|
1月前
|
缓存 Ubuntu Linux
Linux环境下测试服务器的DDR5内存性能
通过使用 `memtester`和 `sysbench`等工具，可以有效地测试Linux环境下服务器的DDR5内存性能。这些工具不仅可以评估内存的读写速度，还可以检测内存中的潜在问题，帮助确保系统的稳定性和性能。通过合理配置和使用这些工具，系统管理员可以深入了解服务器内存的性能状况，为系统优化提供数据支持。
蓝易云
42 4
aliyun5279339750-12408
|
1月前
|
运维 监控 安全
盘点Linux服务器运维管理面板
随着云计算和大数据技术的迅猛发展，Linux服务器在运维管理中扮演着越来越重要的角色。传统的Linux服务器管理方式已经无法满足现代企业的需求，因此，高效、安全、易用的运维管理面板应运而生。
aliyun5279339750-12408
85 2
aliyun5279339750-12408
|
1月前
|
运维 监控 Linux
服务器管理面板大盘点: 8款开源面板助你轻松管理Linux服务器
在数字化时代，服务器作为数据存储和计算的核心设备，其管理效率与安全性直接关系到业务的稳定性和可持续发展。随着技术的不断进步，开源社区涌现出众多服务器管理面板，这些工具以其强大的功能、灵活的配置和友好的用户界面，极大地简化了Linux服务器的管理工作。本文将详细介绍8款开源的服务器管理面板，包括Websoft9、宝塔、cPanel、1Panel等，旨在帮助运维人员更好地选择和使用这些工具，提升服务器管理效率。
aliyun5279339750-12408
412 1
1436047922066202
|
24天前
|
存储 Oracle 安全
服务器数据恢复—LINUX系统删除/格式化的数据恢复流程
Linux操作系统是世界上流行的操作系统之一，被广泛用于服务器、个人电脑、移动设备和嵌入式系统。Linux系统下数据被误删除或者误格式化的问题非常普遍。下面北亚企安数据恢复工程师简单聊一下基于linux的文件系统（EXT2/EXT3/EXT4/Reiserfs/Xfs） 下删除或者格式化的数据恢复流程和可行性。
1436047922066202
25 0
jianz123
|
1月前
|
安全 Linux API
Linux服务器安全
人们常误认为服务器因存于数据中心且数据持续使用而无需加密。然而，当驱动器需维修或处理时，加密显得尤为重要，以防止数据泄露。Linux虽有dm-crypt和LUKS等内置加密技术，但在集中管理、根卷加密及合规性等方面仍存不足。企业应选择具备强大验证、简单加密擦除及集中管理等功能的解决方案，以弥补这些缺口。
jianz123
27 0
weixin_836869520
|
5月前
|
网络协议 安全 Java
Java中的网络编程：Socket编程详解
Java中的网络编程：Socket编程详解
weixin_836869520
65 2
聚娃科技开发者团队
|
5月前
|
网络协议 安全 Java
Java中的网络编程：Socket编程详解
Java中的网络编程：Socket编程详解
聚娃科技开发者团队
184 1

热门文章

最新文章

  • 1
    Python网络编程小示例：生成CIDR表示的IP地址范围
  • 2
    不为人知的网络编程(十九)：能Ping通，TCP就一定能连接和通信吗？
  • 3
    阿里云服务器ECS经济型e实例与通用算力u1区别、特性优势、使用场景及租赁费用对比
  • 4
    阿里云服务器租用、注册域名、备案及域名解析完整流程参考（图文教程）
  • 5
    阿里云服务器云盘类型怎么选？ESSD AutoPL、ESSD和ESSD Entry云盘区别及选择参考
  • 6
    如何把阿里云ECS里的文件下载到本地（免登录免配置）
  • 7
    使用Nginx搭建流媒体服务器
  • 8
    云服务器成本优化深度解析与实战案例
  • 9
    ChatMCP：基于 MCP 协议开发的 AI 聊天客户端，支持多语言和自动化安装 MCP 服务器
  • 10
    阿里云上快速搭建幻兽帕鲁游戏联机服务器指南
  • 1
    Kubernetes学习-集群搭建篇(二) 部署Node服务，启动JNI网络插件
    342
  • 2
    什么是网络安全等级保护测评（等保测评）？
    282
  • 3
    网络安全与信息安全：保护你的数据，保护你的世界
    52
  • 4
    网络防御前线：洞悉漏洞、加密之盾与安全意识觉醒
    41
  • 5
    探索现代网络安全的多层次防御机制
    221
  • 6
    网络安全与信息安全：防御前线的关键技术与意识觉醒
    45
  • 7
    数字堡垒的构建者：网络安全与信息安全的深层剖析
    62
  • 8
    Linux网络编程 网络基础知识
    75
  • 9
    开发板配置网络ssh登入
    77
  • 10
    网络编程知识点总结（7）
    56

    • 相关课程

    更多
  • TCP/IP 网络基础
  • 云计算工程师解析与实战-网络专家篇（体验版）
  • 云网络白皮书-阿里云网络系列课
  • 企业上云攻略-阿里云网络产品应用系列教程
  • Linux网络进阶 - TCP/IP协议及OSI七层模型
  • 网络管理者必知-2分钟了解新出台的《网络安全法》

    • 相关电子书

    更多
  • Session：更加安全、可靠的数据中心网络产品更新
  • Session：极简易用的全球化网络产品更新
  • Session：弹性、高可用、可观测的应用交付网络产品更新

    • 相关实验场景

    更多
  • Linux指令入门-文件与权限
  • Linux指令入门-系统管理
  • 使用ECS和RDS搭建个人博客
  • 利用云备份Cloud Backup实现ECS文件备份
  • 基于ECS搭建FTP服务
  • 基于ECS和NAS搭建个人网盘

    • 推荐镜像

    更多
  • mxlinux-iso
  • archlinuxarm
  • archlinuxcn
    • 下一篇
    手把手教你白嫖阿里云服务器(免费领服务器)