天下武功 唯快不破

杂谈

• 寒冬已至，我们还能活多久？
• 技术管理的三个层次
• 技术文摘精选

温故知新

• 温故知新·冯诺依曼体系结构
• 温故知新·存储器
• 温故知新·存储器之寄存器
• 温故知新·CPU
• 温故知新·汇编语言
• 温故知新·用户态和内核态
• 温故知新·系统调用
• 温故知新·中断
• 温故知新·内存管理基础知识
• 温故知新·内存管理单元MMU
• 温故知新·虚拟内存
• 温故知新·Swap分区

Web前端

• 浏览器渲染网页过程
• 浏览器资源缓存机制总结

Go

• Go语言特点总结
• Go基础语法学习总结(一)
• Go基础语法学习总结(二)

PHP

• PHP开发常用文档总结
• PHP底层运行机制和原理
• PHP框架常见URL模式
• PHP运行模式(SAPI)
• PHP性能优化之Opcache
• PHP安全编程
• PHP标准规范PSR
• PHP类的自动加载
• Composer自动加载原理
• PHP-FPM使用指南
• PHP反射模拟实现注解路由
• PHP协程
• PHP写时拷贝技术
• PHP垃圾回收机制
• PHP的Session运行机制
• PHP错误和异常处理机制详解
• PHP依赖注入和控制反转
• PHP扩展开发入门
• PHP安全配置总结
• PHP微服务开发指南

Python

• Python高频模块汇总
• Python之线程池
• Python之装饰器
• Python使用lambda表达式

前端开发

• PureMVC(JS版)源码解析:总结
• Javascript垃圾回收机制
• Javascript实现双向数据绑定
• 浏览器资源缓存机制总结
• 深入理解Javascript异步原理

Lua

• Lua语法总结
• Lua版MVC框架

Mysql

• Mysql基础操作
• Mysql binlog详解
• Mysql主从复制
• SQL执行原理
• Mysql常见优化技巧
• Mysql存储引擎比较
• Mysql核心知识汇总
• 深入理解Mysql复制机制
• 深入理解Mysql事务
• 深入理解Mysql索引
• MySql表锁、行锁、共享锁、排他锁、乐观锁、悲观锁
• 谈一谈Mysql分库分表
• Mysql中间件MyCat使用
• CAS-乐观锁的一种实现方式

NoSQL

• Redis发布订阅
• Redis管道技术
• Redis事务机制
• Redis持久化和数据数据恢复
• Redis主从模式搭建及应用
• Redis缓存穿透、缓存击穿、缓存雪崩
• Redis集群及高可用实现
• Redis数据过期和淘汰策略
• Redis中BitMap使用
• 基于Redis使用令牌桶算法实现流量控制
• MongoDB入门实践
• MongoDB副本集及分片
• Redis和Memcache对比

大数据

• 大数据开发入门之hadoop介绍
• 大数据开发入门之hadoop单机版部署
• 大数据开发入门之WordCount开发实践

Docker

• Docker数据持久化总结
• Docker网络模式深度解读
• Docker镜像优化
• Docker入门总结
• Docker快速入门
• Dockerfile设置默认时区
• Docker使用技巧
• Dockerfile中CMD与ENTERPOINT差异比较

架构设计

• LNMP架构下各项配置优化总结
• HAProxy实践详解
• P3P协议详解
• 大型网站架构设计总结
• ELK日志分析系统入门
• Nginx高级用法总结
• Nginx+Keepalived搭建高可用集群
• Keepalived的部署及应用
• 常见负载均衡算法
• Nginx常见问题之Location优先级
• Nginx与HAProxy负载均衡比较
• Nginx实战灰度发布

队列/MQ

• 简单队列服务:HTTPSQS
• Kafka基础入门
• 深入浅出RabbitMQ
• 基于RabbitMQ消息延时队列方案
• RabbitMQ集群实践

分布式

• Zookeeper基础入门
• 分布式系统中CAP理论
• 分布式唯一ID实现方案
• Redis和Zookeeper分布式锁实现
• 走进Gossip协议
• 服务降级、熔断和限流
• 深入理解一致性Hash原理

微服务

• 微服务设计思想和目标

RPC

• RPC的简单实现
• Protobuf:高效数据结构化工具
• gRPC入门及应用

API网关

• OpenID Connect协议
• OpenResty实现API网关
• Kong API网关使用入门
• 基于JWT实现Token认证

CI/CD

• GitFlow在团队协作中的实践
• 基于CodePipeline实现CI/CD

Linux基础

• 磁盘IO与swap分区
• Page Cache与Page回写
• 从TCP/IP协议谈Linux内核参数优化
• 深入理解IO模型
• IO多路复用之select、poll、epoll详解
• 长、短链接与连接池

数据结构和算法

• 数据结构之单向链表
• 数据结构之双向链表
• 数据结构之栈
• 数据结构之队列
• 数据结构之集合
• 数据结构之二叉树
• 常见二叉树结构
• 数据结构之B树、B+树、B*树
• 二叉搜索树转双向链表
• 数据结构之图
• Times33哈希算法
• 常见排序算法实现
• 常见搜索算法实现
• 布隆过滤,实现亿级数据快速查找
• LRU算法实现
• 深入理解一致性Hash原理
• 深入理解递归算法

安全

• DDOS攻击下多IP防御思路

switch

switch 语句用于基于不同条件执行不同动作，每一个 case 分支都是唯一的，从上直下逐一测试，直到匹配为止。 Golang switch 分支表达式可以是任意类型，不限于常量。可省略 break，默认自动终止。

range

Golang range类似迭代器操作，返回 (索引, 值) 或 (键, 值)。 for 循环的 range 格式可以对 slice、map、数组、字符串等进行迭代循环。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

package main
func main() {
    s := "abc"
    // 忽略 2nd value，支持 string/array/slice/map。
    for i := range s {
        println(s[i])
    }
    // 忽略 index。
    for _, c := range s {
        println(c)
    }
    // 忽略全部返回值，仅迭代。
    for range s {
    }
    m := map[string]int{"a": 1, "b": 2}
    // 返回 (key, value)。
    for k, v := range m {
        println(k, v)
    }
}

指针

Go语言中的指针不能进行偏移和运算，是安全指针。

在Go语言中对于引用类型的变量，我们在使用的时候不仅要声明它，还要为它分配内存空间，否则我们的值就没办法存储。而对于值类型的声明不需要分配内存空间，是因为它们在声明的时候已经默认分配好了内存空间。

要分配内存，就引出来今天的new和make。 Go语言中new和make是内建的两个函数，主要用来分配内存。

new

new是一个内置的函数，它的函数签名如下：

1

func new(Type) *Type

其中:

Type表示类型，new函数只接受一个参数，这个参数是一个类型 *Type表示类型指针，new函数返回一个指向该类型内存地址的指针。

new函数不太常用，使用new函数得到的是一个类型的指针，并且该指针对应的值为该类型的零值。

make

make也是用于内存分配的，区别于new，它只用于slice、map以及chan的内存创建，而且它返回的类型就是这三个类型本身，而不是他们的指针类型，因为这三种类型就是引用类型，所以就没有必要返回他们的指针了。

make函数的函数签名如下：

1

func make(t Type, size ...IntegerType) Type

make函数是无可替代的，我们在使用slice、map以及channel的时候，都需要使用make进行初始化，然后才可以对它们进行操作。

new与make的区别

• 二者都是用来做内存分配的。
• make只用于slice、map以及channel的初始化，返回的还是这三个引用类型本身；
• 而new用于类型的内存分配，并且内存对应的值为类型零值，返回的是指向类型的指针。

结构体

使用type和struct关键字来定义结构体，具体代码格式如下：

1
2
3
4
5

type 类型名 struct {
  字段名 字段类型
  字段名 字段类型
  …
}

其中：

• 类型名：标识自定义结构体的名称，在同一个包内不能重复。
• 字段名：表示结构体字段名。结构体中的字段名必须唯一。
• 字段类型：表示结构体字段的具体类型。

举个例子，我们定义一个Person（人）结构体，代码如下：

1
2
3
4
5

type person struct {
  name string
  city string
  age  int8
}

同样类型的字段也可以写在一行，

1
2
3
4

type person1 struct {
  name, city string
  age        int8
}

匿名结构体

在定义一些临时数据结构等场景下还可以使用匿名结构体。

1
2
3
4
5
6
7
8
9
10

package main
import (
    "fmt"
)
func main() {
    var user struct{Name string; Age int}
    user.Name = "pprof.cn"
    user.Age = 18
    fmt.Printf("%#v\n", user)
}

初始化结构体的时候可以简写，也就是初始化的时候不写键，直接写值：

1
2
3
4
5
6

p8 := &person{
    "pprof.cn",
    "北京",
    18,
}
fmt.Printf("p8=%#v\n", p8) //p8=&main.person{name:"pprof.cn", city:"北京", age:18}

使用这种格式初始化时，需要注意：

• 必须初始化结构体的所有字段。
• 初始值的填充顺序必须与字段在结构体中的声明顺序一致。
• 该方式不能和键值初始化方式混用。

Go语言的结构体没有构造函数，我们可以自己实现。 例如，下方的代码就实现了一个person的构造函数。 因为struct是值类型，如果结构体比较复杂的话，值拷贝性能开销会比较大，所以该构造函数返回的是结构体指针类型。

1
2
3
4
5
6
7

func newPerson(name, city string, age int8) *person {
    return &person{
        name: name,
        city: city,
        age:  age,
    }
}

调用构造函数

1
2

p9 := newPerson("pprof.cn", "测试", 90)
fmt.Printf("%#v\n", p9)

方法接受者

Go语言中的方法（Method）是一种作用于特定类型变量的函数。这种特定类型变量叫做接收者（Receiver）。接收者的概念就类似于其他语言中的this或者 self。 方法的定义格式如下：

1
2
3

func (接收者变量 接收者类型) 方法名(参数列表) (返回参数) {
	函数体
}

其中：

• 接收者变量：接收者中的参数变量名在命名时，官方建议使用接收者类型名的第一个小写字母，而不是self、this之类的命名。例如，Person类型的接收者变量应该命名为 p，Connector类型的接收者变量应该命名为c等。
• 接收者类型：接收者类型和参数类似，可以是指针类型和非指针类型。
• 方法名、参数列表、返回参数：具体格式与函数定义相同。

在Go语言中，接收者的类型可以是任何类型，不仅仅是结构体，任何类型都可以拥有方法。 举个例子，我们基于内置的int类型使用type关键字可以定义新的自定义类型，然后为我们的自定义类型添加方法。

1
2
3
4
5
6
7
8
9
10
11
12

//MyInt 将int定义为自定义MyInt类型
type MyInt int
//SayHello 为MyInt添加一个SayHello的方法
func (m MyInt) SayHello() {
    fmt.Println("Hello, 我是一个int。")
}
func main() {
    var m1 MyInt
    m1.SayHello() //Hello, 我是一个int。
    m1 = 100
    fmt.Printf("%#v  %T\n", m1, m1) //100  main.MyInt
}

注意事项： 非本地类型不能定义方法，也就是说我们不能给别的包的类型定义方法。

结构体的匿名字段

结构体允许其成员字段在声明时没有字段名而只有类型，这种没有名字的字段就称为匿名字段。

1
2
3
4
5
6
7
8
9
10
11
12
13

//Person 结构体Person类型
type Person struct {
    string
    int
}
func main() {
    p1 := Person{
        "pprof.cn",
        18,
    }
    fmt.Printf("%#v\n", p1)        //main.Person{string:"pprof.cn", int:18}
    fmt.Println(p1.string, p1.int) //pprof.cn 18
}

匿名字段默认采用类型名作为字段名，结构体要求字段名称必须唯一，因此一个结构体中同种类型的匿名字段只能有一个。

嵌套匿名结构体

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

//Address 地址结构体
type Address struct {
    Province string
    City     string
}
//User 用户结构体
type User struct {
    Name    string
    Gender  string
    Address //匿名结构体
}
func main() {
    var user2 User
    user2.Name = "pprof"
    user2.Gender = "女"
    user2.Address.Province = "黑龙江"    //通过匿名结构体.字段名访问
    user2.City = "哈尔滨"                //直接访问匿名结构体的字段名
    fmt.Printf("user2=%#v\n", user2) //user2=main.User{Name:"pprof", Gender:"女", Address:main.Address{Province:"黑龙江", City:"哈尔滨"}}
}

当访问结构体成员时会先在结构体中查找该字段，找不到再去匿名结构体中查找。

结构体字段的可见性

结构体中字段大写开头表示可公开访问，小写表示私有（仅在定义当前结构体的包中可访问）。

类型定义和类型别名的区别

类型别名与类型定义表面上看只有一个等号的差异，我们通过下面的这段代码来理解它们之间的区别。

1
2
3
4
5
6
7
8
9
10

//类型定义
type NewInt int
//类型别名
type MyInt = int
func main() {
    var a NewInt
    var b MyInt
    fmt.Printf("type of a:%T\n", a) //type of a:main.NewInt
    fmt.Printf("type of b:%T\n", b) //type of b:int
}

结果显示a的类型是main.NewInt，表示main包下定义的NewInt类型。b的类型是int。MyInt类型只会在代码中存在，编译完成时并不会有MyInt类型。

单元测试

在*_test.go文件中有三种类型的函数，单元测试函数、基准测试函数和示例函数。

go test命令会遍历所有的*_test.go文件中符合上述命名规则的函数，然后生成一个临时的main包用于调用相应的测试函数，然后构建并运行、报告测试结果，最后清理测试中生成的临时文件。

断言

想要判断空接口中的值这个时候就可以使用类型断言，其语法格式： x.(T) 其中： x：表示类型为interface{}的变量 T：表示断言x可能是的类型。 该语法返回两个参数，第一个参数是x转化为T类型后的变量，第二个值是一个布尔值，若为true则表示断言成功，为false则表示断言失败。 举个例子：

1
2
3
4
5
6
7
8
9
10
11

func main() {
    var x interface{}
    x = "pprof.cn"
    v, ok := x.(string)
    if ok {
        fmt.Println(v)
    } else {
        fmt.Println("类型断言失败")
    }
}

反射

二进制处理

信号

锁

内置类型

值类型

• bool
• int(32 or 64)、int8、int16、int32、int64
• uint(32 or 64)、uint8(byte)、uint16、uint32、uint64
• float32、float64
• string
• complex64、complex128 [complex:复杂的，复合的，复数类型]
• array – 固定长度数组

其中，uint8就是我们熟知的byte型，int16对应C语言中的short型，int64对应C语言中的long型。

Go语言中以bool类型进行声明布尔型数据，布尔型数据只有true（真）和false（假）两个值。

1
2
3
4

注意：
布尔类型变量的默认值为false。
Go 语言中不允许将整型强制转换为布尔型.
布尔型无法参与数值运算，也无法与其他类型进行转换。

Go 语言里的字符串的内部实现使用UTF-8编码。 字符串的值为双引号(“)中的内容。

字符串的常用操作

字符

字符用单引号'包裹起来

Go 语言的字符有以下两种：

1
2

uint8类型，或者叫 byte 型，代表了ASCII码的一个字符。
rune类型，代表一个 UTF-8字符。

当需要处理中文、日文或者其他复合字符时，则需要用到rune类型。rune类型实际是一个int32。 Go 使用了特殊的 rune 类型来处理 Unicode，让基于 Unicode的文本处理更为方便，也可以使用 byte 型进行默认字符串处理，性能和扩展性都有照顾。

字符串底层是一个byte数组，所以可以和[]byte类型相互转换。字符串是不能修改的 字符串是由byte字节组成，所以字符串的长度是byte字节的长度。 rune类型用来表示utf8字符，一个rune字符由一个或多个byte组成。

数组

1
2

长度是数组类型的一部分，因此，var a[5] int和var a[10]int是不同的类型。
指针数组 [n]*T，数组指针 *[n]T

值拷贝行为会造成性能问题，通常会建议使用 slice，或数组指针。

1
2
3
4
5
6
7
8
9
10
11
12
13
14

package main
import (
    "fmt"
)
func test(x [2]int) {
    fmt.Printf("x: %p\n", &x)
    x[1] = 1000
}
func main() {
    a := [2]int{}
    fmt.Printf("a: %p\n", &a)
    test(a)
    fmt.Println(a)
}

输出结果:

1
2
3

a: 0xc42007c010
x: 0xc42007c030
[0 0]

数组遍历

1
2
3
4

for i := 0; i < len(a); i++ {
}
for index, v := range a {
}

数组初始化

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

// 全局
var arr0 [5]int = [5]int{1, 2, 3}
var arr1 = [5]int{1, 2, 3, 4, 5}
var arr2 = [...]int{1, 2, 3, 4, 5, 6}
var str = [5]string{3: "hello world", 4: "tom"}

// 局部
a := [3]int{1, 2}           // 未初始化元素值为 0。
b := [...]int{1, 2, 3, 4}   // 通过初始化值确定数组长度。
c := [5]int{2: 100, 4: 200} // 使用索引号初始化元素。
d := [...]struct {
    name string
    age  uint8
    }{
    {"user1", 10}, // 可省略元素类型。
    {"user2", 20}, // 别忘了最后一行的逗号。
}

引用类型（指针类型）

• slice – 序列数组（最常用）
• map – 映射
• chan – 管道

map

map是一种无序的基于key-value的数据结构，Go语言中的map是引用类型，必须初始化才能使用。

Go语言中 map的定义语法如下

1

map[KeyType]ValueType

其中:

KeyType:表示键的类型 ValueType:表示键对应的值的类型

map类型的变量默认初始值为nil，需要使用make()函数来分配内存。语法为：

1

make(map[KeyType]ValueType, [cap])

其中cap表示map的容量，该参数虽然不是必须的，但是我们应该在初始化map的时候就为其指定一个合适的容量。

map也支持在声明的时候填充元素，例如：

1
2
3
4
5
6
7

func main() {
    userInfo := map[string]string{
        "username": "pprof.cn",
        "password": "123456",
    }
    fmt.Println(userInfo) 
}

Go语言中有个判断map中键是否存在的特殊写法，格式如下:

1

value, ok := map[key]

使用delete()内建函数从map中删除一组键值对，delete()函数的格式如下：

1
2
3

delete(map, key)
# map:表示要删除键值对的map
# key:表示要删除的键值对的键

内置函数

Go语言拥有一些不需要进行导入操作就可以使用的内置函数。它们有时可以针对不同的类型进行操作，例如：len、cap 和 append，或必须用于系统级的操作，例如：panic。因此，它们需要直接获得编译器的支持。

• append – 用来追加元素到数组、slice中,返回修改后的数组、slice
• close – 主要用来关闭channel
• delete – 从map中删除key对应的value
• panic – 停止常规的goroutine （panic和recover：用来做错误处理）
• recover – 允许程序定义goroutine的panic动作
• real – 返回complex的实部 （complex、real imag：用于创建和操作复数）
• imag – 返回complex的虚部
• make – 用来分配内存，返回Type本身(只能应用于slice, map, channel)
• new – 用来分配内存，主要用来分配值类型，比如int、struct。返回指向Type的指针
• cap – capacity是容量的意思，用于返回某个类型的最大容量（只能用于切片和 map）
• copy – 用于复制和连接slice，返回复制的数目
• len – 来求长度，比如string、array、slice、map、channel ，返回长度
• print、println – 底层打印函数，在部署环境中建议使用 fmt 包

内置接口error

1
2
3

type error interface { //只要实现了Error()函数，返回值为String的都实现了err接口
     Error()    String
 }

Go语言的并发是基于 goroutine 的，goroutine 类似于线程，但并非线程。可以将 goroutine 理解为一种虚拟线程。Go语言运行时(runtime)会参与调度 goroutine，并将 goroutine 合理地分配到每个CPU 中，最大限度地使用CPU性能。开启一个goroutine的消耗非常小（大约2KB的内存），你可以轻松创建数百万个goroutine。

goroutine的特点：

• goroutine具有可增长的分段堆栈。这意味着它们只在需要时才会使用更多内存。
• goroutine的启动时间比线程快。
• goroutine原生支持利用channel安全地进行通信。
• goroutine共享数据结构时无需使用互斥锁。

Go语言特点

• 没有继承，多态，类等
• 并发编程，语法层支持并发，和拥有同步并发的channel类型
• 函数多返回值
• 反射

可见性

• 声明在函数内部，是函数的本地值，类似private
• 声明在函数外部，是对当前包可见(包内所有.go文件都可见)的全局值，类似protect
• 声明在函数外部且首字母大写是所有包可见的全局值,类似public

init函数和main函数

init函数

go语言中init函数用于包(package)的初始化。

main函数

Go语言程序的默认入口函数(主函数)

init函数和main函数的异同

相同点

• 两个函数在定义时不能有任何的参数和返回值，且Go程序自动调用。

不同点

• init可以应用于任意包中，且可以重复定义多个。
• main函数只能用于main包中，且只能定义一个。

调用顺序

对同一个go文件的init()调用顺序是从上到下的。

对同一个package中不同文件是按文件名字符串比较“从小到大”顺序调用各文件中的init()函数。

对于不同的package，如果不相互依赖的话，按照main包中”先import的后调用”的顺序调用其包中的init()，如果package存在依赖，则先调用最早被依赖的package中的init()，最后调用main函数。

如果init函数中使用了println()或者print()你会发现在执行过程中这两个不会按照你想象中的顺序执行。这两个函数官方只推荐在测试环境中使用，对于正式环境不要使用。

下划线

• “_”是特殊标识符，用来忽略结果。
• import 下划线（如：import _hello/imp）的作用：当导入一个包时，该包下的文件里所有init()函数都会被执行，然而，有些时候我们并不需要把整个包都导入进来，仅仅是是希望它执行init()函数而已。这个时候就可以使用 import _引用该包。

声明

有四种声明方式：

• var（声明变量）
• const（声明常量）
• type（声明类型）
• func（声明函数）

批量声明

每声明一个变量就需要写var关键字会比较繁琐，go语言中还支持批量变量声明：

1
2
3
4
5
6

var (
  a string
  b int
  c bool
  d float32
)

Go语言在声明变量的时候，会自动对变量对应的内存区域进行初始化操作。每个变量会被初始化成其类型的默认值，例如： 整型和浮点型变量的默认值为0。 字符串变量的默认值为空字符串。 布尔型变量默认为false。 切片、函数、指针变量的默认为nil。

一次初始化多个变量

1

var name, sex = "pprof.cn", 1

短变量声明

在函数内部，可以使用更简略的 := 方式声明并初始化变量。

1
2
3
4
5
6
7
8
9
10
11

package main
import (
    "fmt"
)
// 全局变量m
var m = 100
func main() {
    n := 10
    m := 200 // 此处声明局部变量m
    fmt.Println(m, n)
}

注意事项：

• 函数外的每个语句都必须以关键字开始（var、const、func等）
• :=不能使用在函数外。
• _多用于占位，表示忽略值。

iota

iota是go语言的常量计数器，只能在常量的表达式中使用。 iota在const关键字出现时将被重置为0。const中每新增一行常量声明将使iota计数一次(iota可理解为const语句块中的行索引)。 使用iota能简化定义，在定义枚举时很有用。

举个例子：

1
2
3
4
5
6

const (
  n1 = iota //0
  n2        //1
  n3        //2
  n4        //3
)

众所周知，直接从物理内存(RAM)读写数据要比从硬盘(Desk)读写数据要快的多，但是内存大小是有限的，为了解决物理内存不足的问题，操作系统引入了虚拟内存的概念。

虚拟内存是利用磁盘空间虚拟出的一块逻辑内存，用作虚拟内存的磁盘空间被称为交换空间（Swap Space）。

作为物理内存的扩展，内核会在物理内存不足时，会将暂时不用的内存块信息写到交换空间，这样物理内存得到了释放，当需要用到交换空间的数据时，又会被重新从交换空间读到物理内存。

Linux内核是以内存页为单位进行内存管理，为了保证物理内存能得到充分的利用，内核会在适当的时候将物理内存中不经常使用的数据块自动交换到虚拟内存中，而将经常使用的信息保留到物理内存。

swappniess

swappiness是Linux的一个内核参数，控制系统在进行swap时内存使用的相对权重。以下命令查看当前swappniess配置：

1

cat /proc/sys/vm/swappiness

swappiness参数值可设置范围在0到100之间。 此参数值越低，就会让Linux系统尽量少用swap分区，多用内存。swappiness=0的时候表示最大限度使用物理内存(设为0，这样做并不会禁止对swap的使用，只是最大限度地降低了使用swap的可能性)，然后才是 swap空间，swappiness＝100的时候表示积极的使用swap分区，并且把内存上的数据及时的搬运到swap空间里面。

Ubuntu系统swappiness默认值为60，表示的含义可以这样来理解，当剩余物理内存低于40%（40=100-60）时，开始使用swap分区。CentOS系统此参数的默认值是30。

通常情况下：swap分区设置建议是内存的两倍 （内存小于等于4G时），如果内存大于4G，swap只要比内存大就行。另外尽量的将swappiness调低，这样系统的性能会更好。

修改swappniess参数

1
2
3
4
5
6
7
8
9
10
11

#临时性修改：
sysctl vm.swappiness=10

#永久性修改[root@wenwen ~]
vim /etc/sysctl.conf
# 加入参数
vm.swappiness = 35
# 重新加载配置
sysctl -p /etc/sysctl.conf
#查看是否生效：
cat /proc/sys/vm/swappiness

swap分区设置

查看swap分区的使用情况

在linux系统中，通常使用free -m来查看内存和swap分区的使用情况。

1
2
3
4

root@Devops:~$ free -m
              total        used        free      shared  buff/cache   available
Mem:           3823        1152         241          39        2428        2318
Swap:             0           0           0

其中 swap 表示交换分区使用情况。

创建swap分区

1
2
3
4
5
6
7
8
9
10

#创建 SWAP 文件，设置大小，这里设置为 1G。（bs * count = SWAP 大小）
dd if=/dev/zero of=/var/swap bs=1M count=1024
# 设置文件权限
chmod 600 /var/swap
# 创建 SWAP
mkswap /var/swap
# 启用
swapon /var/swap
# 查看 SWAP 状态
swapon -s 或者 free -m

查看 SWAP 状态:

1
2
3

root@Devops:~$ swapon -s
Filename				Type		Size	Used	Priority
/var/swap                              	file    	1048572	0	-1

添加开机启动：

1
2

# 在 /etc/fstab 中添加一行 /var/swap swap swap default 0 0
echo '/var/swap   swap   swap   default 0 0' >> /etc/fstab

删除Swap:

删除swap之前先要确保内存剩余要大于等于swap使用量，否则会宕机！根据内存机制，swap分区一旦释放，所有存放在swap分区的文件都会转存到物理内存上。

1
2
3
4
5
6

# 先停用
swapoff /var/swap
#再删除
rm -rf /var/swap
# 去掉开机启动
sed -i '/\/var\/swap   swap   swap   default 0 0/d'  /etc/fstab

为什么会存在虚拟内存呢？在以前的计算机体系中是没有虚拟内存的，程序都是直接运行在物理内存上面的，但是随着我们程序越写越大，想要实现的功能越来越多，直接将程序运行在物理内存上会带来一些问题。

• 多程序运行影响内存使用效率
• 修改内存数据可能导致程序崩溃

先来回答问题一，现在有多个程序需要运行，但是内存空间不足，此时我们需要把内存中的某个程序拷贝到硬盘里面，再将新的程序装入内存。这整个过程是很耗时的，而且大量数据频繁装入装出，使得内存的使用效率很低。

然后来看问题二，由于多程序运行在物理内存上，程序之间没有什么安全保护措施，我们访问A程序的数据地址时，可能由于我们的疏忽，错访问成了B程序的数据地址，这样就可能导致B程序出现莫名其妙的问题或者直接崩溃。

针对以上问题，前辈们发明了虚拟内存管理机制，很好地解决了内存使用问题。

虚拟内存系统概述

CPU通过生成一个虚拟地址来访问主存，这个虚拟地址在被送到内存之前先转换成适当的物理地址。将虚拟地址转换成物理地址需要内存管理单元（MMU,Memory Management Unit）进行配合，而MMU属于CPU芯片硬件的一部分。

这样看起来很完美，但其实并不是这样的。MMU 地址翻译过程中存在一种叫页表的数据结构，是由它来保存虚拟地址转换成物理地址的映射关系。每次 MMU 将一个虚拟地址转换为物理地址时，都会从内存中读取对应的页表。这样非常消耗时间，MMU地址翻译效率会极大地降低。

有没有可改进的空间呢？答案是当然有。把页表缓存起来不就行了嘛。事实上他们也是这样做的。他们在 MMU 中包含了一个关于页表的缓存，称为转换检测缓冲区（Translation Lookaside Buffer, TLB）。简而言之，TLB 的作用就是加速 MMU 的地址转换。

虚拟内存的整体流程可分为4步：

• CPU产生一个虚拟地址
• MMU从TLB中获取页表，翻译成物理地址
• MMU把物理地址发送给主存
• 主存将地址对应的数据返回给CPU

整体流程下图所示：

虚拟内存的细节

页与页框

Linux把虚存空间分成若干个大小相等的存储分区，Linux把这样的分区叫做页。为了换入、换出的方便，物理内存也按大小分成若干个块。由于物理内存中的块空间是用来容纳虚拟页的容器，所以物理内存中的块叫做页框。

页与页框是Linux实现虚拟内存技术的基础。

虚拟地址与物理地址的映射关系如下图所示：

页表

物理内存和虚拟内存被分为页框和页之后，其存储单元原来的地址都被自然地分成了两段，并且这两段各自代表着不同的意义：高段位分别是页框和页码，它们是识别页框和页的编码；低段位分别叫做页框偏移量和页内偏移量，它们是存储单元在页框和页内的地址编码。

要实现虚拟页与物理页之间的映射关系，我们需要一种叫作页表的数据结构。页表实际上就是一个页表条目（Page Table Entry, PTE）的数组，每条PTE都由一个有效位和一个n位地址组成。

• 如果PTE的有效位为1，则n位地址表示相应物理页的起始位置，即虚拟地址能够在物理内存中找到相应的物理页。
• 如果PTE的有效位为0，且后面跟着的地址为空，那么表示该虚拟地址指向的虚拟页还没有被分配。
• 如果PTE的有效位为0，且后面跟着指向虚拟页的地址，表示该虚拟地址在物理内存中没有相对应的物理地址，指向该虚拟页在磁盘上的起始位置，我们通常把这种情况称为缺页。此时，若出现缺页现象，MMU 会发出一个缺页异常，缺页异常调用内核中的缺页处理异常程序，该程序会选择主存的一个牺牲页，将我们需要的虚拟页替换到原牺牲页的位置。

多级页表

我们目前为止讨论的只是单页表，但在实际的环境中虚拟空间地址都是很大的（一个32位系统的地址空间有 2^32 = 4GB，更别说 64 位系统了）。在这种情况下，使用一个单页表明显是效率低下的。

常用方法是使用层次结构的页表。假设我们的环境为一个32位的虚拟地址空间，它有如下形式：

• 虚拟地址空间被分为4KB的页，每个PTE都是4字节。
• 内存的前2K个页面分配给了代码和数据，之后的6K个页面还未被分配， 再接下来的1023个页面也未分配，其后的1个页面分配给了用户栈。

下图是为该虚拟地址空间构造的二级页表层次结构（真实情况中多为四级或更多），一级页表（ 1024 个 PTE 正好覆盖 4GB 的虚拟地址空间，同时每个 PTE 只有 4 字节，这样一级页表与二级页表的大小也正好与一个页面的大小一致都为 4KB）的每个 PTE 负责映射虚拟地址空间中一个 4MB 的片（chunk），每一片都由 1024 个连续的页面组成。二级页表中的每个PTE负责映射一个 4KB 的虚拟内存页面。

最后

回到最初的问题，由于虚拟内存 MMU 与 TLB 的存在，多进程运行时效率不会大打折扣；与此同时，每个进程都存在属于自己的页表，所以进程之间也不会相互影响。

内存页

linux 内核中把物理页作为内存分配的最小单位，32位CPU 页的大小通常为4K，64位的CPU通常支持8K的也。内存管理单元MMU 同样以页为大小分配内存。

内存映射

我们通常所说的内存是指物理内存(PC机上的内存条)，也称为主存。为了避免内存数据被篡改，提升内存的读写速度， Linux 内核给每个进程都提供了一个独立的虚拟地址空间，并且这个地址空间是连续的。这样，进程就可以很方便地访问内存，更确切地说是访问虚拟内存。（物理内存只有内核可以访问）

虚拟地址空间的内部又被分为内核空间和用户空间两部分，不同字长（也就是单个 CPU 指令可以处理数据的最大长度）的处理器，地址空间的范围也不同。比如最常见的 32 位和 64 位系统，下面两张图分别表示它们的虚拟地址空间，如下所示：

通过这里可以看出，32 位系统的内核空间占用 1G，位于最高处，剩下的 3G 是用户空间。而 64 位系统的内核空间和用户空间都是 128T，分别占据整个内存空间的最高和最低处（下面是用户空间，上面是内核空间)，剩下的中间部分是未定义的。

进程在用户态(关于用户态和内核态可以阅读前文：点击这里)时，只能访问用户空间内存；只有进入内核态后，才可以访问内核空间内存。虽然每个进程的地址空间都包含了内核空间，但这些内核空间，其实关联的都是相同的物理内存（也就是说内核空间是进程共享的)。这样，进程切换到内核态后，就可以很方便地访问内核空间内存。

那么问题又来了，如果每个进程都有一个这么大的地址空间，那么所有进程的虚拟内存加起来，自然要比实际的物理内存大得多。所以，并不是所有的虚拟内存都会分配物理内存，只有那些实际使用的虚拟内存才分配物理内存，并且分配后的物理内存，是通过内存映射来管理的。

内存映射

内存映射其实就是将虚拟内存地址映射到物理内存地址。为了完成内存映射，内核为每个进程都维护了一张页表，记录虚拟地址与物理地址的映射关系，如下图所示：

页表实际上存储在 CPU 的内存管理单元 MMU 中，这样，正常情况下，处理器就可以直接通过硬件，找出要访问的内存。而当进程访问的虚拟地址在页表中查不到时，系统会产生一个缺页异常，进入内核空间分配物理内存、更新进程页表，最后再返回用户空间，恢复进程的运行。

页表管理

不过要注意，MMU 并不以字节为单位来管理内存，而是规定了一个内存映射的最小单位，也就是页，通常是 4 KB 大小。这样，每一次内存映射，都需要关联 4 KB 或者 4KB 整数倍的内存空间。

如果以4KB内存页为单位管理内存，那整个页表会变得非常大, 4G的物理内存需要100 多万个页表项（4GB/4KB）才可以实现整个地址空间的映射。为了解决页表项过多的问题，Linux 提供了两种机制，也就是多级页表和大页（HugePage）。

多级页表

多级页表就是把内存分成区块来管理，将原来的映射关系改成区块索引和区块内的偏移。由于虚拟内存空间通常只用了很少一部分，那么，多级页表就只保存这些使用中的区块，这样就可以大大地减少页表的项数。

大页(HugePage)

虚拟内存空间分布

我们在回头看一下虚拟内存空间的分布情况。最上方的内核空间不用多讲，下方的用户空间内存，其实又被分成了多个不同的段。以 32 位系统为例，用户空间内存空间从低到高分别是五种不同的内存段。

• 只读段，包括代码和常量等。
• 数据段，包括全局变量等。
• 堆，包括动态分配的内存，从低地址开始向上增长。
• 文件映射段，包括动态库、共享内存等，从高地址开始向下增长。
• 栈，包括局部变量和函数调用的上下文等。栈的大小是固定的，一般是 8 MB。

在这五个内存段中，堆和文件映射段的内存是动态分配的。比如说，使用 C 标准库的 malloc() 或者 mmap() ，就可以分别在堆和文件映射段动态分配内存。 其实 64 位系统的内存分布也类似，只不过内存空间要大得多。

内存分配与回收

内存分配

malloc()是C标准库提供的内存分配函数，对应到系统调用上，有两种实现方式，即brk()和mmap()。

对小块内存（小于128K），C标准库使用brk()来分配，也就是通过移动堆顶的位置来分配内存。这些内存释放后并不会立刻归还系统，而是被缓存起来，这样就可以重复使用。

而大块内存（大于128K），则直接使用内存映射mmap()来分配，也就是在文件映射段找一块空闲内存分配出去。

这两种方式，自然各有优缺点。

• brk()方式的缓存，可以减少缺页异常的发生，提高内存访问效率。不过，由于这些内存没有归还系统，在内存工作繁忙时，频繁的内存分配和释放会造成内存碎片。
• mmap()方式分配的内存，会在释放时直接归还系统，所以每次mmap都会发生缺页异常。在内存工作繁忙时，频繁的内存分配会导致大量的缺页异常，使内核的管理负担增大。这也是 malloc 只对大块内存使用mmap的原因。

了解这两种调用方式后，我们还需要清楚一点，那就是，当这两种调用发生后，其实并没有真正分配内存。这些内存，都只在首次访问时才分配，也就是通过缺页异常进入内核中，再由内核来分配内存。

整体来说，Linux 使用伙伴系统来管理内存分配。前面我们提到过，这些内存在 MMU 中以页为单位进行管理，伙伴系统也一样，以页为单位来管理内存，并且会通过相邻页的合并，减少内存碎片化（比如 brk 方式造成的内存碎片）。

你可能会想到一个问题，如果遇到比页更小的对象，比如不到 1K 的时候，该怎么分配内存呢？实际系统运行中，确实有大量比页还小的对象，如果为它们也分配单独的页，那就太浪费内存了。

所以，在用户空间，malloc通过brk()分配的内存，在释放时并不立即归还系统，而是缓存起来重复利用。在内核空间，Linux则通过slab分配器来管理小内存。你可以把slab看成构建在伙伴系统上的一个缓存，主要作用就是分配并释放内核中的小对象。

内存回收

对内存来说，如果只分配而不释放，就会造成内存泄漏，甚至会耗尽系统内存。所以，在应用程序用完内存后，还需要调用free()或unmap()，来释放这些不用的内存。

当然，系统也不会任由某个进程用完所有内存。在发现内存紧张时，系统就会通过一系列机制来回收内存，比如下面这三种方式：

• 回收缓存，比如使用 LRU（Least Recently Used）算法，回收最近使用最少的内存页面；
• 回收不常访问的内存，把不常用的内存通过交换分区直接写到磁盘中；
• 杀死进程，内存紧张时系统还会通过 OOM（Out of Memory），直接杀掉占用大量内存的进程。

其中，第二种方式回收不常访问的内存时，会用到交换分区（以下简称 Swap）。Swap其实就是把一块磁盘空间当成内存来用。它可以把进程暂时不用的数据存储到磁盘中（这个过程称为换出），当进程访问这些内存时，再从磁盘读取这些数据到内存中（这个过程称为换入）。

第三种方式提到的OOM（Out of Memory），其实是内核的一种保护机制。它监控进程的内存使用情况，并且使用oom_score为每个进程的内存使用情况进行评分：

• 一个进程消耗的内存越大，oom_score就越大；
• 一个进程运行占用的CPU越多，oom_score 就越小。

这样，进程的oom_score越大，代表消耗的内存越多，也就越容易被 OOM 杀死，从而可以更好保护系统。

当然，为了实际工作的需要，管理员可以通过/proc文件系统，手动设置进程的oom_adj，从而调整进程的oom_score。oom_adj的范围是 [-17, 15]，数值越大，表示进程越容易被 OOM 杀死；数值越小，表示进程越不容易被 OOM 杀死，其中 -17 表示禁止 OOM。

1
2
3

# 查看PID 1115的oom_adj配置
root@Devops:~$ cat /proc/1115/oom_adj
-15

用户进程工作在用户态，它是受限的，很多涉及到硬件的操作都无法执行，但是它们又想要取得结果，就只能请求工作在内核态的操作系统帮助完成这些操作，并将操作结果交给用户进程。

系统调用（system call）就是操作系统提供给用户进程请求操作系统做一些特权操作的接口，即为用户进程提供服务的窗口。在Linux下可以通过man syscalls命令查看Linux提供的所有系统调用。

理解系统调用其实很简单，比如有一个程序想要读取a.log文件（例如head -n 1 a.log），读取之前必须先打开文件，但是用户进程是没有权限打开文件的，所以用户进程只能发送一个open()的系统调用请求操作系统去帮忙打开这个文件，操作系统打开这个文件后会将打开的结果——文件描述符交给用户进程，用户进程通过这个文件描述符就能去操作这个文件。

再进一步，用户进程想要从这个打开的文件中读取一行数据，用户进程是没有权限读取文件的，只能发送一个read()系统调用请求操作系统去读取这一行数据，操作系统读取这行数据后就能交给用户进程。

不难发现，系统调用open()和read()都像是函数。其实它们确实都是函数，只不过是比较特殊的由操作系统提供的，一般是由汇编语言编写或参杂了部分汇编代码，因为它们要和硬件交互。

C库包含了所有和系统调用同名的库函数，或者说，这些库函数是对系统调用的封装，执行这些库函数是对系统调用的封装，执行这些库函数时，会发起封装在其内的同名系统调用的请求。例如，C库有open()库函数，它用来打开文件，但是C程序工作在用户模式下，是没有权限打开文件的，于是在执行到open()函数时，open()库函数会发起一个同名的open()系统调用请求操作系统打开文件，同理read()库函数和read()系统调用的关系也是一样的。

对于非C程序，其实本质还是一样的。比如CPython，也有open()函数，它是对C库函数open()的再次封装。所以，在Python程序中调用open()方法打开文件，其实是调用C库的open()函数，再通过open()库函数发起系统调用请求操作系统打开文件，并将结果交给Python程序。

最后，结合前面介绍的中断概念，描述下发起系统调用后的主要过程：

• 发起系统调用，请求操作系统帮忙执行某些操作，这会产生软中断；
• 软中断导致陷入内核，CPU控制权交给操作系统，操作系统处理中断，即执行被请求的操作；
• 如果一切正常，操作系统在完成操作后会恢复到断点处继续向下执行，这会回到用户态；
• 用户进程取得操作系统操作的成果，继续向下执行。

中断的字面意思就是打断正常执行流程，但是注意，它表示的是打断流程而不是终止流程，这是不同的概念。

中断是操作系统中非常重要的机制，正如上面所描述的：中断用于保证CPU控制权交给操作系统，从而让操作系统可以执行某些操作。

中断分为硬件中断和软件中断。

任何硬件，都有自己的IRQ（中断请求），都可以在需要的时候通过总线向CPU发送硬件中断通知。

比如时钟中断，当进程执行耗光时间片时将产生一个时钟中断，使得能够立刻进入操作系统并调度下一个要执行的进程，时钟中断是操作系统具有安全感的保证，只要时钟开始运行后，就意味着操作系统最终总能够获取到CPU控制权。

再比如硬盘的IO中断，当硬盘读取所请求的数据完成后，就会发送硬盘IO中断，CPU接到该中断后就会切换到操作系统，让操作系统去处理这个中断事件。

软件也可以发送中断，比如请求一个系统调用（system call）。

无论是软中断还是硬件中断，最终的目的都是为了回到操作系统，将CPU交给操作系统。那么，中断是如何回到操作系统的呢？换句话说，中断时是如何进入内核态的呢？内核态又如何回到用户态呢？

其实，要进入内核态只需执行特殊的指令即可，一般称之为trap指令，当执行trap指令后，就会进入内核态，回到操作系统。trap这个单词的意思是陷阱，在这里它表示的是动词：陷入，这些事国人翻译的意思, 非常形象，它表示的是执行trap指令以便陷入到内核，即进入内核态。

当操作系统执行完相关操作后，就要回到用户态，要回到用户态也只需执行特殊的指令即可，一般称之为return-from-trap指令。（此处的trap又似乎是个名词，表示脱离陷阱，回到用户态之下。

它将内核态描述为陷阱，这其实也是可以理解的，中断是事件，收到事件表示捕获到事件，什么具有捕获的能力？陷阱。在bash中也有一个trap命令，也可以理解为陷进，它用来设置信号处理程序，当捕获到信号时就做出某些处理。我们不管trap是陷入还是陷阱，我们关注的是作用：进入内核态和退出内核态。）

中断既然是打断CPU的执行流程，那么可能需要重新回到中断点继续正常的执行流程。所以，在发生中断时，需要保存好中断点以及相关的一些状态，以便能够在处理完中断后恢复执行流程继续向下执行。

所以，中断就像是突发事件，处理完成后如果恢复到断点处，那么对整个流程来说，中断就像是从未发生过的事一样，但却实实在在的被处理了。

但是，中断后并不一定会恢复到断点处，因为中断处理程序可能会在恢复断点前直接退出这个执行流程，比如有些硬件中断表示一些异常现象（比如除0异常），这些异常可能会导致终止进程。

Unix/Linux的体系架构

如上图所示，从宏观上来看，Linux操作系统的体系架构分为用户态和内核态（或者用户空间和内核）。内核从本质上看是一种软件——控制计算机的硬件资源，并提供上层应用程序运行的环境。用户态即上层应用程序的活动空间，应用程序的执行必须依托于内核提供的资源，包括CPU资源、存储资源、I/O资源等。为了使上层应用能够访问到这些资源，内核必须为上层应用提供访问的接口：即系统调用。

三者的关系如下：

现代计算机系统中，所有的硬件资源都是由操作系统负责管理的，硬件资源包括 CPU 的使用时间、物理内存的使用、硬盘的读写等等。操作系统内核当然是工作在内核态下，普通的用户进程工作在用户态下。

处于内核态的操作系统内核对于硬件有不受限制的使用权限，并且可以执行任何 CPU 指令以及访问任意的内存地址。

而用户态进程没有能力直接操作硬件，也没有能力访问任意的内存地址空间。用户态进程只能通过操作系统内核提供的系统调用受限地使用硬件资源。并且用户态进程不能执行一些 CPU 特权指令。

用户态的应用程序可以通过三种方式来访问内核态的资源：

• 系统调用
• 库函数
• Shell脚本

下图是对上图的一个细分结构，从这个图上可以更进一步对内核所做的事有一个“全景式”的印象。

主要表现为：向下控制硬件资源，向内管理操作系统资源：包括进程的调度和管理、内存的管理、文件系统的管理、设备驱动程序的管理以及网络资源的管理，向上则向应用程序提供系统调用的接口。

从整体上来看，整个操作系统分为两层：用户态和内核态，这种分层的架构极大地提高了资源管理的可扩展性和灵活性，而且方便用户对资源的调用和集中式的管理，带来一定的安全性。 　　

CPU指令级别

在CPU的所有指令中，有一些指令是非常危险的，如果错用，将导致整个系统崩溃。所以，CPU将指令分为特权指令和非特权指令，对于那些危险的指令，只允许操作系统及其相关模块使用，普通的应用程序只能使用那些不会造成灾难的指令。

intel cpu提供Ring0-Ring3四种级别的运行模式，Ring0级别最高，Ring3最低。Linux使用了Ring3级别运行用户态，Ring0作为 内核态。

对不同的操作赋予不同的执行等级，就是所谓特权的概念。简单说就是有多大能力做多大的事，与系统相关的一些特别关键的操作必须由最高特权的程序来完成。

Intel的X86架构的CPU提供了0到3四个特权级，数字越小，特权越高，Linux操作系统中主要采用了0和3两个特权级，分别对应的就是内核态和用户态。

用户态和内核态的切换

运行于用户态的进程可以执行的操作和访问的资源都会受到极大的限制，而运行在内核态的进程则可以执行任何操作并且在资源的使用上没有限制。

很多程序开始时运行于用户态，但在执行的过程中，一些操作需要在内核权限下才能执行，这就涉及到一个从用户态切换到内核态的过程。

比如C函数库中的内存分配函数malloc()，它具体是使用sbrk()系统调用来分配内存，当malloc调用sbrk()的时候就涉及一次从用户态到内核态的切换，类似的函数还有printf()，调用的是wirte()系统调用来输出字符串，等等。

　 到底在什么情况下会发生从用户态到内核态的切换，一般存在以下三种情况：

• 当然就是系统调用：原因如上的分析。
• 异常事件： 当CPU正在执行运行在用户态的程序时，突然发生某些预先不可知的异常事件，这个时候就会触发从当前用户态执行的进程转向内核态执行相关的异常事件，典型的如缺页异常。
• 外围设备的中断：当外围设备完成用户的请求操作后，会像CPU发出中断信号，此时，CPU就会暂停执行下一条即将要执行的指令，转而去执行中断信号对应的处理程序，如果先前执行的指令是在用户态下，则自然就发生从用户态到内核态的转换。

注意：系统调用的本质其实也是中断，相对于外围设备的硬中断，这种中断称为软中断，这是操作系统为用户特别开放的一种中断，如Linux int 80h中断。所以，从触发方式和效果上来看，这三种切换方式是完全一样的，都相当于是执行了一个中断响应的过程。但是从触发的对象来看，系统调用是进程主动请求切换的，而异常和硬中断则是被动的。