容器技术Linux Namespaces和Cgroups

对操作系统了解多少，仅仅敲个命令吗

  1. 操作系统虚拟化（容器技术）的发展历程

1979 年，UNIX 的第 7 个版本引入了 Chroot 特性。Chroot 现在被认为是第一个操作系统虚拟化（Operating system level virtualization）技术的原型，本质是一种操作系统文件系统层的隔离技术。

2006 年，Google 发布了在 Linux 上运行的 Process Container（进程容器）技术，其目标是提供一种类似于 Virtual Mahine（计算机虚拟化技术）的、但主要针对 Process 的操作系统级别资源限制、优先级控制、资源审计能力和进程控制能力。

2007 年，Google 推动 Process Container 代码合入 Linux Kernel。同时由于 Container 这一命名在 Kernel 具有许多不同的含义，所以为了避免代码命名的混乱，就将 Process Container 更名为了 Control Groups，简称：Cgroups。

2008 年，Linux 社区整合了 Chroot、Cgroups、Namespaces、SELinux、Seccomp 等多种技术并发布了 LXC（Linux Container）v0.1.0 版本。LXC 通过将 Cgroups 的资源配额管理能力和 Namespace 的资源视图隔离能力进行组合，实现了完备的轻量级操作系统虚拟化。

2013 年 3 月 15 日，在加利福尼亚州圣克拉拉召开的 Python 开发者大会上，DotCloud 的创始人兼首席执行官 Solomon Hvkes 在一场仅 5 分钟的微型演讲中，首次发布了基于 LXC 封装的 Docker Container，并于会后将其源码开源并托管到 Github。

图片

2.   容器的优势

传统模式的部署，直接将多个应用运行在物理服务器上，如果其中一个应用占用了大部分资源，可能会导致其他应用的性能下降。

虚拟化部署时代，可以在单个物理服务器的 CPU 上运行多个虚拟机（VM），每个 VM 是一台完整的计算机，在虚拟化硬件之上运行所有组件（包括了操作系统）。因此，可以让不同的应用在 VM 之间安全地隔离运行，更好地利用物理服务器上的资源。

容器与 VM 类似，具有自己的文件系统、CPU、内存、进程空间等，但与 VM 不同的是，容器之间共享操作系统（OS）。 所以，容器被认为是一种轻量级的操作系统层面的虚拟化技术。

相比于 VM ，轻量级的容器更适合云原生模式的实践。

 

 3.  容器的本质

容器是一种轻量级的操作系统层面的虚拟化技术。

重点是 “操作系统层面” ，即容器本质上是利用操作系统提供的功能来实现虚拟化。

容器技术的代表之作 Docker ，则是一个基于 Linux 操作系统，使用 Go 语言编写，调用了 Linux Kernel 功能的虚拟化工具。

为了更好地理解容器的本质，我们来看看容器具体使用了哪些 Linux Kernel 技术，以及在 Go 中应该如何去调用。

图片

3.1  Chroot

Chroot 是一个可供 User Process 调用的 System Call 接口，可以让一个 Process 把指定的目录作为根目录（Root Directory），随后 Process 所有的文件系统操作都只能在这个指定目录中进行。故称之为 Change Root。

chroot() 的函数原型非常简单：

  • 调用权限：Root 用户。

  • 形参列表：

    • path：一个指向字符串的指针，是一个绝对路径，表示将 Process 的根目录更改为的该目录路径。

  • 函数返回：

    • 成功：返回 0；

    • 失败：返回 -1。

#include <unistd.h>int chroot(const char *path);

需要注意的是，在更改了 Process 的根目录后，Process 只能访问新的根目录以及其子目录中的文件和资源。因此，在调用 chroot() 后，应确保 Process 所需要访问的所有文件和资源都存在于新的根目录下。

chroot() 目前主要主要用于：

安全隔离场景：限制将 Process 的访问范围，以此提高系统的安全性。

调试环境场景：创建一个与主系统隔离的环境，用于调试、测试和运行 Process。

系统救援场景：在 Linux 操作系统损坏或遭受攻击时，可以使用 chroot 将 Process 切换到受损系统的根目录中，以便进行修复和救援操作。

可见，chroot() 确实在 Linux File System（文件系统）层面提供了针对 Process 的隔离性，但并不提供完全的安全隔离，无法阻止其他方式的攻击。因此，要想实现 Processes 之间的安全隔离，还需要需采取其他安全措施。

3.2  NameSpaces

Linux Namespaces（命名空间）是一种操作系统层级的资源视图隔离技术，能够将 Linux 的全局资源，划分为 Namespace 范围内可见的资源。

由于容器之间共享 OS ，对于操作系统而言，容器的实质就是进程，多个容器运行，对应操作系统也就是运行着多个进程。

当进程运行在自己单独的命名空间时，命名空间的资源隔离可以保证进程之间互不影响，大家都以为自己身处在独立的一个操作系统里。这种进程就可以称为容器。

Namespaces 具有多种类型，基本上涵盖了构成一个操作系统所需要的基本元素：

命名空间系统调用参数作用
Mount (mnt)CLONE_NEWNS文件目录挂载隔离。用于隔离各个进程看到的挂载点视图
Process ID (pid)CLONE_NEWPID进程 ID 隔离。使每个命名空间都有自己的初始化进程，PID 为 1，作为所有进程的父进程
Network (net)CLONE_NEWNET网络隔离。使每个 net 命名空间有独立的网络设备，IP 地址，路由表，/proc/net 目录等网络资源
Interprocess Communication (ipc)CLONE_NEWIPC进程 IPC 通信隔离。让只有相同 IPC 命名空间的进程之间才可以共享内存、信号量、消息队列通信
UTSCLONE_NEWUTS主机名或域名隔离。使其在网络上可以被视作一个独立的节点而非主机上的一个进程
User ID (user)CLONE_NEWUSER用户 UID 和组 GID 隔离。例如每个命名空间都可以有自己的 root 用户
Control group (cgroup) NamespaceCLONE_NEWCGROUPCgroup 信息隔离。用于隐藏进程所属的控制组的身份，使命名空间中的 cgroup 视图始终以根形式来呈现，保障安全
Time NamespaceCLONE_NEWTIME系统时间隔离。允许不同进程查看到不同的系统时间

通过 /proc/{pid}/ns 文件可以查看指定 Process 运行在哪些 Namespaces Instance 中，并且每个 Namespace Instance 都具有一个唯一的标识。

[root@192 dongguangming]#  ls -l --time-style='+' /proc/$$/ns
total 0
lrwxrwxrwx. 1 root root 0  ipc -> ipc:[4026531839]
lrwxrwxrwx. 1 root root 0  mnt -> mnt:[4026531840]
lrwxrwxrwx. 1 root root 0  net -> net:[4026531956]
lrwxrwxrwx. 1 root root 0  pid -> pid:[4026531836]
lrwxrwxrwx. 1 root root 0  user -> user:[4026531837]
lrwxrwxrwx. 1 root root 0  uts -> uts:[4026531838]
[root@192 dongguangming]#

最终，用户可以通过创建多种不同类型的 Namespaces Instance 来提供的操作系统资源的隔离，再结合创建多种不同类型的 cgroups 来提供操作系统的资源配额，就构成了一个最基本的操作系统容器，即：Process Container。

UTS namespace

UTS namespace 为 Container 提供了 Hostname 和 Domain Name 的隔离。

Container 中的 Process 可以根据需要调用 sethostname 和 setdomainname 指令来进行配置，让每个 Container 都可以被视为网络中的一个独立的节点。

PID namespace

PID namespace 为 Container 提供了进程号的隔离。

每个 Containers 都拥有自己的进程环境，Container 的 init Process 都是 PID 1 号进程，它作为所有子进程的父进程。要想做到进程的隔离，首先需要创建出 PID 1 号进程，它具有以下特性：

  • 如果某个子进程脱离了父进程（父进程没有 wait 它），那么 init Process 就会负责回收资源并结束这个子进程。

  • 如果 init Process  被终止，那么 Kernel 就会调用 SIGKILL 终止此 PID namespace 中的所有进程。

IPC namespace

IPC namespace 为 Container 提供了 IPC（进程间）通信机制的隔离，包括信号量、消息队列、共享内存等机制。

每个 Containers 都拥有以下 /proc 文件接口：

  • /proc/sys/fs/mqueue：POSIX Message Queues 接口类型；

  • /proc/sys/kernel：System V IPC 接口类型；

  • /proc/sysvipc：System V IPC 接口类型。

Mount namespace

Mount namespace 为 Container 提供了 Filesystem 挂载点的隔离，继而实现了 VFS 的隔离。

每个 Containers 都拥有以下 /proc 文件接口，可以构成一个独立的 rootfs（Root 文件系统）：

  • /proc/[pid]/mounts

  • /proc/[pid]/mountinfo

  • /proc/[pid]/mountstats

实际上，Mount namespace 是基于 Chroot 的不断改良而开发出来的。为 Container 创建的 rootfs 只是一个操作系统发行版所包含的文件、目录和配置，并不包括 Kernel 的文件。

Network namespace

Network namespace 为 Container 提供了网络资源的隔离，包括：

  • Network devices（网络设备）

  • IPv4 and IPv6 protocol stacks（IPv4、IPv6 的协议栈）

  • IP routing tables（IP 路由表）

  • Firewall rules（防火墙规则）

  • Sockets 套接字

  • /proc/[pid]/net

  • /sys/class/net

  • /proc/sys/net

需要注意的是，同一个 Network device 只能存在于一个 Namespace Instance 中，所以常常结合虚拟网络设备来使用。

图片

User namespace

User namespace 为 Container 提供了用户权限和安全属性相关的隔离，包括：User ID、User Group ID、Root 目录以及特殊的权限。

每个 Containers 都拥有以下 /proc 文件接口：

  • /proc/[pid]/uid_map

  • /proc/[pid]/gid_map

NameSpace 的具体描述可以查看 Linux man 手册中的 namespaces(7) - Linux manual page，手册中还描述了几个 NameSpace API ，主要是和进程相关的系统调用函数。

图片

clone()
int clone(int (*fn)(void *), void *stack, int flags, void *arg, .../* pid_t *parent_tid, void *tls, pid_t *child_tid */ );

clone() 用于创建新进程，通过传入一个或多个系统调用参数（ flags 参数）可以创建出不同类型的 NameSpace ，并且子进程也将会成为这些 NameSpace 的成员。

setns()
int setns(int fd, int nstype);

setns() 用于将进程加入到一个现有的 Namespace 中。其中 fd 为文件描述符，引用 /proc/[pid]/ns/ 目录里对应的文件，nstype 代表 NameSpace 类型。

unshare()
int unshare(int flags);

unshare() 用于将进程移出原本的 NameSpace ，并加入到新创建的 NameSpace 中。同样是通过传入一个或多个系统调用参数（ flags 参数）来创建新的 NameSpace 。

ioctl()
int ioctl(int fd, unsigned long request, ...);

ioctl() 用于发现有关 NameSpace 的信息。

上面的这些系统调用函数，我们可以直接用 C 语言调用，创建出各种类型的 NameSpace ，这是最直观的做法。而对于 Go 语言，其内部已经帮我们封装好了这些函数操作，可以更方便地直接使用，降低心智负担。

先来看一个简单的小工具

package mainimport ("os""os/exec"
)func main() {switch os.Args[1] {case "run":run()default:panic("help")}
}func run() {cmd := exec.Command(os.Args[2], os.Args[3:]...)cmd.Stdin = os.Stdincmd.Stdout = os.Stdoutcmd.Stderr = os.Stderrmust(cmd.Run())
}func must(err error) {if err != nil {panic(err)}
}

 这个程序接收用户命令行传递的参数，并使用 exec.Command 运行，例如当我们执行 go run main.go run echo hello 时，会创建出 main 进程， main 进程内执行 echo hello 命令创建出一个新的 echo 进程，最后随着 echo 进程的执行完毕，main 进程也随之结束并退出。

但是上面创建的进程太快退出了，不便于我们观察。如果让 main 进程启动一个 bash 进程会怎样呢？

为了直观对比，我们先看看当前会话的进程信息。

[root@192 dongguangming]# psPID TTY          TIME CMD1407 pts/1    00:00:00 bash2057 pts/1    00:00:00 ps
[root@192 dongguangming]# echo $$
1407
[root@192 dongguangming]#

 当前我们正处于 PID 1407 的 bash 会话进程中，继续下一步操作：

[root@192 dongguangming]# go run main.go run /bin/bash
[root@192 dongguangming]# psPID TTY          TIME CMD1407 pts/1    00:00:00 bash2058 pts/1    00:00:00 go2076 pts/1    00:00:00 main2079 pts/1    00:00:00 bash2089 pts/1    00:00:00 ps
[root@192 dongguangming]# echo $$
2079
[root@192 dongguangming]# exit
exit
[root@192 dongguangming]# psPID TTY          TIME CMD1407 pts/1    00:00:00 bash2090 pts/1    00:00:00 ps
[root@192 dongguangming]# echo $$
1407
[root@192 dongguangming]#

在执行 go run main.go run /bin/bash 后，我们的会话被切换到了 PID 2709的 bash 进程中，而 main 进程也还在运行着（当前所处的 bash 进程是 main 进程的子进程，main 进程必须存活着，才能维持 bash 进程的运行）。当执行 exit 退出当前所处的 bash 进程后，main 进程随之结束，并回到原始的 PID 1407的 bash 会话进程。

我们说过，容器的实质是进程，你现在可以把 main 进程当作是 “Docker” 工具，把 main 进程启动的 bash 进程，当作一个 “容器” 。这里的 “Docker” 创建并启动了一个 “容器”。

为什么打了双引号，是因为在这个 bash 进程中，我们可以随意使用操作系统的资源，并没有做资源隔离。

要想实现资源隔离，也很简单，在 run() 函数增加 SysProcAttr 配置，先从最简单的 UTS 隔离开始，传入对应的 CLONE_NEWUTS 系统调用参数，并通过 syscall.Sethostname 设置主机名：

func run() {cmd := exec.Command(os.Args[2], os.Args[3:]...)cmd.Stdin = os.Stdincmd.Stdout = os.Stdoutcmd.Stderr = os.Stderrcmd.SysProcAttr = &syscall.SysProcAttr{Cloneflags: syscall.CLONE_NEWUTS,}must(syscall.Sethostname([]byte("mycontainer")))must(cmd.Run())
}

 

这段代码看似没什么问题，但仔细思考一下。

syscall.Sethostname 这一行到底是哪个进程在执行？main 进程还是 main 进程创建的子进程？

不用想，子进程都还没 Run 起来呢！现在调用肯定是 main 进程在执行，main 进程可没进行资源隔离，相当于直接更改宿主机的主机名了。

子进程还没 Run 起来，还不能更改主机名，等子进程 Run 起来后，又会进入到阻塞状态，无法再通过代码方式更改到子进程内的主机名。那有什么办法呢？

看来只能把 /proc/self/exe 这个神器请出来了。

在 Linux 2.2 内核版本及其之后，/proc/[pid]/exe 是对应 pid 进程的二进制文件的符号链接，包含着被执行命令的实际路径名。如果打开这个文件就相当于打开了对应的二进制文件，甚至可以通过重新输入 /proc/[pid]/exe 重新运行一个对应于 pid 的二进制文件的进程。

对于 /proc/self ，当进程访问这个神奇的符号链接时，可以解析到进程自己的 /proc/[pid] 目录。

合起来就是，当进程访问 /proc/self/exe 时，可以运行一个对应进程自身的二进制文件。

这有什么用呢？继续看下面的代码：

package mainimport ("os""os/exec""syscall"
)func main() {switch os.Args[1] {case "run":run()case "child":child()default:panic("help")}
}func run() {cmd := exec.Command("/proc/self/exe", append([]string{"child"}, os.Args[2:]...)...)cmd.Stdin = os.Stdincmd.Stdout = os.Stdoutcmd.Stderr = os.Stderrcmd.SysProcAttr = &syscall.SysProcAttr{Cloneflags: syscall.CLONE_NEWUTS,}must(cmd.Run())
}func child() {must(syscall.Sethostname([]byte("mycontainer")))cmd := exec.Command(os.Args[2], os.Args[3:]...)cmd.Stdin = os.Stdincmd.Stdout = os.Stdoutcmd.Stderr = os.Stderrmust(cmd.Run())
}func must(err error) {if err != nil {panic(err)}
}

 

在 run() 函数中，我们不再是直接运行用户所传递的命令行参数，而是运行 /proc/self/exe ，并传入 child 参数和用户传递的命令行参数。

同样当执行 go run main.go run echo hello 时，会创建出 main 进程， main 进程内执行 /proc/self/exe child echo hello 命令创建出一个新的 exe 进程，关键也就是这个 exe 进程，我们已经为其配置了 CLONE_NEWUTS 系统调用参数进行 UTS 隔离。也就是说，exe 进程可以拥有和 main 进程不同的主机名，彼此互不干扰。

进程访问 /proc/self/exe 代表着运行对应进程自身的二进制文件。因此，按照 exe 进程的启动参数，会执行 child() 函数，而 child() 函数内首先调用 syscall.Sethostname 更改了主机名（此时是 exe 进程执行的，并不会影响到 main 进程），接着和本文最开始的 run() 函数一样，再次使用 exec.Command 运行用户命令行传递的参数。

总结一下就是， main 进程创建了 exe 进程（exe 进程已经进行 UTS 隔离，exe 进程更改主机名不会影响到 main 进程）， 接着 exe 进程内执行 echo hello 命令创建出一个新的 echo 进程，最后随着 echo 进程的执行完毕，exe 进程随之结束，exe 进程结束后， main 进程再结束并退出。

图片

那经过 exe 这个中间商所创建出来的 echo 进程和之前由 main 进程直接创建的 echo 进程，两者有何不同呢。

我们知道，创建 exe 进程的同时我们传递了 CLONE_NEWUTS 标识符创建了一个 UTS NameSpace ，Go 内部帮我们封装了系统调用函数 clone() 的调用，我们也说过，由 clone() 函数创建出的进程的子进程也将会成为这些 NameSpace 的成员，所以默认情况下（创建新进程时无继续指定系统调用参数），由 exe 进程创建出的 echo 进程会继承 exe 进程的资源， echo 进程将拥有和 exe 进程相同的主机名，并且同样和 main 进程互不干扰。

因此，借助中间商 exe 进程 ，echo 进程可以成功实现和宿主机（ main 进程）资源隔离，拥有不同的主机名。

图片

再次通过启动 /bin/bash 进行验证主机名是否已经成功隔离：

[root@192 dongguangming]# hostname
192.168.0.103
[root@192 dongguangming]# touch main.go
[root@192 dongguangming]# vi main.go 
[root@192 dongguangming]# go run main.go run /bin/bash
[root@mycontainer dongguangming]# hostname
mycontainer
[root@mycontainer dongguangming]# psPID TTY          TIME CMD1407 pts/1    00:00:00 bash2112 pts/1    00:00:00 go2133 pts/1    00:00:00 main12136 pts/1    00:00:00 exe2140 pts/1    00:00:00 bash2150 pts/1    00:00:00 ps
[root@mycontainer dongguangming]# exit
exit
[root@192 dongguangming]# hostname
192.168.0.103
[root@192 dongguangming]#

 当执行 go run main.go run /bin/bash 时，我们也可以在另一个 ssh 会话中，使用 ps afx 查看bash 会话进程的层次信息：

以此类推，新增资源隔离只要继续传递指定的系统调用参数即可：

package mainimport ("fmt""os""os/exec""syscall"
)func main() {switch os.Args[1] {case "run":run()case "child":child()default:panic("help")}
}func run() {fmt.Println("[main]", "pid:", os.Getpid())cmd := exec.Command("/proc/self/exe", append([]string{"child"}, os.Args[2:]...)...)cmd.Stdin = os.Stdincmd.Stdout = os.Stdoutcmd.Stderr = os.Stderrcmd.SysProcAttr = &syscall.SysProcAttr{Cloneflags: syscall.CLONE_NEWUTS |syscall.CLONE_NEWPID |syscall.CLONE_NEWNS,Unshareflags: syscall.CLONE_NEWNS,}must(cmd.Run())
}func child() {fmt.Println("[exe]", "pid:", os.Getpid())must(syscall.Sethostname([]byte("mycontainer")))must(os.Chdir("/"))must(syscall.Mount("proc", "proc", "proc", 0, ""))cmd := exec.Command(os.Args[2], os.Args[3:]...)cmd.Stdin = os.Stdincmd.Stdout = os.Stdoutcmd.Stderr = os.Stderrmust(cmd.Run())must(syscall.Unmount("proc", 0))
}func must(err error) {if err != nil {panic(err)}
}

 

Cloneflags 参数新增了 CLONE_NEWPID 和 CLONE_NEWNS 分别隔离进程 pid 和文件目录挂载点视图，Unshareflags: syscall.CLONE_NEWNS 则是用于禁用挂载传播（如果不设置该参数，container 内的挂载会共享到 host ，挂载传播不在本文的探讨范围内）。

当我们创建 PID Namespace 时，exe 进程包括其创建出来的子进程的 pid 已经和 main 进程隔离了，这一点可以通过打印 os.Getpid() 结果或执行 echo $$ 命令得到验证。但此时还不能使用 ps 命令查看，因为 ps 和 top 等命令会使用 /proc 的内容，所以我们才继续引入了 Mount Namespace ，并在 exe 进程挂载 /proc 目录。

[root@192 dongguangming]# psPID TTY          TIME CMD1407 pts/1    00:00:00 bash2195 pts/1    00:00:00 ps
[root@192 dongguangming]# echo $$
1407
[root@192 dongguangming]# go run main.go run /bin/bash
[main] pid: 2217
[exe] pid: 1
[root@mycontainer /]# psPID TTY          TIME CMD1 pts/1    00:00:00 exe4 pts/1    00:00:00 bash13 pts/1    00:00:00 ps
[root@mycontainer /]#  echo $$
4
[root@mycontainer /]# exit
exit
[root@192 dongguangming]#

通过 /proc/{pid}/ns 文件可以查看指定 Process 运行在哪些 Namespaces Instance 中，并且每个 Namespace Instance 都具有一个唯一的标识。

此时，exe 作为初始化进程，pid 为 1 ，创建出了 pid 4 的 bash 子进程，而且已经看不到 main 进程了。

剩下的 IPC 、NET、 USER 等 NameSpace 就不在本文一一展示了。

3.3  Cgroups

借助 NameSpace 技术可以帮进程隔离出自己单独的空间，成功实现出最简容器。但是怎样限制这些空间的物理资源开销（CPU、内存、存储、I/O 等）就需要利用 Cgroups 技术了。

限制容器的资源使用，是一个非常重要的功能，如果一个容器可以毫无节制的使用服务器资源，那便又回到了传统模式下将应用直接运行在物理服务器上的弊端。这是容器化技术不能接受的。

Cgroups 的全称是 Control groups 即控制组，最早是由 Google 的工程师（主要是 Paul Menage 和 Rohit Seth）在 2006 年发起，一开始叫做进程容器（process containers）。在 2007 年时，因为在 Linux Kernel 中，容器（container）这个名词有许多不同的意义，为避免混乱，被重命名为 cgroup ，并且被合并到 2.6.24 版本的内核中去。

Cgroups 是对进程分组管理的一种机制，提供了对一组进程及它们的子进程的资源限制、控制和统计的能力，并为每种可以控制的资源定义了一个 subsystem （子系统）的方式进行统一接口管理，因此 subsystem 也被称为 resource controllers （资源控制器）。

几个主要的 subsystem 如下（ Cgroups V1 ）：

子系统作用
cpu限制进程的 cpu 使用率
cpuacct统计进程的 cpu 使用情况
cpuset在多核机器上为进程分配单独的 cpu 节点或者内存节点（仅限 NUMA 架构）
memory限制进程的 memory 使用量
blkio控制进程对块设备（例如硬盘） io 的访问
devices控制进程对设备的访问
net_cls标记进程的网络数据包，以便可以使用 tc 模块（traffic control）对数据包进行限流、监控等控制
net_prio控制进程产生的网络流量的优先级
freezer挂起或者恢复进程
pids限制 cgroup 的进程数量
更多子系统参考 Linux man cgroups[3]文档https://man7.org/linux/man-pages/man7/cgroups.7.html

借助 Cgroups 机制，可以将一组进程（task group）和一组 subsystem 关联起来，达到控制进程对应关联的资源的能力。如图：

图片

Cgroups 的层级结构称为 hierarchy （即 cgroup 树），是一棵树，由 cgroup 节点组成。

系统可以有多个 hierarchy ，当创建新的 hierarchy 时，系统所有的进程都会加入到这个 hierarchy 默认创建的 root cgroup 根节点中，在树中，子节点可以继承父节点的属性。

对于同一个 hierarchy，进程只能存在于其中一个 cgroup 节点中。如果把一个进程添加到同一个 hierarchy 中的另一个 cgroup 节点，则会从第一个 cgroup 节点中移除。

hierarchy 可以附加一个或多个 subsystem 来拥有对应资源（如 cpu 和 memory ）的管理权，其中每一个 cgroup 节点都可以设置不同的资源限制权重，而进程（ task ）则绑定在 cgroup 节点中，并且其子进程也会默认绑定到父进程所在的 cgroup 节点中。

基于 Cgroups 的这些运作原理，可以得出：如果想限制某些进程的内存资源，就可以先创建一个 hierarchy ，并为其挂载 memory subsystem ，然后在这个 hierarchy 中创建一个 cgroup 节点，在这个节点中，将需要控制的进程 pid 和控制属性写入即可。

接下来我们就来实践一下。

Linux 一切皆文件。

在 Linux Kernel 中，为了让 Cgroups 的配置更直观，使用了目录的层级关系来模拟 hierarchy ，以此通过虚拟的树状文件系统的方式暴露给用户调用。

创建一个 hierarchy ，并为其挂载 memory subsystem ，这一步我们可以跳过，因为系统已经默认为每个 subsystem 创建了一个默认的 hierarchy ，我们可以直接使用。

例如 memory subsystem 默认的 hierarchy 就在 /sys/fs/cgroup/memory 目录。

[root@host go]# mount | grep memory
cgroup on /sys/fs/cgroup/memory type cgroup (rw,nosuid,nodev,noexec,relatime,memory)
[root@host go]# cd /sys/fs/cgroup/memory
[root@host memory]# pwd
/sys/fs/cgroup/memory
[root@host memory]#

只要在这个 hierarchy 目录下创建一个文件夹，就相当于创建了一个 cgroup 节点：

[root@host memory]# mkdir hello
[root@host memory]# cd hello/
[root@host hello]# ls
cgroup.clone_children           memory.kmem.slabinfo                memory.memsw.failcnt             memory.soft_limit_in_bytes
cgroup.event_control            memory.kmem.tcp.failcnt             memory.memsw.limit_in_bytes      memory.stat
cgroup.procs                    memory.kmem.tcp.limit_in_bytes      memory.memsw.max_usage_in_bytes  memory.swappiness
memory.failcnt                  memory.kmem.tcp.max_usage_in_bytes  memory.memsw.usage_in_bytes      memory.usage_in_bytes
memory.force_empty              memory.kmem.tcp.usage_in_bytes      memory.move_charge_at_immigrate  memory.use_hierarchy
memory.kmem.failcnt             memory.kmem.usage_in_bytes          memory.numa_stat                 notify_on_release
memory.kmem.limit_in_bytes      memory.limit_in_bytes               memory.oom_control               tasks
memory.kmem.max_usage_in_bytes  memory.max_usage_in_bytes           memory.pressure_level
[root@host hello]#

其中我们创建的 hello 文件夹内的所有文件都是系统自动创建的。常用的几个文件功能如下：

文件名功能
taskscgroup 中运行的进程（ PID）列表。将 PID 写入一个 cgroup 的 tasks 文件，可将此进程移至该 cgroup
cgroup.procscgroup 中运行的线程群组列表（ TGID ）。将 TGID 写入 cgroup 的 cgroup.procs 文件，可将此线程组群移至该 cgroup
cgroup.event_controlevent_fd() 的接口。允许 cgroup 的变更状态通知被发送
notify_on_release用于自动移除空 cgroup 。默认为禁用状态（0）。设定为启用状态（1）时，当 cgroup 不再包含任何任务时（即，cgroup 的 tasks 文件包含 PID，而 PID 被移除，致使文件变空），kernel 会执行 release_agent 文件（仅在 root cgroup 出现）的内容，并且提供通向被清空 cgroup 的相关路径（与 root cgroup 相关）作为参数
memory.usage_in_bytes显示 cgroup 中进程当前所用的内存总量（以字节为单位）
memory.memsw.usage_in_bytes显示 cgroup 中进程当前所用的内存量和 swap 空间总和（以字节为单位）
memory.max_usage_in_bytes显示 cgroup 中进程所用的最大内存量（以字节为单位）
memory.memsw.max_usage_in_bytes显示 cgroup 中进程的最大内存用量和最大 swap 空间用量（以字节为单位）
memory.limit_in_bytes设定用户内存（包括文件缓存）的最大用量
memory.memsw.limit_in_bytes设定内存与 swap 用量之和的最大值
memory.failcnt显示内存达到 memory.limit_in_bytes 设定的限制值的次数
memory.memsw.failcnt显示内存和 swap 空间总和达到 memory.memsw.limit_in_bytes 设定的限制值的次数
memory.oom_control可以为 cgroup 启用或者禁用“内存不足”（Out of Memory，OOM） 终止程序。默认为启用状态（0），尝试消耗超过其允许内存的任务会被 OOM 终止程序立即终止。设定为禁用状态（1）时，尝试使用超过其允许内存的任务会被暂停，直到有额外内存可用。
更多文件的功能说明可以查看 kernel 文档中的 cgroup-v1/memory[4]https://www.kernel.org/doc/Documentation/cgroup-v1/memory.txt

在这个 hello cgroup 节点中，我们想限制某些进程的内存资源，只需将对应的进程 pid 写入到 tasks 文件，并把内存最大用量设定到 memory.limit_in_bytes 文件即可。

[root@host hello]# cat memory.oom_control
oom_kill_disable 0
under_oom 0
[root@host hello]# cat memory.failcnt
0
[root@host hello]# echo 100M > memory.limit_in_bytes
[root@host hello]# cat memory.limit_in_bytes
104857600
[root@host hello]#

hello cgroup 节点默认启用了 OOM 终止程序，因此，当有进程尝试使用超过可用内存时会被立即终止。查询 memory.failcnt 可知，目前还没有进程内存达到过设定的最大内存限制值。

我们已经设定了 hello cgroup 节点可使用的最大内存为 100M ，此时新启动一个 bash 会话进程并将其移入到 hello cgroup 节点中：

[root@host hello]# /bin/bash
[root@host hello]# echo $$
4123
[root@host hello]# cat tasks
[root@host hello]# echo $$ > tasks
[root@host hello]# cat tasks
4123
4135
[root@host hello]# cat memory.usage_in_bytes
196608
[root@host hello]#

后续在此会话进程所创建的子进程都会加入到该 hello cgroup 节点中（例如 pid 4135 就是由于执行 cat 命令而创建的新进程，被系统自动加入到了 tasks 文件中）。

同样篇幅问题，剩下的 subsystem 也不在本文一一展示了。

其实到这里，我们已经通过 NameSpace 技术帮进程隔离出自己单独的空间，并使用 Cgroups 技术限制和监控这些空间的资源开销，这种特殊的进程就是容器的本质。

4. Docker 对 Cgroups 和 Namespaces 的应用

当我们创建了一个 Docker Container 之后就可以查看这个 Container 所具有的 cgroups 和 namespaces 了。

  1. 查看 Container 的 ID（cfca1212d140）和 PID（2240）配置。

$ docker ps
CONTAINER ID   IMAGE                   COMMAND   CREATED         STATUS       PORTS     NAMES
cfca1212d140   centos:centos7.9.2009   "bash"    18 months ago   Up 2 hours             vim-ide$ docker inspect --format='{{.State.Pid}}' cfca1212d140
2240

  1. 查看 Container 的 cgroups 配置。

$ ll /sys/fs/cgroup/memory/docker/
总用量 0
drwxr-xr-x. 2 root root 0 6月   2 03:40 cfca1212d1407a89632a439e974e246d1f6edd0bbef9079f06addf2613e1d46f$ cat /sys/fs/cgroup/memory/docker/cfca1212d1407a89632a439e974e246d1f6edd0bbef9079f06addf2613e1d46f/cgroup.procs 
2240$ cat /sys/fs/cgroup/memory/docker/cfca1212d1407a89632a439e974e246d1f6edd0bbef9079f06addf2613e1d46f/memory.limit_in_bytes
9223372036854771712

  1. 查看 Container 的 namespaces 配置。

$ ls -l --time-style='+' /proc/2240/ns
总用量 0
lrwxrwxrwx. 1 root root 0  ipc -> ipc:[4026532433]
lrwxrwxrwx. 1 root root 0  mnt -> mnt:[4026532431]
lrwxrwxrwx. 1 root root 0  net -> net:[4026531956]
lrwxrwxrwx. 1 root root 0  pid -> pid:[4026532434]
lrwxrwxrwx. 1 root root 0  user -> user:[4026531837]
lrwxrwxrwx. 1 root root 0  uts -> uts:[4026532432]

 

总结

其实容器的底层原理并不难，本质上就是一个特殊的进程，特殊在为其创建了 NameSpace 隔离运行环境，用 Cgroups 为其控制了资源开销，这些都是站在 Linux 操作系统的肩膀上实现的，包括 Docker 的镜像实现也是利用了 UnionFS 的分层联合技术。

参考：

  1. Linux Namespace和Cgroup  Linux Namespace和Cgroup - Linux程序员 - SegmentFault 思否

  2. linux namespace and cgroup linux namespace and cgroup - 掘金

  3. Linux Namespace 入门系列：Namespace API Linux Namespace 入门系列：Namespace API - 知乎

  4. Docker 工作原理及容器化简易指南 http://dockone.io/article/8788

  5. 昨天有读者说他不会 docker，今天就给你肝出来了 https://mp.weixin.qq.com/s?__biz=MzU2NDg0OTgyMA==&mid=2247492639&idx=1&sn=ac607fbbe221e50c24db1a7ccb12518b

  6. Docker 系列：核心原理和实现(2) Docker 系列：核心原理和实现(2) | 郭宁的个人博客

  7. What Are Linux Namespaces and What Are They Used for? What Are Linux Namespaces and What Are They Used for?

  8. namespaces(7) — Linux manual page namespaces(7) - Linux manual page

  9. 极好 A deep dive into Linux namespaces A deep dive into Linux namespaces – Chord Simple

  10. Linux – cgroup & namespace Linux – cgroup & namespace – Benjr.tw

  11. cgroup_namespaces(7) — Linux manual pages  https://manpages.courier-mta.org/htmlman7/cgroup_namespaces.7.html

  12. Overview of Linux Namespace  Linux namespaces pid,network,mount,ipc,uts,user,cgroup

  13. Container and Cgroups https://enqueuezero.com/container-and-cgroups.html

  14. Everything You Need to Know about Linux Containers, Part I: Linux Control Groups and Process Isolation  Everything You Need to Know about Linux Containers, Part I: Linux Control Groups and Process Isolation | Linux Journal

  15. Anatomy of a Container: Namespaces, cgroups & Some Filesystem Magic - LinuxConf https://www.slideshare.net/jpetazzo/anatomy-of-a-container-namespaces-cgroups-some-filesystem-magic-linuxcon

  16. What even is a container: namespaces and cgroups What even is a container: namespaces and cgroups

  17. https://events.static.linuxfound.org/sites/events/files/slides/cgroup_and_namespaces.pdf
  18. Resource management: Linux kernel Namespaces and cgroups  https://sites.cs.ucsb.edu/~rich/class/cs293b-cloud/papers/lxc-namespace.pdf，http://www.haifux.org/lectures/299/netLec7.pdf

  19. #14 - Introduction to Linux Control Groups (Cgroups)

    Introduction to Linux Control Groups (Cgroups)

  20. Control Group v2 https://www.kernel.org/doc/Documentation/cgroup-v2.txt

  21. Docker 背后的内核知识——cgroups 资源限制 Docker背后的内核知识——cgroups资源限制_语言 & 开发_孙健波_InfoQ精选文章

  22. 在Linux中使用namespace和cgroup实现进程的资源隔离和限制 在Linux中使用namespace和cgroup实现进程的资源隔离和限制 | 滩之南

  23. CGroup Namespaces https://lwn.net/Articles/618873/

  24. CGroup 介绍、应用实例及原理描述 IBM Developer

  25. Restricting process CPU usage using nice, cpulimit, and cgroups Restricting process CPU usage using nice, cpulimit, and cgroups | Scout APM Blog

  26. Docker DCA – Linux Namespaces and cgroups

    Docker DCA - Linux Namespaces and cgroups - buildVirtual

  27. Demystifying Containers - Part I: Kernel Space https://medium.com/@saschagrunert/demystifying-containers-part-i-kernel-space-2c53d6979504

  28. Containers: Namespaces and Dockers http://www.i3s.unice.fr/~urvoy/docs/VICC/1_2_vicc.pdf

  29. Docker Namespace and Cgroups https://medium.com/@kasunmaduraeng/docker-namespace-and-cgroups-dece27c209c7

  30. Understanding Linux Container Scheduling  Understanding Linux Container Scheduling — Squarespace / Engineering

  31. Linux Container Primitives: PID and Network Namespaces - SCHUTZWERK Linux Container Primitives: PID and Network Namespaces - SCHUTZWERK

  32. Containers: cgroups, Linux kernel namespaces, ufs, Docker, and intro to Kubernetes pods Containers: cgroups, Linux kernel namespaces, ufs, Docker, and intro to Kubernetes pods - IBM MediaCenter

  33. Container Creation Using Namespaces and Bash Container Creation Using Namespaces and Bash | Nicolas Mesa

  34. Linux containers in 500 lines of code Linux containers in 500 lines of code

  35. Linux Container Primitives: cgroups, namespaces, and more! https://www.youtube.com/watch?v=x1npPrzyKfs

  36. Container Creation Using Namespaces and Bash  Container Creation Using Namespaces and Bash | Nicolas Mesa

  37. Containers from Scratch Containers from Scratch | posts

  38. Hands on Linux sandbox with namespaces and cgroups https://blogs.rdoproject.org/2015/08/hands-on-linux-sandbox-with-namespaces-and-cgroups/

  39. How to run Docker containers using common Linux tools (without Docker)  unshare – I Learned How To…

  40. Understanding containers (Part 1/3) Understanding containers (Part 1/3) – Bibi's blog

  41. Docker 学习笔记10 容器技术原理 PID Namespace Docker 学习笔记10 容器技术原理 PID Namespace | 码农家园

  42. Understanding Linux containers  Containers explained: What they are and why you should care

  43. runc source code——bootstrap分析2 runc source code——bootstrap分析2 – freesky-edward

  44. Demystifying Containers – Part I: Kernel Space Demystifying Containers - Part I: Kernel Space | SUSE Communities

  45. Linux Namespaces  Linux Namespaces

  46. Containerization Mechanisms: Namespaces Containerization Mechanisms: Namespaces - Selectel Blog

  47. Runc 容器初始化和容器逃逸 Runc 容器初始化和容器逃逸_Linux云计算网络-商业新知

  48. chroot, cgroups and namespaces — An overview https://itnext.io/chroot-cgroups-and-namespaces-an-overview-37124d995e3d

  49. Everything You Need to Know about Linux Containers, Part I: Linux Control Groups and Process Isolation Everything You Need to Know about Linux Containers, Part I: Linux Control Groups and Process Isolation | Linux Journal

  50. Namespaces and Cgroups – the basis of Linux Containers  Meetup - We are what we do
  51. LXC, Cgroups and Advanced Linux Container Technology Lecture http://www.novell.com/feeds/nih/wp-content/uploads/2012/05/SUS15_lec.pdf
  52. Linux Containers https://www.cl.cam.ac.uk/~lc525/files/Linux_Containers.pdf

  53. Linux Container Primitives: cgroups, namespaces, and more! (LinuxFest Northwest 2019)

    https://speakerdeck.com/samuelkarp/linux-container-primitives-cgroups-namespaces-and-more-linuxfest-northwest-2019

  54. Container Performance Analysis  http://www.brendangregg.com/Slides/LISA2017_Container_Performance_Analysis.pdf

  55. Understanding cgroups https://www.grant.pizza/blog/understanding-cgroups/

  56. cgroups  cgroups - ArchWiki

  57. Understanding Linux Container Scheduling Understanding Linux Container Scheduling — Squarespace / Engineering

  58. Understanding Linux Container Scheduling Understanding Linux Container Scheduling — Kevin Lynch

  59. Linux Kernel Isolation Features From the Frog's mouth - JFrog Blog

  60. Introduction to Linux Containers Introduction to Linux Containers | CloudNativeLab

  61. All things Linux containers containerz.info

  62. src/syscall/exec_linux.go - The Go Programming Language https://golang.org/src/syscall/exec_linux.go

 

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mzph.cn/news/64189.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

QT基础教程之七Qt消息机制和事件

QT基础教程之七Qt消息机制和事件

QT基础教程之七Qt消息机制和事件 事件 事件&#xff08;event&#xff09;是由系统或者 Qt 本身在不同的时刻发出的。当用户按下鼠标、敲下键盘&#xff0c;或者是窗口需要重新绘制的时候&#xff0c;都会发出一个相应的事件。一些事件在对用户操作做出响应时发出&#xff0c…
阅读更多...
【面经】字节测开实习岗面试题分享

【面经】字节测开实习岗面试题分享

1、自我介绍 2、为什么投了字节&#xff1f; 公司声誉&#xff1a;字节跳动是一家知名的科技公司&#xff0c;在互联网行业享有很高的声誉。 发展前景&#xff1a;字节跳动的业务涵盖了多个领域&#xff0c;包括短视频、资讯、教育等。这意味着您将有机会接触到不同的产品和…
阅读更多...
C++通过JNI调用JAVA方法返回ArrayList对象

C++通过JNI调用JAVA方法返回ArrayList对象

运行效果: JAVA实现: 获取系统已安装应用列表并返回List<String>对象 //使用系统API获取安装包列表public List<String> getAppList(MainActivity act) {List<String> packages = new ArrayList<String>();try {//取包信息列表List<PackageInf…
阅读更多...
计算机网络 概述部分

计算机网络 概述部分

目录 计算机网络在信息时代的作用 计算机网络的重要特征 网络&#xff0c;internet,Internet的区别 局域网 广域网的区别 网络协议的分层 计算机网络在信息时代的作用 计算机网络的重要特征 连通性&#xff1a;彼此联通&#xff0c;交换信息 共享性&#xff1a;信息共享…
阅读更多...
Java实现根据关键词搜索当当商品列表数据方法，当当API接口申请指南

Java实现根据关键词搜索当当商品列表数据方法，当当API接口申请指南

要通过当当网的API获取商品列表数据&#xff0c;您可以使用当当开放平台提供的接口来实现。以下是一种使用Java编程语言实现的示例&#xff0c;展示如何通过当当开放平台API获取商品列表&#xff1a; 首先&#xff0c;确保您已注册成为当当开放平台的开发者&#xff0c;并创建…
阅读更多...
老程序员教你如何笑对问题，轻松培养逻辑思考和解决问题的能力

老程序员教你如何笑对问题，轻松培养逻辑思考和解决问题的能力

原文链接 ​​​​​​​老程序员教你如何笑对问题&#xff0c;轻松培养逻辑思考和解决问题的能力 故事发生在一个阳光明媚的午后&#xff0c;我们的主人公&#xff0c;老李&#xff0c;一位拥有十年工作经验的 Python 老程序员&#xff0c;正悠哉地在喝着咖啡。 这时&#x…
阅读更多...
扫盲：常用NoSQL数据库

扫盲：常用NoSQL数据库

前言 关系型数据库产品很多&#xff0c;如 MySQL、Oracle、Microsoft SQL Sever 等&#xff0c;但它们的基本模型都是关系型数据模型。 非关系型数据库又称为&#xff1a;NoSQL &#xff0c;没有统一的模型&#xff0c;而且是非关系型的。 常见的 NoSQL 数据库包括键值数据库、…
阅读更多...
python unitest自动化框架

python unitest自动化框架

以下举一个最简单的unitest实例&#xff0c;包含备注&#xff0c;自己拉取代码运行一次就知道原理了 import unittest import osclass TestSample(unittest.TestCase):classmethoddef setUpClass(cls) -> None:print(整个测试类只执行一次)def setUp(self) -> None:prin…
阅读更多...
Prometheus+grafana安装配置

Prometheus+grafana安装配置

Prometheus安装配置 Prometheus下载地址 官方地址&#xff1a;Download | Prometheus 可根据系统版本下载想要的安装包&#xff0c;复制链接地址 wget https://github.com/prometheus/prometheus/releases/download/v2.33.3/prometheus-2.33.3.linux-amd64.tar.gzwg 解压pr…
阅读更多...
系列五、Java操作RocketMQ简单消息之同步消息

系列五、Java操作RocketMQ简单消息之同步消息

一、概述 同步消息的特征是消息发出后会有一个返回值&#xff0c;即RocketMQ服务器收到消息后的一个确认&#xff0c;这种方式非常安全&#xff0c;但是性能上却没有那么高&#xff0c;而且在集群模式下&#xff0c;也是要等到所有的从机都复制了消息以后才会返回&#xff0c;适…
阅读更多...
【链表OJ 10】环形链表Ⅱ(求入环节点)

【链表OJ 10】环形链表Ⅱ(求入环节点)

前言: &#x1f4a5;&#x1f388;个人主页:​​​​​​Dream_Chaser&#xff5e; &#x1f388;&#x1f4a5; ✨✨刷题专栏:http://t.csdn.cn/UlvTc ⛳⛳本篇内容:力扣上链表OJ题目 目录 leetcode142. 环形链表 II 1.问题描述 2.代码思路 3.问题分析 leetcode142. 环形链…
阅读更多...
04、添加 com.fasterxml.jackson.dataformat -- jackson-dataformat-xml 依赖报错

04、添加 com.fasterxml.jackson.dataformat -- jackson-dataformat-xml 依赖报错

Correct the classpath of your application so that it contains a single, compatible version of com.fasterxml.jackson.dataformat.xml.XmlMapper 解决&#xff1a; 改用其他版本&#xff0c;我没写版本号&#xff0c;springboot自己默认的是 2.11.4 版本 成功启动项目…
阅读更多...
Vulnhub: Ragnar Lothbrok: 1靶机

Vulnhub: Ragnar Lothbrok: 1靶机

kali&#xff1a;192.168.111.111 靶机&#xff1a;192.168.111.226 信息收集 端口扫描 nmap -A -sC -v -sV -T5 -p- --scripthttp-enum 192.168.111.226 作者提示修改hosts文件 目录爆破 gobuster dir -u http://armbjorn -w /usr/share/wordlists/dirbuster/directory-l…
阅读更多...
Java自定义异常

Java自定义异常

Java标准库定义的常用异常包括&#xff1a; 当我们在代码中需要抛出异常时&#xff0c;尽量使用JDK已定义的异常类型。例如&#xff0c;参数检查不合法&#xff0c;应该抛出IllegalArgumentException&#xff1a; static void process1(int age) {if (age < 0) {throw new…
阅读更多...
mysql中的with

mysql中的with

概念 WITH 子句是 MySQL 中的一种 SQL 结构&#xff0c;又称为 Common Table Expression (CTE)。它在不影响原有 SQL 语句的情况下&#xff0c;允许开发人员临时创建一个内存中的结果集&#xff0c;然后对其进行操作。 作用 WITH 子句的主要用途是创建一个暂时的结果集&…
阅读更多...
2023高教社杯数学建模思路 - 案例：ID3-决策树分类算法

2023高教社杯数学建模思路 - 案例：ID3-决策树分类算法

文章目录 0 赛题思路1 算法介绍2 FP树表示法3 构建FP树4 实现代码 建模资料 0 赛题思路 &#xff08;赛题出来以后第一时间在CSDN分享&#xff09; https://blog.csdn.net/dc_sinor?typeblog 1 算法介绍 FP-Tree算法全称是FrequentPattern Tree算法&#xff0c;就是频繁模…
阅读更多...
响应式图片与 CSS image-set

响应式图片与 CSS image-set

响应式图片 前置知识 art direction problem光栅图像与矢量图像 raster image and vector images img 能否担此重任 sizessrcset实际看一看 picture: img 的好姐妹 source实际看一看 CSS image-set 语法兼容性 其他注意事项 响应式图片 图片在网页中占据了 超过 60% 的浏览带…
阅读更多...
基于微信小程序的汽车租赁系统的设计与实现ljx7y

基于微信小程序的汽车租赁系统的设计与实现ljx7y

汽车租赁系统&#xff0c;主要包括管理员、用户二个权限角色&#xff0c;对于用户角色不同&#xff0c;所使用的功能模块相应不同。本文从管理员、用户的功能要求出发&#xff0c;汽车租赁系统系统中的功能模块主要是实现管理员后端&#xff1b;首页、个人中心、汽车品牌管理、…
阅读更多...
SAP_ABAP_OLE_EXCEL批导案例

SAP_ABAP_OLE_EXCEL批导案例

SAP ABAP顾问能力模型梳理_企业数字化建设者的博客-CSDN博客SAP Abap顾问能力模型https://blog.csdn.net/java_zhong1990/article/details/132469977 一、OLE_EXCEL批导 1.1 下载按钮 1.2 选择EXCEL上传&#xff0c;解析EXCLE数据&#xff0c; Call屏幕。 1.3 实现效果 1.4…
阅读更多...
数据结构——哈希表

数据结构——哈希表

哈希表 这里没有讲哈希表底层的概念&#xff0c;什么转红黑树&#xff0c;什么链表的&#xff0c;这篇文章主要讲的是如何用C实现哈希表&#xff0c;以及哈希表的基本概念。后面我会出一篇文章来讲C中hashmap中的底层逻辑的知识。 哈希表的概念 哈希表是一种数据结构&#xff0…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023