谷歌中国开发部 代码随笔

{
"version": "0.2.0",
"configurations": [
{
"name": "LaunchGo",
"type": "go",
"request": "launch",
"mode": "auto",
"program": "${workspaceRoot}/main.go",

        "args": ["./config/configtest.toml"],
        "dlvLoadConfig": {
            "followPointers": true,
            "maxVariableRecurse": 1,
            "maxStringLen": 1000, //字符串最大长度
            "maxArrayValues": 64,
            "maxStructFields": -1
            }
    }
]

}

fmt.Println(([unsafe.Sizeof(v)]byte)(unsafe.Pointer(&v)))

go get github.com/golang/protobuf/protoc-gen-go

insert into staticcard(uid, cnt11) (select c.uid uid, count(c.uid) cnt11 from (select b.uid uid from order_999.order_extra_data a join order_999.order_record b On date(a.update_time) between '2021-09-08' and '2021-09-08' && a.order_id = b.order_id && b.channel_id = 11 && a.card_num != "____" && a.card_num != "" group by b.uid, a.card_num) c group by c.uid) on duplicate key update cnt11 = values(cnt11);

1.建立服务目录： mk svrpath && cd svrpath
2.在当前路径建立虚拟环境： python3 -m venv myenv
3.激活虚拟环境： source myenv/bin/activate
4.在虚拟环境安装本服务依赖的所有package： pip install -r requirements.txt，

yum install python3
yum install pip3
pip3 install --upgrade pip
pip3 install tensorflow

jupyter notebook --generate-config
jupyter notebook password
jupyter_notebook_config.json "notebook_dir":"/root/note", "port" =8888,"ip":"*",
jupyter notebook --allow-root &

go tool objdump -s "main.main\b" checkout

ulimit -c unlimited export GOTRACEBACK=crash
ulimit -c unlimited 设置core文件大小为不限制大小

config max-string-len 99999

watch -n 1 echo nice
while true; do echo nice;sleep 1; done
cat *|grep -ioP 'country:\w+'
cat *|grep -ioP 'country[^\ ]+'

redis事务，一个队列中，一次性、顺序性、排他性的执行一系列命令

采用MyISAM
R/W > 100:1 且update相对较少
并发不高
表数据量小
硬件资源有限

采用InooDB引擎
R/W比较少，频繁更新大字段
表数据量超过1000万，并发高
安全性和可用性要求高

READ UNCOMMITTED (未提交读) ：隔离级别：0. 哪个问题都不能解决
READ COMMITTED (提交读) ：隔离级别：1. 可以解决脏读
REPEATABLE READ (可重复读) ：隔离级别：2. 可以解决脏读和不可重复读，实现不幻读，需要加锁
SERIALIZABLE （可串行化）：隔离级别：3.

performance_schema的表中的数据不会持久化存储在磁盘中，
而是保存在内存中，一旦服务器重启，这些数据会丢失（包括配置表在内的整个performance_schema下的所有数据）

禁用insert into …on duplicate key update…在高并发环境下，会造成主从不一致。

当使用了 PreparedStatement，带占位符 ( ? ) 的 sql 语句只会被编译一次，之后执行只是将占位符替换为用户输入，并不会再次编译/解释，因此从根本上防止了 SQL 注入问题。

变长字段长度列表
若列的长度小于255字节，用1字节表示
若列的长度大于255字节，用2字节表示（varchar最大限制为65535）

窗口函数
select order_id, uid, goods_id, status,
rank() over (partition by uid
order by goods_id desc) as ranking
from pay_flow

在SQL中执行的顺序

1. 先连接from后的数据源(若有join，则先执行on后条件，再连接数据源)。
2. 执行where条件
3. 执行group by
   4.执行having
   5.执行order by

NULL标志位
占用字节为(可为NULL的列数量/8)向上取整,字节中哪一位为1，表示该行数据对应列为NULL值

如果LIKE的参数是一个不以通配符开头的常量字符串，索引也可以用于LIKE比较
当优化器估计到使用索引将需要MySQL访问表中的大部分行时，在这种情况下，表扫描可能会更快些，因为需要的搜索要少
锁定表可以加速用多个语句执行的INSERT操作，因为索引缓存区仅在所有INSERT语句完成后刷新到磁盘上一次。

MyISAM 非聚集索引
MyISAM 不支持事务和行级锁，而且最大的缺陷就是崩溃后无法安全恢复。
MyISAM存储引擎
不支持事务
缓冲池只缓存索引文件，不缓冲数据文件
由MYD和MYI文件组成，MYD用来存放数据文件，MYI用来存放索引文件

InnoDB存储引擎
唯一索引的范围查询会到第一个不符合的值位置

独立表空间，支持MVCC，行锁设计，提供一致性非锁定读
支持外键，插入缓冲，二次写，自适应哈希索引，预读
使用聚集的方式存储数据，每张表的存储都是按主键顺序存放。
InnoDB 提供事务支持，支持行级锁(row-level locking)和表级锁,默认为行级锁。
InnoDB 聚集索引 索引和数据一体，必须有主键，没有找一个唯一标识的列，或者生成一个6个字节的长整型
辅助索引data域存储相应记录主键的值
脏读，不可重复度，幻读的特性。

数据空洞，表重建
optimize table pay_flow;
select concat(round(sum(DATA_LENGTH/1024/1024),2),'M')
from information_schema.tables where table_schema='pay' AND table_name = 'pay_flow';

阻塞IO、非阻塞IO、多路复用IO、信号驱动IO以及异步IO
创建，就绪，运行，阻塞，终止
bss block storage segment(Block Started by Symbol)
已初始化的全局变量保存在.data 段中，未初始化的全局变量保存在.bss 段中
text和data段都在可执行文件中（在嵌入式系统里一般是固化在镜像文件中），由系统从可执行文件中加载；
而bss段不在可执行文件中，由系统初始化。

分配器由三种组件组成。
• cache: 每个运⾏期⼯作线程都会绑定⼀个 cache，⽤于⽆锁 object 分配。
• central: 为所有 cache 提供切分好的后备 span 资源。
• heap: 管理闲置 span，需要时向操作系统申请新内存。

lsof -p 10075 使用-p查看指定进程ID已打开的内容
lsof abc.txt 显示开启文件或者目录abc.txt的进程
lsof -i :22 知道22端口现在运行什么程序
lsof -c abc 显示abc命令现在打开的文件
lsof +d /usr/local/ 显示目录下被进程开启的文件
lsof +D /usr/local/ 同上，但是会搜索目录下的目录，时间较长
lsof -d 4 显示使用fd为4的进程
lsof -g gid 显示归属gid的进程情况
lsof -i 用以显示符合条件的进程情况
lsof -r会永远不断的执行，直到收到中断信号
lsof -s 列出打开文件的大小，如果没有大小，则留下空白

cat static.log |awk '{print $8}'
cat static.log |awk '{sum += $8}; END { print sum }'
cat /etc/passwd | awk -F: ' { print $1 } '
awk '{printf "%-8s %-10s\n",$1,$4}'

-t 指定一个分隔符

-k 后面跟数字，指定按第几列进行排序

-r 反序排序（升序变成降序）

按“：”做分隔符，以第3列，来从大到小排序

sort -t ":" -nk3 -r /etc/passwd

ll /etc |more -10

数据拆分，服务拆分，适当增长服务链路，尽量缩短访问链路，降低单次访问的资源消耗

进程调试命令:truss、strace和ltrace

protoc -I ./ user_info.proto --go_out=plugins=grpc:.

python 服务部署规范:
1.建立服务目录： mk svrpath && cd svrpath
2.在当前路径建立虚拟环境： python3 -m venv myenv
3.激活虚拟环境： source myenv/bin/activate
4.在虚拟环境安装本服务依赖的所有package： pip install -r freeze.txt

将密钥上传至Linux服务器，并修改权限。以文件king.pem为例:
chmod 600 king.pem
修改密钥格式为OpenSSH，如果询问，留空回车：
ssh-keygen -p -f king.pem
生成公钥.pub文件：
ssh-keygen -e -f king.pem >> king.pem.pub
下载生成.pub文件，在使用SecrueCRT连接时指定相应pub文件即可。

ssh-keygen -t rsa
git config --global --add url."git@github.com:".insteadOf "https://github.com/"
git config --global http.extraHeader "PRIVATE-TOKEN: JRdrr8bzsPRCBuqD1TG3"
git config --global url."https://pay:JRdrr8bzsPRCBuqD1TG3@github.com".insteadOf /
"https://github.com"

export GIT_TERMINAL_PROMPT=1
go env -w CGO_ENABLED=0

wate@tencent.com
git tag -a "v1.15.0" -m "base"
git push --follow-tags
git push origin gostripe -u --follow-tags

git tag -d v1.7.0
git push origin :v1.7.0

Host paytest
HostName 188.243.83.1
User dev
IdentitiesOnly yes

58.089.133/0001-66

wget https://dl.google.com/go/go1.16.4.linux-amd64.tar.gz
tar -zxvf go1.16.4.linux-amd64.tar.gz
export PATH=$PATH:/usr/local/go/bin
source $HOME/.profile

未执行 git add 操作 git restore file_name、git checkout -- file_name 或者 git reset --hard HEAD
执行了 git add 操作 git restore --staged newfile、 git rm --cached newfile或者 git reset HEAD newfile
修改或删除后执行了 git add、git commit 操作 git reset --soft HEAD^
HEAD^^ 表示倒数第三版本，HEAD^^^ 表示倒数第四版本
HEAD~1 表示最新版本的前一版，也就是倒数第二版本，HEAD~2 表示倒数第三版本，HEAD~3 表示倒数第四版本
git push -f

git reset HEAD^^ 命令还原两次提交，然后在工作区将文件按第二次修改再改一次进行提交
只是想还原第一次修改，那么可以使用 git revert HEAD^ 命令来反向修改那一次变化，修改之后会自动添加到暂存区，等待提交。

stdout_logfile = /data/log/3rd/gopay/out.log
stderr_logfile = /data/log/3rd/gopay/error.log

interface{}变量比较特殊，判断它是nil时，要求它的类型和值都是nil，即(nil, nil)

// 将第三个元素切片，并限制容量（6-2）
// 其长度为1个元素，容量为4个元素
myFruit := fruit[2:3:6]

m := map[string]data {"x":data{"three"}}
//m["x"].print() //error
d2 = m["x"]
d2.print() // ok

m := map[string]data {"x":{"one"}}
//m["x"].name = "two" //error
r := m["x"]
r.name = "two"
m["x"] = r
fmt.Println(s)       // prints: map[x:{two}]

mp := map[string]*data {"x": {"one"}}
mp["x"].name = "two" // ok

s := []data{{"one"}}
s[0].name = "two"    // ok
fmt.Println(s)       // prints: [{two}]

互斥条件，不可剥夺条件，请求和保持条件，循环等待条件

陷阱指令可以使执行流程从用户态陷入内核并把控制权转移给操作系统，使得用户程序可以调用内核函数和使用硬件从而获得操作系统所提供的服务

b: 块设备文件
c：字符设备文件
d：目录
-：普通文件
l：链接
s：socket
p：管道

如果两种类型具有相同的内存结构，我们可以将unsafe.Pointer当作桥梁，让这两种类型的指针相互转换，从而实现同一份内存拥有两种解读方式

向已关闭的 channel 发送数据会造成 panic
在一个值为 nil 的 channel 上发送和接收数据将永久阻塞

Golang GC 的基本特征是 “⾮分代、⾮紧缩、写屏障、并发标记清理”。

堆上动态分配内存比栈上静态分配内存，开销大很多。
变量分配在栈上需要能在编译期确定它的作用域，否则会分配到堆上。
Go编译器会在编译期对考察变量的作用域，并作一系列检查，如果它的作用域在运行期间对编译器一直是可知的，那么就会分配到栈上。简单来说，编译器会根据变量是否被外部引用来决定是否逃逸。
对于Go程序员来说，编译器的这些逃逸分析规则不需要掌握，我们只需通过go build -gcflags '-m'命令来观察变量逃逸情况就行了。
不要盲目使用变量的指针作为函数参数，虽然它会减少复制操作。但其实当参数为变量自身的时候，复制是在栈上完成的操作，开销远比变量逃逸后动态地在堆上分配内存少的多。
最后，尽量写出少一些逃逸的代码，提升程序的运行效率。

SB: Staic Base Pointer，静态内存 的开始地址
FP: Frame Pointer，对应函数的帧指针，一般用来访问函数的参数和返回值
SP: Stack Pointer，分伪SP 与真SP
伪 SP：位于当前栈帧(frame)底部，用于定位局部变量 ，形如 tmp-2(SP)，即相对与真 SP 地址偏移量
真 SP：位于当前栈帧(frame)顶部，用于定位调用其他函数的 参数 和 返回值

函数尽量不要返回map， slice对象, 这种频繁调用的函数会给gc 带来压力。
小对象要合并。
函数频繁创建的简单的对象，直接返回对象，效果比返回指针效果要好。
避不开，能用sync.Pool 就用，虽然有人说1.10 后不推荐使用sync.Pool，但是压测来看，确实还是用效果，堆累计分配大小能减少一半以上。
类型转换要注意，官方用法消耗特别大，推荐使用的方式。
避免反复创建slice。

编译参数介绍(-gcflags):
-N: 禁止编译优化
-l: 禁止内联(可以有效减少程序大小)
-m: 逃逸分析(最多可重复四次)
-benchmem: 压测时打印内存分配统计

APP要符合12因子（Twelve-Factor）的规范：
基准代码（Codebase）：代码必须纳入配置库统一管理。
依赖（Dependencies）：显式的声明对其他服务的依赖，比如通过Maven、Bundler、NPM等。
配置（Config）：对于不同环境（开发/staging/生产等）的参数配置，是通过环境变量的方式进行注入。
后台服务（Backing services）：对于DB、缓存等后台服务，是作为附加资源，可以独立的Bind/Unbind。
编译/发布/运行（Build、Release、Run）：Build、Release、Run这三个阶段要清晰的定义和分开。
无状态进程（Processes）：App的进程是无状态的，任何状态信息都存储到Backing services（DB，缓存等）。
端口绑定（Port binding）：App是自包含的，所有对外服务通过Port Binding暴露，比如通过Http。
并发（Concurrency）：App可以水平的Scaling。
快速启动终止（Disposability）：App进程可以被安全的、快速的关闭和重启。
环境一致性（Dev/prod parity）：尽可能的保持开发、staging、线上环境的一致性。
日志（Logs）：把日志作为事件流，不管理日志文件，通过一个集中的服务，由执行环境去收集、聚合、索引、分析日志事件。

gcc .\h.cpp -o h.exe -lstdc++
g++ .\h.cpp

mysqldump -h192.168.11.1 -uroot -p123456 --all-databases > /tmp/sqlfile.sql

redis cluster，10 台机器，5 台机器部署了 redis 主实例，另外 5 台机器部署了 redis 的从实例，每个主实例挂了一个从实例，5 个节点对外提供读写服务，每个节点的读写高峰qps可能可以达到每秒 5 万，5 台机器最多是 25 万读写请求/s。

机器是什么配置？32G 内存+ 8 核 CPU + 1T 磁盘，但是分配给 redis 进程的是10g内存，一般线上生产环境，redis 的内存尽量不要超过 10g，超过 10g 可能会有问题。

1、什么是Redis？
2、Redis有哪些数据结构？
3、Redis相比memcached有哪些优势？
4、Redis有哪些适合的场景？
5、Redis有哪几种数据淘汰策略？
6、使用过Redis分布式锁么，它是什么回事？
7、假如Redis里面有1亿个key，其中有10w个key是以某个固定的已知的前缀开头的，如何将它们全部找出来？
8、由7接着问：如果这个redis正在给线上的业务提供服务，那使用keys指令会有什么问题？
9、如果有大量的key需要设置同一时间过期，一般需要注意什么？
10、如何处理redis集群中big key和hot key？
11、MySQL里有2000w数据，redis中只存20w的数据，如何保证redis中的数据都是热点数据？
12、使用过Redis做异步队列么，你是怎么用的？
13、如果对方追问redis如何实现延时队列？
14、说说Redis哈希槽的概念？
15、Redis中的Pipeline有什么好处，为什么要用pipeline？
16、Redis与其他key-value存储有什么不同？
17、Redis和Redisson有什么关系？
18、Jedis与Redisson对比有什么优缺点？
19、支持一致性哈希的客户端有哪些？
20、Twemproxy是什么？
21、怎么理解Redis事务？
22、Redis回收进程如何工作的？
23、Redis回收使用的是什么算法？
24、Redis如何做大量数据插入？
25、为什么要做Redis分区？
26、你知道有哪些Redis分区实现方案？
27、Redis分区有什么缺点？
28、为什么Redis需要把所有数据放到内存中？
29、Redis的内存占用情况怎么样？
30、都有哪些办法可以降低Redis的内存使用情况呢？
31、Redis的内存用完了会发生什么？
32、Redis如何做内存优化？
33、Redis如何做持久化的？
34、对方追问bgsave的原理是什么？
35、Redis提供了哪几种持久化方式？
36、如何选择合适的持久化方式？
37、Redis是单线程的，如何提高多核CPU的利用率？
38、Redis常见性能问题和解决方案？
39、修改配置不重启Redis会实时生效吗？
40、Redis的同步机制了解么？
41、是否使用过Redis集群，集群的原理是什么？
42、Redis集群方案应该怎么做？都有哪些方案？
43、Redis集群方案什么情况下会导致整个集群不可用？
44、Redis集群的主从复制模型是怎样的？
44、Redis的集群方案之间都有哪些区别，其优点和缺点是什么？
45、Redis集群会有写操作丢失吗？为什么？
46、Redis集群之间是如何复制的？
47、Redis集群最大节点个数是多少？
48、一个Redis实例最多能存放多少的keys？List、Set、Sorted Set他们最多能存放多少元素？
49、Redis持久化数据和缓存怎么做扩容？
50、分布式Redis是前期做还是后期规模上来了再做好？为什么？