-
Notifications
You must be signed in to change notification settings - Fork 1
/
index.xml
378 lines (298 loc) · 35.1 KB
/
index.xml
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
<?xml version="1.0" encoding="utf-8" standalone="yes"?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom">
<channel>
<title>Anonymous' Blog</title>
<link>https://huweicai.com/</link>
<description>Recent content on Anonymous' Blog</description>
<generator>Hugo -- gohugo.io</generator>
<language>zn-Hans</language>
<lastBuildDate>Sun, 30 Jun 2024 01:26:00 +0800</lastBuildDate><atom:link href="https://huweicai.com/index.xml" rel="self" type="application/rss+xml" />
<item>
<title>动态链接函数调用是如何实现的</title>
<link>https://huweicai.com/dynamic-linking/</link>
<pubDate>Sun, 30 Jun 2024 01:26:00 +0800</pubDate>
<guid>https://huweicai.com/dynamic-linking/</guid>
<description>函数链接 根据函数在编译期间的链接方式， 我们可以将函数分为三种： 直接调用（Direct Call）：这是最直接的一种方式，函数地址在编译时就已经确定，调用时直接跳转到目标地址。 静态链接（Static Linking）：在编译时将库与程序合并，尽管在单个编译单元内不确定函数的具体地址，但在链接阶段会解析所有符号，最终生成的可执行文件包含所有必要的代码，无需依赖外部库。 动态链接（Dynamic Linking</description>
</item>
<item>
<title>C/C++ & Python 融合之道</title>
<link>https://huweicai.com/c-with-python-intercall/</link>
<pubDate>Mon, 29 Jan 2024 09:50:00 +0800</pubDate>
<guid>https://huweicai.com/c-with-python-intercall/</guid>
<description>Python 解释器 正如软件系统通常分为定义与实现两部分，编程语言也是。 比如 C++ 标准是由国际标准化组织 ( ISO ) 下属的 ISO/IEC JTC1/SC22/WG21特别工作组制定的，最新标准为 C++ 20 (ISO/IEC 14882:2020)，这是定义；而其实现则有 GNU 的 gcc、微软的 visual c++、Apple 发起的 clang 等等，任何人都可以按照定义去实现自己的实现。 Java 规范则是由 Oracle 主导的 JCP 所制定，有 Oracle Java SE、OpenJDK、Corretto、AdoptOpen 等大量</description>
</item>
<item>
<title>Executable and Linkable Format</title>
<link>https://huweicai.com/elf/</link>
<pubDate>Sat, 07 Oct 2023 13:58:00 +0800</pubDate>
<guid>https://huweicai.com/elf/</guid>
<description>ELF Executable and Linkable Format，可执行与可链接格式，其一个很熟悉的身份就是 Linux 操作系统的标准可执行文件格式，在 Linux 上运行我们编写的代码时，就需要将其编译成 ELF 格式。 另外它还定义了共享库和核心转储文件的结构和布局。 ELF 文件格式在操作系统中起着重要的作用，它使得我们编写的代码能够被正确地编译、链接和执行。 此外，部分 Unix 系统，如: Solaris、FreeBSD 等也采用 ELF 作为其可执行文件格式。 ELF 文件格式被设计为可扩展和灵活的</description>
</item>
<item>
<title>很快的共享内存</title>
<link>https://huweicai.com/shared-memory/</link>
<pubDate>Tue, 08 Aug 2023 13:42:00 +0800</pubDate>
<guid>https://huweicai.com/shared-memory/</guid>
<description>WHY 共享内存 进程间通信有许多种方式，不同的场景有不同的选择。 当通信内容非常简单的时候，可以考虑信号、信号量甚至 flock() 这种最基础的通信方式。 当需要传递不仅仅是信号这种规模的数据时，可以考虑 FIFO、MQ 等内核 API，也非常的简单易用 。 当我们的传输内容再进一步复杂，需要用“协议”去抽象这种复杂度的时候，Unix Domain Socket 会是一个不错的选择，比如常见的 gRPC over UDS；或者牺牲一点网络栈开销，直接使用基于 TCP / UDP 的 Socket 也非常</description>
</item>
<item>
<title>Linux Kernel Debug Tips</title>
<link>https://huweicai.com/kernel-debug-tips_en/</link>
<pubDate>Tue, 17 Jan 2023 00:00:00 +0800</pubDate>
<guid>https://huweicai.com/kernel-debug-tips_en/</guid>
<description>Kernel Kernel undertakes the core Operating System job, which is the foundation of the current software ecosystem.
So, knowing more about how the kernel works will contribute to the construction of our user mode system.
The best method to learn software code is debugging while watching, software = code + data, know more about the runtime data while learning code can help us understand it better.
However the Kernel is not a normal software system, we can&rsquo;t add breakpoint and debug it through IDE debug button like other normal software, though we can implement it by kgdb + QEMU, it&rsquo; still too heavy, and not available for online systems.
This article shares two lightweight kernel debugging tips, helps us observing it runtime status rapidly.
Kernel Module Usally, our codes are runing in user mode. In Linux operating systems, the instruction of user mode program will run in level Ring 3 , they do not have the permission to acces the data in level Ring 0 high memory address space, which means that they can&rsquo;t snoop the data inside Kernel.
In that case, why not try to run our code inside the Kernel?
It&rsquo;s possible to edit the source code of kernel, adding log to print the information we concerned, but it&rsquo;s a long tedious step.</description>
</item>
<item>
<title>CubeFS&Kubernetes实践</title>
<link>https://huweicai.com/cubefs-with-kubernetes/</link>
<pubDate>Thu, 22 Dec 2022 20:47:00 +0800</pubDate>
<guid>https://huweicai.com/cubefs-with-kubernetes/</guid>
<description>Kubernetes （K8S） 是目前容器编排领域事实上的标准，在全球范围内有着广泛的应用。 CubeFS 既可以在 K8S 集群中部署客户端，通过 CSI 接口为 K8S 提供持久卷存储能力，也可以直接将 CubeFS 服务端集群整个部署在 K8S 中。 本文将分别介绍一下如何在 K8S 集群中部署 CubeFS 客户端、服务端，以及一些常见的运维操作和注意事项。 服务端 随着容器化的普及，基础设施全部上 K8S 是未来的趋势，这样所有的资源可以统一调度，且有着云原生庞大生态的加持，基础设施的运维成本也将大幅</description>
</item>
<item>
<title>聊一聊磁盘</title>
<link>https://huweicai.com/something-about-disk/</link>
<pubDate>Mon, 13 Jun 2022 18:20:55 +0800</pubDate>
<guid>https://huweicai.com/something-about-disk/</guid>
<description>磁盘 磁盘是一种非常常见的持久化存储设备，相较于计算机上另外一种主要的存储设备：内存，磁盘则主要具有断电数据不丢失、容量通常更大、价格低廉等特点；当然我们今天这里主要聊的是广义上的磁盘，而不是特指利用磁性来存储的狭义上的概念。 存储介质 理论上任何能够表达两种状态，且能持久性的保持的东西都可以用来造磁盘；不过我们通常还要考虑成本等其他实际的问题。 我们通常指的磁盘，按照存储介质来分，主要能分为固态硬盘和机</description>
</item>
<item>
<title>容器网络可视化：Weave Scope</title>
<link>https://huweicai.com/weave-scope/</link>
<pubDate>Wed, 27 Apr 2022 23:42:00 +0800</pubDate>
<guid>https://huweicai.com/weave-scope/</guid>
<description>Scope 简介 scope 是 weavework 开源的一款容器集群网络可视化监控方案，可以提供整个集群的实时网络拓扑，能具体到容器内进程这一粒度，同时还能提供对容器进行简单的详情查看、销毁、远程登录等管理功能。 功能 Overview 下图是 scope 的管理后台，打开可以看到图中有很多个六边形，代表一个个容器，而容器之间的连线则代表它们之间当前存在网络连接，鼠标悬浮到线条之上还能看到连接发起的方向，这样我们就能直观地观察到整个集群的网络流量拓扑了，哪几个服务之</description>
</item>
<item>
<title>Linux 内核轻量级调试小技巧</title>
<link>https://huweicai.com/kernel-debug-tips/</link>
<pubDate>Sun, 13 Mar 2022 00:00:00 +0800</pubDate>
<guid>https://huweicai.com/kernel-debug-tips/</guid>
<description>Kernel 内核承担了核心的操作系统工作，是当今软件生态的基石，因此了解内核是如何工作的能极大的帮助我们更好地构建用户态系统。 学习软件源代码最好的方式就是边看边 DEBUG，软件 = 代码 + 数据，看代码的同时了解其运行时数据能让我们更好的理解整体逻辑。 但内核毕竟不是普通的软件系统，并不是简单的在 IDE 里面一点就能断点调试的，虽然也可以通过 kgdb + qemu 实现在 IDE 中的断点调式，不过这样实在是太重了，而且也不能分析正在运行中的线上</description>
</item>
<item>
<title>Cilium 容器数据路径</title>
<link>https://huweicai.com/cilium-container-datapath/</link>
<pubDate>Sat, 19 Feb 2022 11:00:00 +0800</pubDate>
<guid>https://huweicai.com/cilium-container-datapath/</guid>
<description>Cilium Cilium 提供了一套基于 eBPF 的容器网络方案，在网络可观测性和隔离策略方面提供了非常多强大的特性。 我们今天主要关注 Cilium 容器数据面路径这个话题，即一个使用 Cilium 做为 CNI 的 Pod 的数据是如何流动的。 这里我们以在 Pod 中向 1.1.1.1:80发起 TCP 连接（nc -v 1.1.1.1 80）的流量为例进行分析，演示的 Cilium 集群使用 veth pair 打通容器和宿主机网络命名空间，同时使用 vxlan 模式来进行跨主机间的 Pod 通信。 这里我们使用 Pod 10.1.128.86 进行演示，其所在 Node IP 为 10.11.224</description>
</item>
<item>
<title>Cilium 配置详解</title>
<link>https://huweicai.com/cilium-config/</link>
<pubDate>Wed, 02 Feb 2022 02:26:00 +0800</pubDate>
<guid>https://huweicai.com/cilium-config/</guid>
<description>Cilium Cilium 可以说是当下最流行的基于 eBPF 的容器网络方案，基于eBPF 这种内核黑魔法 Cilium 极大地提升了容器网络的可玩性。 Cilium 的参数配置项都是通过 ConfigMapcilium-config配置的 中，，下面我们来一个个的分析一下这个 ConfigMap 里面的参数都有何意义。 本文基于cilium 1.11版本进行分析。 Cilium Config 配置项 意义 kvstore 当使用 KV 数据库存储元信息而不是CRD时，需要设置此项申明具体的KV存储，原来支持 etcd 和 consul 两种选择，不过 1.11 版</description>
</item>
<item>
<title>镜像仓库Harbor Pull实现原理</title>
<link>https://huweicai.com/harbor-pull-principle/</link>
<pubDate>Sat, 04 Dec 2021 01:19:00 +0800</pubDate>
<guid>https://huweicai.com/harbor-pull-principle/</guid>
<description>Harbor简介 Harbor 是 VMWare 开源的一个镜像仓库平台，镜像分发和存储逻辑是基于 docker 开源的 registry (后更名为 distribution)实现的，Harbor 主要在其之上扩展了权限管理、镜像扫描、可视化管理后台等平台化功能，和大部分的云原生组件一样，Harbor 也是基于 Go 语言开发的。 Harbor 的系统架构如下图所示，箭头所指方向为数据流向： 一个镜像仓库最核心的功能就是推送和拉取，本文主要讨论 Harbor 镜像拉取具体的实现细节。 在开始之前 我</description>
</item>
<item>
<title>CentOS Linux内核升级指南</title>
<link>https://huweicai.com/upgrade-centos-kernel-version/</link>
<pubDate>Thu, 24 Jun 2021 21:29:00 +0800</pubDate>
<guid>https://huweicai.com/upgrade-centos-kernel-version/</guid>
<description>内核 一个 Linux 操作系统，或者叫做 Linux 发行版，比如常见的：CentOS、Debian、Unbuntu 等等，都是由如下五部分构成的，如下图所示，Linux发行版在外层封装了了大量的库、包和工具供用户使用，而底层硬件设备控制相关的能力则仍是由内核提供： 为什么要升级版本 内核也是一个软件， 软件在不断的迭代的过程中会开发很多新的特性，当我们不论是主动还是被动的对内核的新特性有需求而当前版本不支持时，我们就需要升级版</description>
</item>
<item>
<title>Fluent Bit介绍</title>
<link>https://huweicai.com/fluent-bit/</link>
<pubDate>Wed, 05 May 2021 13:58:00 +0800</pubDate>
<guid>https://huweicai.com/fluent-bit/</guid>
<description>Fluent Bit Fluent Bit 是一款开源的日志收集组件，资源开销非常小，小到甚至能在嵌入式系统上运行，支持日志解析&amp;过滤&amp;转发，同时作为云原生基金会下的一个子项目，天然支持容器和 k8s 场景。 基本概念 大部分日志收集组件都将系统大致分为输入、缓冲区、输出三大部分，输入部分负责采集日志，采集了之后放在缓冲区，然后输出部分将其再转发到其他系统。 Fluent Bit 将这三大部分细分成了：输入、解析、过滤、缓冲区、路由、输出六个部分：</description>
</item>
<item>
<title>手动实现一个Linux容器</title>
<link>https://huweicai.com/run-linux-container-manual/</link>
<pubDate>Wed, 14 Apr 2021 16:20:00 +0800</pubDate>
<guid>https://huweicai.com/run-linux-container-manual/</guid>
<description>容器 容器技术的出现，彻底颠覆了传统的应用交付部署方式，交付的边界不再仅限于代码，而是一整套能 run everywhere 的基础设施，正如容器化领域的集大成者 Docker 的标语所言，这是一个新的时代了： Accelerate how you build, share and run modern applications. 容器本质上就是一个软件包，包含了业务服务及其依赖组件，比如我有一个Java服务，依赖了jdk 14.0.1以及几个外部 jar包，同时我们还依赖发行版的一些特性，需要运行在 debian buster发行版上，那么我们可以把这些通通打</description>
</item>
<item>
<title>Kubernetes权限管理概述</title>
<link>https://huweicai.com/kubernetes-permissions-overview/</link>
<pubDate>Thu, 18 Mar 2021 21:29:00 +0800</pubDate>
<guid>https://huweicai.com/kubernetes-permissions-overview/</guid>
<description>对于一个多用户系统而言，权限管理始终是无法忽略的一环，系统规模越大，权限管理就越重要。 以 Git 系统为例，你有一个代码仓库，你是这个仓库的管理员，你们组的同学具有提交代码的权限，你们部门的同学具有只读权限，公司的其他人全部无法查看，这就是一个典型的权限管理场景。 通常在校验权限中分为两个流程，认证和鉴权。 即先判断你是谁：认证，然后再鉴权，判断你有没有这个资源的权限。 毫无疑问，复杂的Kubernetes也具</description>
</item>
<item>
<title>Kubectl基本概念&常用命令</title>
<link>https://huweicai.com/kubectl-concepts-and-commands/</link>
<pubDate>Thu, 28 Jan 2021 15:01:00 +0800</pubDate>
<guid>https://huweicai.com/kubectl-concepts-and-commands/</guid>
<description>基本概念 容器化 + Kubernetes 逐渐成为云计算领域计算资源编排调度管理的事实标准，而 kubectl 则提供了一种非常直观和强大的观察操控 k8s集群的方式。 kubectl 是 kubernetes自带的 21 个命令行程序中的一个，其本身的逻辑并不复杂，使用 cobra 来解析命令行参数，读取 .kube/config中存储的认证信息经由 k8s restful api 和集群交互。 kubectl 命令基本格式如下： kubectl [子命令] [资源类型] [资源名称] [选项] 和 docker 、git这种复杂的命令行程序一样，kub</description>
</item>
<item>
<title>如何准确的获取CPU占用率[Linux][Go]</title>
<link>https://huweicai.com/go-linux-get-cpu-usage/</link>
<pubDate>Fri, 01 Jan 2021 01:20:00 +0800</pubDate>
<guid>https://huweicai.com/go-linux-get-cpu-usage/</guid>
<description>如果我们想要获取系统的 CPU 占用率，首先，Go 语言本身是没有帮我们封装这样的 API 的，所以我们只能自己通过其他方式直接向操作系统要，而不同的操作系统“要”的方式都不太一样，我们这里主要基于 Linux 场景来分析。 虽然有现成的 ps 和 top 等工具我们可以读到现成的值，但是这些工具也是基于 proc 文件解析的，对于人眼可读性较友好，但是代码解析时就不那么方便了。 PROCESS 文件系统 在许多 Unix 类系统中，都存在一个 procfs (Process File System) 进程文件系统的概念，用于将内</description>
</item>
<item>
<title>VPN是如何工作的</title>
<link>https://huweicai.com/how-vpn-works/</link>
<pubDate>Tue, 22 Dec 2020 23:42:00 +0800</pubDate>
<guid>https://huweicai.com/how-vpn-works/</guid>
<description>VPN 想象一下这两种场景： 你下班家，公司线上一台机器出事故了，这个时候你需要远程到这台机器上来排查并处理问题。 你在其他城市实习，这个时候学校需要选下学期的课了，但是教务网站只对校园网开放。 在这两种场景中，都离不开一种关键的技术：VPN（Virtual Private Network：虚拟局域网）。 VPN提供了一种在公网上安全的加入局域网的方式，可以我们这里就以开源的 OpenConnect VPN 为例，探讨一下 VPN 这种技术是如何安全的将局域网在互</description>
</item>
<item>
<title>Minikube安装教程</title>
<link>https://huweicai.com/minikube-install-tutorial/</link>
<pubDate>Mon, 14 Dec 2020 16:20:00 +0800</pubDate>
<guid>https://huweicai.com/minikube-install-tutorial/</guid>
<description>Minikube 是一个迷你版的 k8s，部署极其简单（相较于正常一套完整的k8s系统而言），对于想要学习k8s或者本地开发调试的人而言都是一个非常不错的选择。 注：以下操作均基于 CentOS 7，其他发型版流程大致一样，不过包管理部分会略有差异 安装容器引擎: Docker Kubernetes 是一个容器编排调度系统，但是容器实体还是需要其他系统来创建的，常见的有如：docker、virtual box、kata等，这里我们以最常见的 docker 为例进行安装，如果系统上已</description>
</item>
<item>
<title>小米路由器4A百兆版刷OpenWRT</title>
<link>https://huweicai.com/run-openwrt-on-xiaomi4a100m/</link>
<pubDate>Tue, 08 Dec 2020 23:47:00 +0800</pubDate>
<guid>https://huweicai.com/run-openwrt-on-xiaomi4a100m/</guid>
<description>我其实不怎么喜欢写这种教程类的博客，不过苦于刷机过程中资料过少，踩坑过多，特此系统性的捋一下，分享给有缘人，我手上的型号是百兆版的，4A千兆版刷OpenWRT的流程也基本一样，不过需要注意镜像地址什么的自行替换一下。 前提：需要安装 git、python3 以及熟悉基本的终端操作。 OpenWRT 首先我们要对 OpenWRT 有一些最基本的概念，OpenWRT 是一种 Linux 发行版，本质上是一个操作系统，和我们的常见的 Windows、And</description>
</item>
<item>
<title>Git实现原理</title>
<link>https://huweicai.com/git-implementation/</link>
<pubDate>Wed, 11 Nov 2020 01:43:00 +0800</pubDate>
<guid>https://huweicai.com/git-implementation/</guid>
<description>基本概念 概述 Git 是一个基于快照的文件版本管理系统，其实现原理是为每个文件计算一个 hash 值然后压缩存储到 .git/objects 目录内，普通文件为 blob 对象，而文件夹也会生成一个对象：tree，这样一个版本的文件就能被根目录串联起来，这个版本的再上层会有一个 commit 对象，commit 对象会有一到多个 parent 指针，指向上一个提交，这样就把一个个版本串联了起来。 commit 的上层还有一个概念叫分支，分支是一个指向 commit 的指针，相当于是对这一系列 commit 的抽象。 这是一</description>
</item>
<item>
<title>完整网络请求包自底向上分析</title>
<link>https://huweicai.com/who-network-capture-analysis/</link>
<pubDate>Wed, 01 Jul 2020 01:47:00 +0800</pubDate>
<guid>https://huweicai.com/who-network-capture-analysis/</guid>
<description>我们都知道网络是分层的，国际标准化组织将网络划分了七层，定义于 ISO/IEC 7498-1，也就是我们所熟知的 ISO 七层模型。 自底向上分别是：物理层、数据链路层、网络层、传输层、会话层、表示层、应用层。 而我们所熟知的超文本传输协议（HTTP: HyperText Transfer Protocol）便位于这个模型中的第七层，HTTP 请求包发出的时候会一层一层往下叠加头部知道最终变成最底层的物理信号在网线上传输，那么最终的网络包到底是长什么样呢？我们今</description>
</item>
<item>
<title>Golang 如何排查协程泄漏问题</title>
<link>https://huweicai.com/troubleshotting-goroutine-leeking/</link>
<pubDate>Fri, 29 May 2020 19:58:00 +0800</pubDate>
<guid>https://huweicai.com/troubleshotting-goroutine-leeking/</guid>
<description>背景 周所周知，内存泄漏是一个很严重的问题，会导致系统运行占用资源越来越多，无法释放，直至崩溃。所幸 Go 语言是一门 具有垃圾回收的语言，能大大降低遇到内存泄漏的概率，而我们今天要说的是另外一个棘手的问题：协程泄漏。 协程泄漏：顾名思义就是出现了应该释放而没有被释放的协程，导致系统协程数量一直上升。不像对象回收需要引用计数、三色标记等手段，协程的回收是相当简单的，等待协程将代码从头到尾执行完毕之后这一块儿空</description>
</item>
<item>
<title>颜色是如何呈现的</title>
<link>https://huweicai.com/how-color-present/</link>
<pubDate>Thu, 09 Apr 2020 01:27:11 +0800</pubDate>
<guid>https://huweicai.com/how-color-present/</guid>
<description>现实的世界是丰富多彩的，然而我们又是怎么将这种色彩呈现到我们的显示器上的呢？ 人眼如何感知色彩 众所周知，光是一种电磁波，可见光是人眼所能处理的一个电磁波频率区间子集，人眼看到事物是通过光来感知的，颜色的本质就是电磁波的频率，不同频率的光即我们语言中所定义的不同种类的颜色。本质上我们的眼睛和雷达并没有任何区别，只是大脑的解码渲染能力强一点罢了。 人的眼睛中有视锥细胞和视杆细胞，视杆细胞负责感受光的强度，</description>
</item>
<item>
<title>找出使用最频繁的Shell命令</title>
<link>https://huweicai.com/most-frequently-command/</link>
<pubDate>Fri, 20 Mar 2020 19:58:00 +0800</pubDate>
<guid>https://huweicai.com/most-frequently-command/</guid>
<description>使用最频繁 TOP 10命令： history | awk &#39;{map[$2]++} END { for (a in map )print map[ a ]&#34; &#34; map[ a ]/NR*100 &#34;% &#34; a }&#39;| sort -rn | nl | head 先上成品，然后，我们一步一步分析这行语句都涉及到了命令，它们又是如何拼凑到一块儿完成我们的目的的。 Shell 首先我们需要明确一下 shell 的定义，大家可能经常听到 shell ，shell 脚本这些词，那么 shell 到底是什么呢？ Shell 翻译成中文的意思就是壳，和操作系统内核的核相对应，就是一个基于内核的可操作界面。可操作性界面又分为两种： 图形界面类：Graphi</description>
</item>
<item>
<title>进程线程协程的本质区别</title>
<link>https://huweicai.com/process-thread-goroutine/</link>
<pubDate>Tue, 17 Mar 2020 01:20:00 +0800</pubDate>
<guid>https://huweicai.com/process-thread-goroutine/</guid>
<description>现代多任务操作系统通常都会有进程的概念来对任务进行隔离，而为了充分利用多核处理器性能同时又减少进程创建的开销，通常又都会引入更细粒度的调度单元：线程。 我们经常能在教科书上看到对于进程和线程的定义： 进程是操作系统分配资源的最小单位，线程是进行调度的最小单元。 这句话没错，但是只是从职责上给出的定义，而不是基于底层实现出发的。 广义上的线程分为内核态线程和用户态线程两种，内核态线程受操作系统直接调度可以充</description>
</item>
<item>
<title>Go语言sync包实现原理分析</title>
<link>https://huweicai.com/go-package-sync/</link>
<pubDate>Fri, 10 Jan 2020 00:30:00 +0800</pubDate>
<guid>https://huweicai.com/go-package-sync/</guid>
<description>Java 语言中有一个 java.util.Concurrent 包提供了大量的并发工，而 Go 语言中也有这样的角色：sync包。 sync.Mutex 锁实现原理 sync.Mutext 是 Go 提供的一种同步原语，用于表达互斥，不过不推荐在业务中使用，根据 Go 的设计思想，应首先考虑通过传递消息（管道）来共享内存，而不是通过共享内存来传递消息 Mutex 结构体如下，只有两个变量，非常简单： type Mutex struct { state int32 // 状态，bitmap sema uint32 // 信号量 } state 字段是一个位图 第 0 位表示是否加锁 第 1 位表示是否已唤醒 第 2 位表示是否为饥饿模</description>
</item>
<item>
<title>Go 多路条件语句 Switch 语法详解</title>
<link>https://huweicai.com/go-switch/</link>
<pubDate>Thu, 02 Jan 2020 12:09:00 +0800</pubDate>
<guid>https://huweicai.com/go-switch/</guid>
<description>Switch 是 Go 语言中一种多路条件语句，一般搭配 case 语句使用。 执行逻辑 一个 switch case 条件结构如下所示： switch simpleStatement; condition { case expression1,expression2: statements case expression3: statements default: statements } 和 if 语句类似，switch 语句也可以在条件语句之前执行一段简短的表达式（可以用于很方便的控制变量的作用域），switch case 开始执行时，会先执行这一个表达式（空也算一种），然后计算出条件语句的值，接着按从上到下，从左到右的顺序一个一个的执行 case 语句的条件表达式，如果值相等的话就会进入执行 case 条件</description>
</item>
<item>
<title>MySQL建表选项</title>
<link>https://huweicai.com/mysql-create-options/</link>
<pubDate>Wed, 13 Nov 2019 00:13:31 +0800</pubDate>
<guid>https://huweicai.com/mysql-create-options/</guid>
<description>这是一个很常见的 SQL 建表语句： CREATETABLE`people`(`id`intNOTNULLAUTO_INCREMENT,`name`varchar(40)DEFAULTNULL,PRIMARYKEY(`id`))ENGINE=InnoDBDEFAULTCHARSET=utf8SQL 建表语句结构如下： CREATE[TEMPORARY]TABLE[IFNOTEXISTS]tbl_name(create_definition,...)[table_options]我们对照结构可以看到我们的建表语句最后一部分是表选项，而在这里我们指定了两个选项：引擎和字符集，那么总共都有哪些选项可以设置呢？参照MySQL官方文档，我们一起来看看。 AUTO_INCREMENT MySQL 一张表中可以指定一</description>
</item>
<item>
<title>在线 Markdown 转 PDF 工具评测</title>
<link>https://huweicai.com/web-markdown-to-pdf-utils/</link>
<pubDate>Tue, 02 Jul 2019 08:47:11 +0800</pubDate>
<guid>https://huweicai.com/web-markdown-to-pdf-utils/</guid>
<description>用 Markdown 写了这么久博客，对于这种简约风格还是非常喜欢的，所以在写一些其他文档的时候我也更倾向于这种格式。最近需要写一些 PDF 格式的文档，所以我找了一些在线 Markdown 转 PDF 的网站，不同的网站渲染出来的风格并不一样，我在下面做了一个对比，帮助大家进行选择。 测试数据 # 测试测试 1111111111 / 测试 / 123 Email: test@test.com Test: test Website: https://github.com.cn * * * 123213123 测出测试 真的测试 测试吧 * * * # 二阶段测试 - 真的测试测试 - 真的测试测试/真的测试测试 - 微博：[@Easy](http:</description>
</item>
<item>
<title>Java跨平台究竟能跨哪些平台</title>
<link>https://huweicai.com/java-platforms/</link>
<pubDate>Mon, 20 May 2019 23:47:00 +0800</pubDate>
<guid>https://huweicai.com/java-platforms/</guid>
<description>众所周知，Java跨平台的一直被众多Java程序员们津津乐道，“一次编写，到处运行”的设想着实令人心动，虽然会带来一定性能上的问题，但这并不妨碍大家对Java的喜爱，既然都说Java能跨平台，Java 也并不是凭空就能跑在任何机器上，这是不现实的，需要官方针对对应的平台，编译一套对应平台包括 Java 虚拟机（Java Runtime Environment 简称 JRE）在内的 Java 开发工具集（Java Develop Kit，简称 JDK），这样我们编写的 Java 代码才算</description>
</item>
<item>
<title>Go知识点杂记</title>
<link>https://huweicai.com/go-knowledge-points/</link>
<pubDate>Fri, 05 Apr 2019 23:55:00 +0800</pubDate>
<guid>https://huweicai.com/go-knowledge-points/</guid>
<description>Go语言的不足 我在使用 Go 语言编程开发时发现的一些问题，记录： 没有泛型，写工具库时很不方便 Go 把错误当成一种函数返回值来处理自有其设计道理，但是一次只能只能处理一个错误则是语法上的不足 编译器不支持尾递归优化，这对于递归代码而言很不友好 strings 库不像 Java 那样直接支持正则 没有三目运算符 官方库提供的锁不支持重入 Go静态链接编译的做法会把二进制包撑的特别大，虽然这带来了较好的可移植性 使用首字母大小写这种隐式的做法来</description>
</item>
<item>
<title>Redis FAQ</title>
<link>https://huweicai.com/redis-faq/</link>
<pubDate>Fri, 04 Jan 2019 22:43:00 +0800</pubDate>
<guid>https://huweicai.com/redis-faq/</guid>
<description>Redis 官网 FAQ 翻译以及部分自己生产实践总结的问题 官网FAQ地址 Redos持久化策略：RDB和AOF RDB：数据快照，数据整体快照，吞吐量较大，但单次耗时较长，如果在dump的时候宕机可能会导致数据丢失。 AOF：日志追加，占空间比RDB大，但安全性更好，每秒追加一次日志，丢失数据的可能性会小很多，但是宕机恢复很慢。 而在实际生产环境中，我们通常会将两种持久化策略共同使用，定期进行数据快照，同时保留 AOF 日志，在</description>
</item>
<item>
<title>小论计算机Encoding</title>
<link>https://huweicai.com/computer-encodings/</link>
<pubDate>Sat, 26 May 2018 12:47:11 +0800</pubDate>
<guid>https://huweicai.com/computer-encodings/</guid>
<description>乱码问题一直是最让人心烦的一类问题，因为不知从何而来，由何而起，只能一处一处的改编码，运气好了就改成功了，运气不好就继续试，有时候明明把所有能改的地方全改成UTF-8了，却仍然无济于事，着实叫人抓狂。这一切都要从1946年的那个春天说起。 在第一计算机台诞生的时候，那个时候还只有0和1，慢慢的，科学家们厌倦了只有0和1的世界，所以他们就聚在一起开了个会，讨论了讨论，决定按特定的方式将人类语言映射到0</description>
</item>
<item>
<title>for{;;}与while(true)的困惑</title>
<link>https://huweicai.com/confusion-betwwen-forwhiletrue/</link>
<pubDate>Sun, 04 Mar 2018 21:47:00 +0800</pubDate>
<guid>https://huweicai.com/confusion-betwwen-forwhiletrue/</guid>
<description>最近在阅读JUC源码的时候，由于多线程并发时情况比较复杂，所以源码中经常出现一些无限循环用于等待确保或是某些目的的完成，通常我一般无限循环都是用while(true)，但是我发现在concurrent包中经常用for(;;)来实现。这让我产生了困惑，难道for(;;)会比while(true)性能更好一些吗？于是我决定自己分别编译比较一下。 我编写了如下的程序： public class Test2 { public void whileTest() { int i = 0; while (true) { i++; } } public</description>
</item>
<item>
<title></title>
<link>https://huweicai.com/chubaofs-csi/</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://huweicai.com/chubaofs-csi/</guid>
<description>ChubaoFS CSI 为什么升级就会挂</description>
</item>
<item>
<title></title>
<link>https://huweicai.com/personal/go%E5%86%85%E5%AD%98%E6%A8%A1%E5%9E%8B/</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://huweicai.com/personal/go%E5%86%85%E5%AD%98%E6%A8%A1%E5%9E%8B/</guid>
<description>Go内存示意图 page 内存页面的最小单元，大小为：_PageShift = 13;_PageSize = 1 &lt;&lt; _PageShift = 8KB mheap 是一个全局唯一的对象，代表整个堆，当堆空间不够时，会通过 mmap 系统调用申请一块大小为 64MB 的内存，封装为一个 arena 进行管理。 mheap 中 arenas 数组最多可以管理：4194304 个 arena，每个 arena 64MB，所以 mheap 总共可以管理 256TB 的内存。 type mheap struct { allspans []*mspan // all spans out there arenas [1]*[4194304]*heapArena central [134]struct { // 134 = 57 * 2，有 57 种大小类型的内存 mcentral mcentral } } arena 每个 arena 64 MB // pagesPerArena = 8192 = 8 * 1024 // heapArenaBitmapBytes = 2097152</description>
</item>
<item>
<title></title>
<link>https://huweicai.com/personal/%E5%8D%95%E6%9C%BA%E5%AE%B9%E5%99%A8%E7%BD%91%E7%BB%9C%E6%A8%A1%E5%9E%8B/</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://huweicai.com/personal/%E5%8D%95%E6%9C%BA%E5%AE%B9%E5%99%A8%E7%BD%91%E7%BB%9C%E6%A8%A1%E5%9E%8B/</guid>
<description>slug: &#34;stand-alone-network-model &#34; tags: [&#34;操作系统&#34;,&#34;网络&#34;,&#34;Linux&#34;,&#34;docker&#34;,&#34;容器&#34;] date: 2021-06-20T01:20:00+08:00 toc: true title: 经典单机容器网络模型-Docker # 参考文档 1. https://docs.docker.com/network/bridge/ 2. https://docs.docker.com/network/iptables/</description>
</item>
<item>
<title></title>
<link>https://huweicai.com/untitled/</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://huweicai.com/untitled/</guid>
<description></description>
</item>
</channel>
</rss>