伪技术 on 黑猫说

软路由系列--Others

Thu, 08 Feb 2024 20:40:00 +0000

Others

还有一些其他的点，顺带记录下

Samba

安装软件后，配置目录，添加smb用户和密码

apt install samba

vim /etc/samba/smb.conf

[global]
  workgroup = SAMBA
  security = user
  passdb backend = tdbsam
  printing = cups 
  printcap name = cups
  load printers = yes
  cups options = raw

[other]
  comment = other
  path = /data/other
  browseable = yes
  writable = yes
  public = yes
  write list = +smbuser1

smbpasswd -a smbuser1  # 添加用户，设置密码，这个密码是samba的密码

把Sonarr的docker IP添加到Transmission 访问白名单

Transmission我们是docker安装的，所以白名单的IP是docker的IP，我们使用以下命令获取到sonarr的IP

docker network inspect sonarr_default

假设得到的是172.18.0.1，那么我们在transmission的配置文件中添加以下内容即可，这样的话，sonarr就可以访问transmission了

- WHITELIST=127.0.0.1,10.0.3.*,172.17.*.*
- HOST_WHITELIST=127.0.0.1,10.0.3.*,172.17.*.*

fstab

# /etc/fstab
# <file system> <mount point>   <type>  <options>       <dump>  <pass>
UUID=xxxxxx /data/other ext4 defaults 0 0

其中的UUID可以使用blkid命令获取，填入即可

rc.local

vim /etc/systemd/system/rclocal.service

[Unit]
Description=Other Starting Scripts
After=network.target

[Service]
ExecStart=/opt/rclocal/rc.local

[Install]
WantedBy=multi-user.target

chmod +x /etc/systemd/system/rclocal.service
systemctl enable rclocal

vim /opt/rclocal/rc.local

#!/bin/bash
# your commands
iptables -t nat -A POSTROUTING -j MASQUERADE # 开启nat
sdparm --flexible -6 -l --set SCT=6000 --set STANDBY=1 /dev/sda # 设置硬盘休眠时间

软路由系列--Docker

Thu, 08 Feb 2024 20:30:00 +0000

Why Docker

为什么要用Docker，而不是直接安装软件？或者用虚拟机？

问题1 直接安装，最大的是依赖问题，杂七杂八的会搞乱系统问题2 虚拟机，比较复杂，占用资源，多一层虚拟化，性能损耗

Docker 安装

直接看官方系统吧

docker install on ubuntu

Docker 软件列表

linuxserver

可以安装如下软件

sonarr
transmission
jackett
emby
and so on

建议大家使用docker compose来管理你的docker，存到单独一个软件的文件夹，这样方便管理

---
version: "2.1"
services:
  sonarr:
    image: ghcr.io/linuxserver/sonarr:latest
    container_name: sonarr
    environment:
      - PUID=1000
      - PGID=1000
      - TZ=Asia/Shanghai
    volumes:
      - /docker/sonarr/config:/config # 建议每个软件都有自己的配置文件夹,数据隔离
      - /path/to/your/local/tv:/tv #optional
      - /path/to/your/local/downloads:/downloads #optional
    ports:
      - 8989:8989
    restart: unless-stopped

软路由系列--续篇--代理和DNS设置

Thu, 08 Feb 2024 20:00:00 +0000

为啥要写这个

之前买的零刻N-305小主机很好用，又买了一个，替换掉服役6年的小马n3700。趁这次机会，记录下代理和DNS的设置。

Clash代理

这个我不多说了，大家google一下，网上很多，我记录下与软路由的集成。

禁用Ubuntu自带的DNS

systemctl disable systemd-resolved

vim /etc/resolv.conf

nameserver 10.0.1.1 # 这里是你的软路由的ip

开启dhcp服务,给其他设备分配ip或者提供dns服务

 apt install dnsmasq

编辑配置文件, 设置dhcp的网段，dns，dns解析文件，端口

vim /etc/dnsmasq.conf

interface=br0
dhcp-range=10.0.1.2,10.0.1.254,72h
dhcp-option=6,10.0.1.1
resolv-file=/etc/resolv.dnsmasq.conf
port=1053 # 这里我改成了1053，我其他地方有个dns服务，端口是53，所以这里改成了1053

Clash的DNS设置

这样的话，相当于你有一个本地的DNS代理，你上游是一些可信的DNS服务器，比如谷歌的，还有一些是宽带运营商的，同时开启fake-ip 模式，这样的话，你的设备比如访问一个被墙的网站，会被Clash代理到一个假的ip地址，你不需要单独设置iptables规则，直接可以透明翻墙。

dns:
  enable: true
  listen: 0.0.0.0:53
  default-nameserver:
    - 8.8.4.4
    - 1.1.1.1
    - 8.8.8.8
    - 114.114.114.114
  enhanced-mode: fake-ip
  fake-ip-range: 198.18.0.1/16 # Fake IP addresses pool CIDR

  nameserver:
    - 202.101.172.35
    - 202.101.172.47
    - 8.8.8.8 # default value
    - tls://dns.rubyfish.cn:853 # DNS over TLS
    - tls://dns.google:853
    - https://1.1.1.1/dns-query # DNS over HTTPS
    - dhcp://enp1s0 # dns from dhcp
  fallback:
    - tls://1.0.0.1:853
    - tls://dns.google:853
  fallback-filter:
    geoip: true
    ipcidr:
      - 240.0.0.0/4

软路由系列--路由器系统-Ubuntu

Sat, 08 Jul 2023 21:00:00 +0000

软路由的系统

软路由系统安装篇1也是写于三年前左右了

自己的软路由系统一直在用linux发行版，第一次使用软路由是2018年了，当时使用的是centos7，还是小马的软路由n3700,当时自己加配了8G内存，也就是4C8G,固态硬盘120，而后这个固态也在今年挂掉了，4月份还重装了下系统，由于配置还在，所以当时继续沿用了centos7

不过呢，最近刚好入手了一个零刻的小主机，i3-N305, 8核8线程，1.8GHz->3.8GHz, 16G,512G。最近也是想换个系统了，因为centos7的软件源太老了，带的内核还是3.10的，官方也没人维护了，索性切换到Ubuntu 22.04.02了，内核5.15(晚些换成6)

Ubuntu 22.04.02

我选择的是server版本，安装的时候，根本不会跳出来GUI，全部命令行，超级nice，而且很贴心的自动把SSH远程访问勾选了，只要安装好，就可以使用远程登陆了，也不需要自己开启了。

开启软路由功能

apt install bridge-utils

编辑 netplan yaml文件,这台主机只有两个网口，所以搞个bridge，而后一个网口当做wan口，一个网口当做lan口，把lan口加入到bridge中即可

vim /etc/netplan/00-installer-config.yaml

network:
  ethernets:
    enp1s0:
      dhcp4: true
    enp2s0:
      dhcp4: no
  bridges:
    br0:
      dhcp4: no
      addresses: [10.0.1.1/24]
      nameservers:
        addresses: [8.8.8.8]
      interfaces: [enp2s0]
  version: 2

应用配置，并且查看信息

netplan apply

brctl show

类似以下就成功了，其中enp2s0 就是lan口，你下面挂其他wifi放大器，或者交换机等等

bridge name	bridge id		STP enabled	interfaces
br0		8000.6aa01d4c1f71	no		enp2s0

开启dhcp服务,给其他设备分配ip或者提供dns服务

 apt install dnsmasq

编辑配置文件, 设置dhcp的网段，dns，dns解析文件，端口

vim /etc/dnsmasq.conf

interface=br0
dhcp-range=10.0.1.2,10.0.1.254,72h
dhcp-option=6,10.0.1.1
resolv-file=/etc/resolv.dnsmasq.conf
port=1053 # 这里我改成了1053，我其他地方有个dns服务，端口是53，所以这里改成了1053

如果有自己的dns proxy，这里要注意，ubuntu有个默认的resolv.service,可以把他禁用掉，不然会冲突

systemctl disable systemd-resolved

开启linux转发和nat功能

vim /etc/sysctl.conf

net.ipv4.ip_forward=1
net.ipv6.conf.all.forwarding=1

sysctl -p /etc/sysctl.conf

iptables -A FORWARD -j ACCEPT
iptables -t nat -A POSTROUTING -j MASQUERADE

完结

这样就完结了，一个软路由就可以玩了.

go解决c10k problem(二)--db版下单场景

Sat, 14 Jan 2023 17:20:00 +0000

TL;DR

前言

这是一篇去年8月写的文章，本来是希望达到10k, 不过实际测试并没有成功，最终达到了1000+的事务，完成C10K的一个K，还有9个 :(

DB选择

DB	类型	业务	io
Mysql	sql，支持事务，有缓存	强sql，强类型，类似java	B & B+
Postgres	sql，支持事务
Mongo	nosql，key-value DB，读很快	弱sql，非强制，类似js	B+
Redis	nosql	just kv，代码复杂
sqlite3	sql	强sql，支持事务	Btree

初步结论，理论上是随便用，先用sqlite3把，如果性能达不到，再来排查原因和更改DB

业务场景

我们设计一个sticker网站，可以售卖sticker，用户可以购买sticker，sticker是有库存的，如果用户的余额足够，则可以售卖，另外售卖的过程中，如果库存没了的话，需要回滚订单。

主要对象

用户
商品，库存字段也在商品身上
订单

主要流程

商品的详情页面，get v1/api/sticker/:id
商品的点赞+1接口，post v1/api/sticker/likes
下单接口，post v1/api/order
订单查看接口，get v1/api/order/:id

表现

get 接口读

load

PID USER PR NI VIRT RES SHR S %CPU %MEM TIME+ COMMAND 
10154 ubuntu 20 0 1757000 36888 10020 R 362.7 0.1 2:48.41 main 
9046 ubuntu 20 0 2125668 31976 9876 S 346.3 0.1 2:51.78 server

QPS表现

耗时	并发数	成功数	qps	最长耗时	最短耗时	平均耗时	下载字节	字节每秒	状态码
1s	100	14296	15228.54	39.92	0.28	6.57	2,201,584	2,201,538	200:14296
2s	100	29744	15753.80	39.92	0.28	6.35	4,580,576	2,290,266	200:29744
3s	100	45190	15899.55	39.92	0.28	6.29	6,959,260	2,315,325	200:45228

下单接口事务写

PID USER PR NI VIRT RES SHR S %CPU %MEM TIME+ COMMAND 
9046 ubuntu 20 0 5731688 145260 10004 S 11.0 0.4 8:56.24 server 
10310 ubuntu 20 0 1535804 21276 9868 S 2.3 0.1 0:45.78 main

耗时	并发数	成功数	qps	最长耗时	最短耗时	平均耗时	下载字节	字节每秒	状态码
1s	78	234	462.62	921.42	0.88	216.16	4,854	4,853	200:234
2s	96	468	339.03	1723.88	0.88	294.95	9,632	4,813	200:468
3s	97	671	300.53	2843.52	0.88	332.75	13,697	4,564	200:671
4s	99	891	267.94	3300.58	0.85	373.22	18,217	4,553	200:891
5s	100	1127	265.51	4121.60	0.85	376.64	22,887	4,577	200:1127
6s	100	1352	254.29	4121.60	0.84	393.26	27,634	4,605	200:1352
7s	100	1556	243.91	5965.82	0.84	409.99	31,668	4,523	200:1556
8s	100	1750	244.42	5965.82	0.84	409.13	35,364	4,419	200:1750
9s	100	2014	242.56	5965.82	0.84	412.27	40,688	4,520	200:2014
10s	100	2266	242.84	5965.82	0.79	411.79	45,980	4,597	200:2266
11s	100	2505	243.15	6417.73	0.79	411.28	50,668	4,606	200:2505
12s	100	2769	243.57	6417.73	0.79	410.56	56,198	4,683	200:2769
13s	100	2954	240.99	6417.73	0.72	414.96	59,611	4,585	200:2954
14s	100	3201	240.45	6417.73	0.72	415.89	64,578	4,612	200:3201
15s	100	3437	237.23	6417.73	0.72	421.53	69,516	4,634	200:3437
16s	100	3622	235.57	6417.73	0.72	424.51	73,425	4,588	200:3622
17s	100	3800	235.41	6417.73	0.72	424.79	76,927	4,525	200:3800
18s	100	3990	234.07	6417.73	0.72	427.21	80,603	4,477	200:3990
19s	100	4176	233.61	6417.73	0.72	428.07	84,177	4,430	200:4176
20s	100	4328	229.46	6417.73	0.72	435.81	87,093	4,354	200:4328
21s	100	4506	229.19	6417.73	0.72	436.32	90,583	4,313	200:4506
22s	100	4701	222.47	6417.73	0.72	449.51	94,600	4,299	200:4701
23s	100	4862	219.28	6417.73	0.72	456.03	97,841	4,253	200:4862
24s	100	5031	216.87	6417.73	0.72	461.10	101,150	4,214	200:503
25s	100	5199	216.08	6417.73	0.72	462.78	104,284	4,171	200:519
26s	100	5374	213.84	6417.73	0.72	467.64	107,871	4,148	200:537
27s	100	5546	212.53	6417.73	0.72	470.52	111,251	4,120	200:554
28s	100	5718	211.58	6417.73	0.72	472.63	114,633	4,093	200:571
29s	100	5893	208.82	6417.73	0.72	478.87	118,122	4,073	200:58

iostat -d -m 1 10

Device tps MB_read/s MB_wrtn/s MB_dscd/s MB_read MB_wrtn MB_dscd
xvda 701.00 0.00 7.82 0.00 0 7 0 
xvda 867.00 0.00 9.66 0.00 0 9 0 
xvda 990.00 0.00 11.00 0.00 0 11 0 
xvda 906.00 0.00 10.75 0.00 0 10 0 
xvda 787.00 0.00 8.62 0.00 0 8 0 
xvda 240.00 0.00 2.64 0.00 0 2 0 
xvda 387.00 0.00 4.25 0.00 0 4 0

问题出现了

tps 只有200，而且是在8核32G内存的机器上，cpu没有瓶颈，内存也没有，问题出在哪里？

1 慢sql

下单的时候，会读取用户和产品表，此时慢sql

2022/08/04 09:55:45 /home/ubuntu/go/src/c10k-go/cmd/server/server.go:71 SLOW SQL >= 200ms [1210.759ms] [rows:1] SELECT * FROM `users` WHERE `name` = "demo-9475" AND `users`.`deleted_at` IS NULL ORDER BY `users`.`id` LIMIT 1

2022/08/04 09:55:45 /home/ubuntu/go/src/c10k-go/cmd/server/server.go:81 SLOW SQL >= 200ms [929.940ms] [rows:1] SELECT * FROM `products` WHERE `code` = "Sticker" AND `products`.`deleted_at` IS NULL ORDER BY `products`.`id` LIMIT 1

原因

查询的时候，没有索引，慢sql

解决

索引：加索引可以解决部分问题

in-memory: 如果我们使用sqlite的in-memory 模式，这样避免从磁盘读取，速度更快

预热: 预先放到缓存，读缓存的数据，从一个树的查找 O(log n), 放缓存的话，时间复杂度是 O(1)

三种方案，应该有一个数量级的差异，晚些看下数据对比

2 锁表导致的

2022/08/04 09:55:45 /home/ubuntu/go/src/c10k-go/cmd/server/db.go:59 database is locked [0.061ms] [rows:0] UPDATE `products` SET `created_at`="2022-08-04 09:40:45.165",`updated_at`="2022-08-0 09:55:45.644",`deleted_at`=NULL,`code`="Sticker",`price`=100,`quantity`=99971357 WHERE `products`.`deleted_at` IS NULL AND `id` = 1 create order failed: 2

原因-为啥锁表报错

业务场景：这里其实是扣减库存，扣减的是商品的库存，来更新的库存表，update的时候，更新库存-1

报错：这里有锁表导致的事务失败，怎么解决？

| operationalerror-database-is-locked

搜索推荐是切换DB，更换掉sqlite，是一种解决方案，

锁表报错解决

业务：先看库存这个业务，他其实是一个有限的资源，一般来讲，是没办法超卖的，比如说你有100件手机，你不能卖出去101件，第101件你是发不出货的，卖出去后，就是超卖了，发不出货就会有投诉，退款等麻烦的事情。

实物和虚拟的区别：不过我们这里测试的时候，库存其实是无限的，不太担心超卖的，数量极大，这就是卖虚拟的东西和实物的区别，虚拟的可以随便卖，履约成本无限低，不像实物，所以虚拟商品，一般来讲，库存超卖相对还好

事务: 首先锁表商品表，减库存，创建订单，创单成功后，提交事务。如果床单失败，则回滚事务，加上库存。

系统：可以看到这里的压力有两点，一个是减库存，对商品表的压力，一个是创建订单，对订单表的压力。

锁资源：我们知道一条record 更新的时候，一般是record 锁和索引锁，新增的时候，会有db的table 级别的锁.

| 锁级别 innodb-locks-set

减库存流程：

如果商品和库存在一个表里面的话，库存频繁更新的话，那么商品读取也会受到影响，解法是拆分表，相当于垂直拆分，缓解压力
另外对于单个热点商品来讲，减库存的流程，其实相当于秒杀场景，大量的流量流入单个商品，单个库存，这里其实有数据库热点的，有热点就好办，最直观的解法，肯定是把热点与非热点拆分开来，特殊对待，为啥特殊对待？毕竟资源是有限的呀
解法: 我们现在压测，而且是单个产品，相当于一个秒杀场景，所以把库存单独拿出来，放到redis缓存，利用redis的Decr 来减库存。

订单创建流程：

这里的压力主要是表锁，新增记录。
解法很简单，水平扩容即可，分库分表来缓解新增的压力，暂时不加，看下效果

限流：

限流是为了保护集群，比如一个餐厅，最多提供100人同时就餐，如果来了1000人，餐厅会挤得水泄不通，资源可能会到非就餐人员身上，正常就餐受到影响，反而提供不了100人同时就餐服务了。
我们压测，可以动态控制流量，所以暂时不加限流

解决1-读加缓存

读的地方，都加到缓存里面

load

PID USER PR NI VIRT RES SHR S %CPU %MEM TIME+ COMMAND 
16869 root 20 0 2570232 63384 9648 S 57.3 3.1 1:31.96 server 
16941 root 20 0 1600468 22360 9172 S 23.7 1.1 0:37.09 main

并发表现：TPS 700 左右，latency最长13s，平均0.1 s，可接受的范围

耗时	并发数	成功数	qps	最长耗时	最短耗时	平均耗时	下载字节	字节每秒	状态码
235s	100	173411	740.00	13486.30	0.25	135.14	3,790,647	16,130	200:173411
236s	100	174178	740.61	13486.30	0.25	135.02	3,807,690	16,134	200:174178
237s	100	174925	740.56	13486.30	0.25	135.03	3,823,497	16,132	200:174925
238s	100	175642	740.56	13486.30	0.25	135.03	3,838,482	16,128	200:175642
239s	100	176435	740.85	13486.30	0.25	134.98	3,855,447	16,131	200:176435
240s	100	177571	741.99	13486.30	0.25	134.77	3,882,983	16,178	200:177571
241s	100	178609	743.09	13486.30	0.25	134.57	3,907,901	16,215	200:178609
242s	100	179479	744.23	13486.30	0.25	134.37	3,927,131	16,227	200:179479

慢SQL 相关报错日志

2022/08/06 12:44:55 /root/go/src/c10k-go/cmd/server/db.go:59 database is locked [0.047ms] [rows:0] UPDATE `products` SET `created_at`="2022-08-06 12:11:54.183",`updated_at`="2022-08-06 12:44:55.893",`deleted_at`=NULL,`code`="Sticker",`price`=100,`quantity`=99989897 WHERE `products`.`deleted_at` IS NULL AND `id` = 1 create order failed: 2

2022/08/06 12:44:55 /root/go/src/c10k-go/cmd/server/db.go:49 SLOW SQL >= 200ms [329.423ms] [rows:1] SELECT * FROM `products` WHERE `products`.`deleted_at` IS NULL AND `products`.`id` = 1 ORDER BY `products`.`id` LIMIT 1

一个是product 锁表导致的，一个是下单报错，可以看到，压力全在product库，原因就是库存在这里

怎么办？继续拆，把库存拆出去，但需要考虑一致性。把减库存的压力放到redis，这样的话，product没压力了，事务就是减redis成功后，再增加order即可

解决2-库存拆分

PID USER PR NI VIRT RES SHR S %CPU %MEM TIME+ COMMAND 
18969 root 20 0 2570512 34096 11160 S 28.3 1.7 1:00.64 server 
19344 root 20 0 1305540 17000 9080 S 13.3 0.8 0:12.72 main

TPS表现：结果更慢了，TPS 400+， why？

耗时	并发数	成功数	qps	最长耗时	最短耗时	平均耗时	下载字节	字节每秒	状态码
105s	50	44999	431.17	5017.35	1.33	115.96	585,291	5,574	200:44999
106s	50	45339	430.80	5017.35	1.33	116.06	589,711	5,563	200:45339
107s	50	45680	430.20	5017.35	1.33	116.23	594,144	5,552	200:45680
108s	50	45840	429.09	5017.35	1.33	116.53	596,224	5,520	200:45840
109s	50	46161	427.25	5017.35	1.33	117.03	600,397	5,508	200:46161
110s	50	46461	426.08	5017.35	1.33	117.35	604,313	5,493	200:46461

慢sql，现在压力全部在order库了，新增的时候，锁表导致的order 大于200ms, 本来均摊到两个表的压力，现在全部到一个表了，结果更慢了，当然也可能是order表数据变大了，先不细究

2022/08/06 13:06:05 /root/go/src/c10k-go/cmd/server/db.go:60 SLOW SQL >= 200ms [2029.641ms] [rows:1] INSERT INTO `orders` (`created_at`,`updated_at`,`deleted_at`,`user_id`,`product_id`,`status`) VALUES ("2022-08-06 13:06:03.588","2022-08-06 13:06:03.588",NULL,1,1,"pending") RETURNING `id`,`status`

2022/08/06 13:06:05 /root/go/src/c10k-go/cmd/server/db.go:60 SLOW SQL >= 200ms [429.022ms] [rows:1] INSERT INTO `orders` (`created_at`,`updated_at`,`deleted_at`,`user_id`,`product_id`,`status`) VALUES ("2022-08-06 13:06:05.324","2022-08-06 13:06:05.324",NULL,1,1,"pending") RETURNING `id`,`status`

解决3-订单单表新增

就剩下一个问题了，怎么提高单表的事务插入速度？

sqlite 切换成inmemory 试下看看，结果不贴了，反正是不行，可能是当时的机器不行 :(

| inmemory

切换成mysql

load ，两核的小鸡，不堪重负，mysql 就吃完了

PID USER PR NI VIRT RES SHR S %CPU %MEM TIME+ COMMAND 
22971 lxd 20 0 1856120 511704 30824 S 69.4 25.3 5:59.03 mysqld 
27494 root 20 0 1453036 18376 9892 S 47.2 0.9 0:54.78 server 
22928 root 20 0 1517876 8208 2476 S 34.6 0.4 1:23.44 docker-proxy 
27559 root 20 0 1379016 18584 9304 S 29.9 0.9 0:33.23 main

TPS表现：效果是显著的，并发数 1200+了

耗时	并发数	成功数	qps	最长耗时	最短耗时	平均耗时	下载字节	字节每秒	状态码
91s	50	109297	1203.37	456.32	2.19	41.55	1,420,861	15,613	200:109297
92s	50	110507	1203.60	456.32	2.19	41.54	1,436,591	15,615	200:110507
93s	50	111691	1203.39	456.32	2.19	41.55	1,451,983	15,612	200:111691
94s	50	112890	1203.36	456.32	2.19	41.55	1,467,570	15,612	200:112890
95s	50	114023	1202.61	456.32	2.19	41.58	1,482,299	15,603	200:114023

慢sql

2022/08/06 13:50:02 /root/go/src/c10k-go/cmd/server/db.go:60 SLOW SQL >= 200ms [205.602ms] [rows:1] INSERT INTO `orders` (`created_at`,`updated_at`,`deleted_at`,`user_id`,`product_id`,`status`) VALUES ('2022-08-06 13:50:02.278','2022-08-06 13:50:02.278',NULL,1,1,'pending')

2022/08/06 13:50:25 /root/go/src/c10k-go/cmd/server/db.go:60 SLOW SQL >= 200ms [238.287ms] [rows:1] INSERT INTO `orders` (`created_at`,`updated_at`,`deleted_at`,`user_id`,`product_id`,`status`) VALUES ('2022-08-06 13:50:25.573','2022-08-06 13:50:25.573',NULL,1,1,'pending')

2022/08/06 13:50:25 /root/go/src/c10k-go/cmd/server/db.go:60 SLOW SQL >= 200ms [200.938ms] [rows:1] INSERT INTO `orders` (`created_at`,`updated_at`,`deleted_at`,`user_id`,`product_id`,`status`) VALUES ('2022-08-06 13:50:25.699','2022-08-06 13:50:25.699',NULL,1,1,'pending')

2022/08/06 13:50:48 /root/go/src/c10k-go/cmd/server/db.go:60 SLOW SQL >= 200ms [244.081ms] [rows:1] INSERT INTO `orders` (`created_at`,`updated_at`,`deleted_at`,`user_id`,`product_id`,`status`) VALUES ('2022-08-06 13:50:48.284','2022-08-06 13:50:48.284',NULL,1,1,'pending')

慢sql怎么解决？

走批量插入，还是继续分片？要求是2k可以不？

还是先加机器吧，继续加cpu，看下瓶颈在哪里，换成8核16G再来战

加完机器 tps 650+？？？ what happend?

耗时	并发数	成功数	qps	最长耗时	最短耗时	平均耗时	下载字节	字节每秒	状态码
47s	100	31555	676.78	872.18	22.54	147.76	410,215	8,727	200:31555
48s	100	32018	671.71	872.18	22.54	148.87	416,234	8,671	200:32018
49s	100	32476	667.29	872.18	22.54	149.86	422,188	8,615	200:32476
50s	100	33035	664.77	872.18	22.54	150.43	429,455	8,586	200:33035
51s	100	33613	663.74	872.18	22.54	150.66	436,969	8,567	200:33613
52s	100	34161	661.17	872.18	22.54	151.25	444,093	8,540	200:34161

解决4-db最大连接数

2022/08/07 12:17:20 /root/go/src/c10k-go/cmd/server/db.go:60 SLOW SQL >= 200ms [268.386ms] [rows:1] INSERT INTO `orders` (`created_at`,`updated_at`,`deleted_at`,`user_id`,`product_id`,`status`) VALUES ('2022-08-07 12:17:20.273','2022-08-07 12:17:20.273',NULL,1,1,'pending')

2022/08/07 12:17:20 /root/go/src/c10k-go/cmd/server/db.go:60 SLOW SQL >= 200ms [276.732ms] [rows:1] INSERT INTO `orders` (`created_at`,`updated_at`,`deleted_at`,`user_id`,`product_id`,`status`) VALUES ('2022-08-07 12:17:20.265','2022-08-07 12:17:20.265',NULL,1,1,'pending')

create order failed: 3 [mysql] 2022/08/07 12:18:19 packets.go:37: unexpected EOF [mysql] 2022/08/07 12:18:19 packets.go:37: unexpected EOF [mysql] 2022/08/07 12:18:19 packets.go:37: unexpected EOF [mysql] 2022/08/07 12:18:19 packets.go:37: unexpected EOF [mysql] 2022/08/07 12:18:19 packets.go:37: unexpected EOF

一看就是最大链接数问题，看下gorm的最大连接数

| Golang MySQL error - packets.go:33: unexpected EOF

sqlDB, _ := gormDB.DB()
sqlDB.SetMaxIdleConns(10)
sqlDB.SetMaxOpenConns(100)

解决5-docker-proxy load 高

PID USER PR NI VIRT RES SHR S %CPU %MEM TIME+ COMMAND 
2046 root 20 0 5730236 13968 2832 S 467.7 0.1 10:17.72 docker-proxy 
2088 lxd 20 0 5014264 499052 33452 R 128.0 3.0 9:57.75 mysqld 
2706 root 20 0 1526768 22588 10020 S 52.0 0.1 3:07.06 server 
20389 root 20 0 1748444 21524 9208 S 33.7 0.1 0:40.35 main 
778 root 20 0 57832 9152 6724 S 5.7 0.1 0:19.09 redis-server

mysql 使用的是docker，看到网络肯定是挂了 mysql的load 基本在2左右 server 0.6 压测client 0.4 redis 0.05 左右

解决：不使用docker了，直接裸机mysql，docker-proxy 就不会是问题了

TPS 恢复 1000+

耗时	并发数	成功数	qps	最长耗时	最短耗时	平均耗时	下载字节	字节每秒	状态码
61s	100	61452	1019.02	612.01	18.68	98.13	798,876	13,096	200:61452
62s	100	62260	1015.74	612.01	18.68	98.45	809,380	13,054	200:62260
63s	100	63122	1014.10	612.01	18.68	98.61	820,586	13,025	200:63122
64s	100	63996	1011.60	612.01	18.68	98.85	831,948	12,998	200:63996
65s	100	64749	1007.47	612.01	18.68	99.26	841,737	12,949	200:64749
66s	100	65603	1004.88	612.01	18.68	99.51	852,839	12,921	200:65603
67s	100	66556	1005.23	612.01	18.68	99.48	865,228	12,913	200:66556
68s	100	67401	1003.13	612.01	18.68	99.69	876,213	12,885	200:67401
69s	100	68347	1002.32	612.01	18.68	99.77	888,511	12,876	200:68347
70s	100	69240	1001.25	612.01	18.68	99.88	900,120	12,858	200:69240

去掉docker db后，再看下load，恢复正常了

PID USER PR NI VIRT RES SHR S %CPU %MEM TIME+ COMMAND 
45178 mysql 20 0 5046820 500292 37164 S 240.2 3.1 7:22.01 mysqld 
45625 root 20 0 1600500 23016 9852 S 122.3 0.1 2:25.70 server 
45779 root 20 0 1822432 22776 9268 S 81.4 0.1 1:04.24 main 
778 root 20 0 57832 9212 6724 S 11.0 0.1 0:31.49 redis-server

| redis 真是厉害啊，才0.1，最占资源的还是DB，所以DB需要分拆出来，有专业的DBA团队来维护是一个必然的事情 mysql 2.5 server 1.2 client 0.8 redis 0.1

磁盘io

Device tps MB_read/s MB_wrtn/s MB_dscd/s MB_read MB_wrtn MB_dscd
vda 352.00 0.00 4.38 0.00 0 4 0

慢sql: 现在基本都是订单插入的慢sql了

2022/08/07 12:45:51 /root/go/src/c10k-go/cmd/server/db.go:60 SLOW SQL >= 200ms [282.300ms] [rows:1] INSERT INTO `orders` (`created_at`,`updated_at`,`deleted_at`,`user_id`,`product_id`,`status`) VALUES ('2022-08-07 12:45:51.009','2022-08-07 12:45:51.009',NULL,1,1,'pending')

2022/08/07 12:45:51 /root/go/src/c10k-go/cmd/server/db.go:60 SLOW SQL >= 200ms [300.287ms] [rows:1] INSERT INTO `orders` (`created_at`,`updated_at`,`deleted_at`,`user_id`,`product_id`,`status`) VALUES ('2022-08-07 12:45:50.991','2022-08-07 12:45:50.991',NULL,1,1,'pending')

2022/08/07 12:45:51 /root/go/src/c10k-go/cmd/server/db.go:60 SLOW SQL >= 200ms [299.624ms] [rows:1] INSERT INTO `orders` (`created_at`,`updated_at`,`deleted_at`,`user_id`,`product_id`,`status`) VALUES ('2022-08-07 12:45:50.992','2022-08-07 12:45:50.992',NULL,1,1,'pending')

2022/08/07 12:45:51 /root/go/src/c10k-go/cmd/server/db.go:60 SLOW SQL >= 200ms [291.614ms] [rows:1] INSERT INTO `orders` (`created_at`,`updated_at`,`deleted_at`,`user_id`,`product_id`,`status`) VALUES ('2022-08-07 12:45:51','2022-08-07 12:45:51',NULL,1,1,'pending')

2022/08/07 12:45:51 /root/go/src/c10k-go/cmd/server/db.go:60 SLOW SQL >= 200ms [299.556ms] [rows:1] INSERT INTO `orders` (`created_at`,`updated_at`,`deleted_at`,`user_id`,`product_id`,`status`) VALUES ('2022-08-07 12:45:50.992','2022-08-07 12:45:50.992',NULL,1,1,'pending')

解决6-换DB，加配置

到此没办法解决了，只能提高配置了，看下mysql 最大能力了, 换postgres or 换其他的mysql

尝试了第三方解决方案，估计给的实例资源比较差，pg digitalOcean自带的，配置低的话，不行, digitalOcean 自带的mysql 900+一样，2c4G，还不如自建的mysql

digitalOcean pg的TPS

耗时	并发数	成功数	qps	最长耗时	最短耗时	平均耗时	下载字节	字节每秒	状态码
1s	32	298	1044.82	934.47	3.91	95.71	3,874	3,856	200:298
2s	67	955	1013.23	1979.03	3.91	98.69	12,415	6,206	200:955
3s	99	1523	817.50	2939.58	3.91	122.32	19,799	6,597	200:1523
4s	100	1994	677.12	3060.34	3.91	147.69	25,922	6,480	200:1994
5s	100	2566	646.20	3060.34	3.91	154.75	33,358	6,671	200:2566
6s	100	3197	648.93	3060.34	3.91	154.10	41,561	6,924	200:3197
7s	100	3837	652.61	3060.34	3.91	153.23	49,881	7,125	200:3837
8s	100	4442	647.12	3060.34	3.91	154.53	57,746	7,213	200:4442
9s	100	5132	649.41	3060.34	3.91	153.98	66,716	7,412	200:5132
10s	100	5794	647.98	3060.34	3.91	154.33	75,322	7,530	200:5794
11s	100	6444	651.26	3060.34	3.91	153.55	83,772	7,614	200:6444
12s	100	7064	646.37	3060.34	3.91	154.71	91,832	7,651	200:7064
13s	100	7712	642.93	3060.34	3.83	155.54	100,256	7,711	200:7712
14s	100	8371	645.52	3060.34	3.83	154.91	108,823	7,772	200:8371
15s	100	9010	645.66	3060.34	3.83	154.88	117,130	7,808	200:9010
16s	100	9658	644.54	3060.34	3.83	155.15	125,554	7,846	200:9658

digitalOcean mysql server 5 的TPS

耗时	并发数	成功数	qps	最长耗时	最短耗时	平均耗时	下载字节	字节每秒	状态码
159s	100	134747	855.20	3156.15	5.27	116.93	1,751,711	11,016	200:134747
160s	100	135554	853.64	3156.15	5.27	117.14	1,762,202	11,013	200:135558
161s	100	136682	855.51	3156.15	5.27	116.89	1,776,866	11,036	200:136682
162s	100	137457	855.16	3156.15	5.27	116.94	1,786,941	11,030	200:137457
163s	100	138103	854.17	3156.15	5.27	117.07	1,795,339	11,014	200:138103
164s	100	138830	853.16	3156.15	5.27	117.21	1,804,790	11,003	200:138838
165s	100	139687	853.15	3156.15	5.27	117.21	1,815,931	11,005	200:139687
166s	100	140265	851.49	3156.15	5.27	117.44	1,823,445	10,984	200:140265
167s	100	140952	850.71	3156.15	5.27	117.55	1,832,376	10,972	200:140952
168s	100	141609	849.58	3156.15	5.27	117.71	1,840,917	10,957	200:141609
169s	100	142296	848.47	3156.15	5.27	117.86	1,849,848	10,945	200:142296

第三方DB的应用LOAD

PID USER PR NI VIRT RES SHR S %CPU %MEM TIME+ COMMAND 
73601 root 20 0 5142000 23352 11496 R 527.8 0.1 8:34.38 server 
73893 root 20 0 1896164 24076 9380 S 77.8 0.1 2:53.16 main

第三方DB的慢sql

2022/08/07 15:03:40 /root/go/src/c10k-go/cmd/server/db.go:60 SLOW SQL >= 200ms [253.865ms] [rows:1] INSERT INTO `orders` (`created_at`,`updated_at`,`deleted_at`,`user_id`,`product_id`,`status`) VALUES ('2022-08-07 15:03:40.232','2022-08-07 15:03:40.232',NULL,1,1,'pending')

2022/08/07 15:04:25 /root/go/src/c10k-go/cmd/server/db.go:60 SLOW SQL >= 200ms [248.147ms] [rows:1] INSERT INTO `orders` (`created_at`,`updated_at`,`deleted_at`,`user_id`,`product_id`,`status`) VALUES ('2022-08-07 15:04:24.973','2022-08-07 15:04:24.973',NULL,1,1,'pending')

2022/08/07 15:04:44 /root/go/src/c10k-go/cmd/server/db.go:60 SLOW SQL >= 200ms [258.707ms] [rows:1] INSERT INTO `orders` (`created_at`,`updated_at`,`deleted_at`,`user_id`,`product_id`,`status`) VALUES ('2022-08-07 15:04:43.935','2022-08-07 15:04:43.935',NULL,1,1,'pending')

pgsql 换成本地

load

PID USER PR NI VIRT RES SHR S %CPU %MEM TIME+ COMMAND 
127490 root 20 0 1897792 31676 12208 R 244.4 0.2 2:58.06 server 
127754 root 20 0 1601236 22120 9156 S 53.0 0.1 0:37.00 main 
73264 postgres 20 0 218692 30360 27604 R 32.8 0.2 1:09.48 postgres 
778 root 20 0 57832 9232 6724 S 6.3 0.1 1:35.19 redis-server 
73270 postgres 20 0 73424 7256 4368 R 2.6 0.0 0:05.10 postgres

TPS 1100+

耗时	并发数	成功数	qps	最长耗时	最短耗时	平均耗时	下载字节	字节每秒	状态码
97s	100	111084	1150.23	524.39	2.81	86.94	1,446,540	14,912	200:111084
98s	100	112243	1150.17	524.39	2.81	86.94	1,461,607	14,914	200:112243
99s	100	113367	1150.38	524.39	2.81	86.93	1,476,219	14,911	200:113369
100s	100	114549	1150.57	524.39	2.81	86.91	1,491,585	14,915	200:114549
101s	100	115704	1151.13	524.39	2.81	86.87	1,506,600	14,916	200:115704
102s	100	117044	1152.56	524.39	2.81	86.76	1,524,020	14,941	200:117044
103s	100	118235	1152.99	524.39	2.81	86.73	1,539,503	14,946	200:118235
104s	100	119582	1154.97	524.39	2.81	86.58	1,557,014	14,971	200:119582
105s	100	120818	1155.32	524.39	2.81	86.56	1,573,082	14,981	200:120818
106s	100	122110	1156.76	524.39	2.81	86.45	1,589,878	14,998	200:122110

日志 sql 报错，没有慢sql，但事务失败的很多，原因未知,日志没有打印出来DB的，没有继续查

create order failed: 3 
create order failed: 3 
create order failed: 3 
create order failed: 3 
create order failed: 3 
create order failed: 3 
create order failed: 3 
create order failed: 3 
create order failed: 3 
create order failed: 3

结论

1 读的地方加缓存，注意缓存失效

2 如果是秒杀场景，库存可以使用Redis扣减，基本不占资源

3 订单表的事务插入，尽量异步，不能异步的，加资源，使用Mysql或者Postgres 都可以

在8c16g的资源下，单机做到1100+的TPS，还可以吧，下次继续 :)

go解决c10k problem(一)

Mon, 01 Aug 2022 09:40:00 +0000

零：缘起

一：go http server

goroutine的存在，让go在网络编程这块很高效，也有很多优秀的http 框架，比如 gin echo fasthttp

fasthttp 比较快，我们先不读取db和其他，仅让cpu是一个瓶颈，仅写个hello world，收到请求后，返回一行文本。

示例代码

package main

import (
	"fmt"
	"github.com/valyala/fasthttp"
)

// request handler in fasthttp style, i.e. just plain function.
func fastHTTPHandler(ctx *fasthttp.RequestCtx) {
	fmt.Fprintf(ctx, "Hi there! RequestURI is %q", ctx.RequestURI())
}

func main() {
	fasthttp.ListenAndServe(":8087", fastHTTPHandler)
}

二：go http client 压测的client

2.1 压测client选择

简单实现版本，使用time.Sleep 函数，来均匀分布所有的请求到一个server。
复杂实现版本，来一个goroutine的pool，一个http connect的pool，分别控制最大连接数和最大goroutine数目，并且根据请求耗时，动态调整两个pool的大小，然后到一个稳定的状态。
别人现有的，找到一个 go-strees-testing 的项目，可以先用起来

2.2 先选择现有的试试效果

https://github.com/link1st/go-stress-testing

#!/bin/bash

go-stress-testing-linux -c 100 -n 100000 -u http://127.0.0.1:8087

这里原生不支持多核cpu，所以多核的话，我们需要下载下来，修改main函数，把cpu的数量从 runtime.GOMAXPROCS(1) 修改成runtime.GOMAXPROCS(runtime.NumCPU())

三：可观测

3.1 观测内容

观测分为几点，一个是业务监控，一个是系统监控，像我们这种，没有业务逻辑，仅监控系统即可

系统监控，又分为主机系统监控，应用系统监控、中间件、DB

主机监控有cpu、内存、磁盘、网络的监控，我们这里磁盘其实可以忽略掉

应用系统监控，go runtime监控，比如gc、堆栈

DB和中间件，暂时没有，先不写

3.2 观测方案

系统监控，使用shell、linux 命令行即可，手动监控

应用监控，使用prometheus 的golang client 采集，grafana 展示

四：实战

4.1 Mac 实践

问题

server和client 配置好后，开始监测，QPS也就700左右，死活上不去了，内存和cpu都还好，不高，网络链接也不多，但请求的延时就开始超过10s

解决

尽早放弃了，不想折腾，使用linux

4.2 Linux 实践

问题1

这次简单，直接在现有的小鸡上来跑，0.5G内存，1VCPU

结果1

解决1

可以看到，linux 直接就3800 QPS了，这次是单机CPU满载了，client 64%，server 36%， 100%

这种简单，加机器就可以解决的问题

解决2

*GOMAXPROCS=4 go run server.go &*

PID USER      PR  NI    VIRT    RES    SHR S  %CPU  %MEM     TIME+ COMMAND
17606 root      20   0 1438212 119252   5284 R 303.7   0.4   5:51.98 client
17485 root      20   0 1527320  15384   9156 S 230.0   0.0   4:29.19 server

30k+的top 和并发数

PID USER      PR  NI    VIRT    RES    SHR S  %CPU  %MEM     TIME+ COMMAND
18814 root      20   0 1816328  53512   9532 S 549.8   0.2   4:21.05 main
17485 root      20   0 1748772  16164   9348 R 166.8   0.0  14:03.47 server

─────┬───────┬───────┬───────┬────────┬────────┬────────┬────────┬────────┬────────┬────────
耗时│ 并发数│ 成功数│ 失败数│   qps  │最长耗时│最短耗时│平均耗时│下载字节│字节每秒│ 状态码 
─────┼───────┼───────┼───────┼────────┼────────┼────────┼────────┼────────┼────────┼────────
1s│    100│  22654│      0│27766.78│   45.56│    0.17│    3.60│1,245,970│1,245,938│200:22654
2s│    100│  46299│      0│28457.67│   45.56│    0.15│    3.51│2,546,445│1,273,204│200:46299
3s│    100│  70470│      0│28828.85│   45.56│    0.15│    3.47│3,875,850│1,291,943│200:70470
4s│    100│  94893│      0│29192.73│   45.56│    0.14│    3.43│5,219,115│1,304,771│200:94893
5s│    100│ 119602│      0│29516.55│   45.56│    0.14│    3.39│6,578,110│1,315,573│200:119602
6s│    100│ 144138│      0│29669.31│   45.56│    0.14│    3.37│7,927,590│1,321,143│200:144138
7s│    100│ 169391│      0│29952.31│   45.56│    0.14│    3.34│9,316,505│1,330,926│200:169391
8s│    100│ 194896│      0│30215.56│   45.56│    0.14│    3.31│10,719,280│1,339,904│200:194896
9s│    100│ 220623│      0│30489.03│   45.56│    0.14│    3.28│12,134,265│1,348,246│200:220623
10s│    100│ 246594│      0│30690.36│   45.56│    0.14│    3.26│13,562,670│1,356,265│200:246594
11s│    100│ 272641│      0│30889.66│   45.56│    0.14│    3.24│14,995,255│1,363,135│200:272641
12s│    100│ 299071│      0│31084.94│   45.56│    0.14│    3.22│16,448,905│1,370,737│200:299071
13s│    100│ 325628│      0│31266.74│   45.56│    0.14│    3.20│17,909,540│1,377,654│200:325628
14s│    100│ 352274│      0│31436.50│   45.56│    0.14│    3.18│19,375,070│1,383,930│200:352311
15s│    100│ 379019│      0│31602.18│   45.56│    0.14│    3.16│20,846,045│1,389,734│200:379019
16s│    100│ 405848│      0│31756.00│   45.56│    0.14│    3.15│22,321,640│1,395,101│200:405848
17s│    100│ 432456│      0│31883.06│   45.56│    0.14│    3.14│23,785,080│1,399,121│200:432456
18s│    100│ 459049│      0│32011.63│   45.56│    0.14│    3.12│25,247,695│1,402,645│200:459227
19s│    100│ 486589│      0│32163.75│   45.56│    0.14│    3.11│26,762,395│1,408,546│200:486589
20s│    100│ 513977│      0│32314.27│   45.56│    0.14│    3.09│28,268,735│1,413,435│200:513978
21s│    100│ 540328│      0│32372.83│   45.56│    0.14│    3.09│29,718,040│1,415,142│200:540328
22s│    100│ 568158│      0│32517.04│   45.56│    0.14│    3.08│31,248,690│1,420,373│200:568163
23s│    100│ 595715│      0│32614.98│   45.56│    0.14│    3.07│32,764,325│1,424,534│200:595715
24s│    100│ 623436│      0│32732.62│   45.56│    0.14│    3.06│34,288,980│1,428,599│200:623731
25s│    100│ 650742│      0│32858.38│   45.56│    0.14│    3.04│35,790,810│1,431,629│200:650745
26s│    100│ 678444│      0│32945.23│   45.56│    0.14│    3.04│37,314,420│1,435,163│200:678444
27s│    100│ 706591│      0│33066.18│   45.56│    0.14│    3.02│38,862,505│1,439,116│200:706591
28s│    100│ 734065│      0│33133.34│   45.56│    0.14│    3.02│40,373,575│1,441,912│200:734065
29s│    100│ 761927│      0│33222.32│   45.56│    0.14│    3.01│41,905,985│1,445,032│200:761934

40k的结果

可以达到40k，耗时很短，server 很高

PID USER      PR  NI    VIRT    RES    SHR S  %CPU  %MEM     TIME+ COMMAND
18814 root      20   0 2236976 187344   9532 R 548.5   0.6  25:16.16 main
17485 root      20   0 1748772  16324   9540 S 172.1   0.0  20:36.26 server

─────┬───────┬───────┬───────┬────────┬────────┬────────┬────────┬────────┬────────┬────────
耗时│ 并发数│ 成功数│ 失败数│   qps  │最长耗时│最短耗时│平均耗时│下载字节│字节每秒│ 状态码 
─────┼───────┼───────┼───────┼────────┼────────┼────────┼────────┼────────┼────────┼────────
247s│    100│7563722│      0│40026.69│   48.31│    0.14│    2.50│416,004,710│1,684,229│200:7563722
248s│    100│7595709│      0│40034.48│   48.31│    0.14│    2.50│417,763,995│1,684,532│200:7595709
249s│    100│7628010│      0│40044.40│   48.31│    0.14│    2.50│419,540,550│1,684,901│200:7628010
250s│    100│7659374│      0│40049.95│   48.31│    0.14│    2.50│421,265,570│1,685,058│200:7659374
251s│    100│7691688│      0│40060.62│   48.31│    0.14│    2.50│423,042,840│1,685,429│200:7691688
252s│    100│7723556│      0│40067.88│   48.31│    0.14│    2.50│424,795,580│1,685,695│200:7723556

结语

可以看到，go 来解决一个C10k的问题，很简单，当然这个只是最简单的一个模拟，下一期，我们加上数据库，再来解决数据库下面的C10k的问题。

参考

C10K

typeScript的一个坑

Thu, 30 Jun 2022 21:00:00 +0000

缘起

最近找了个兼职，写了一段node的typescript代码，虽然上次写node还是5年前，但因为使用的框架是midway，写的过程中，几乎没有碰到bug，很自然的感觉，就是spring的那一套，面向对象，依赖注入等，写web还是很方便的。

不过也由于这几年天天看和写java代码，写的时候，很容易就按照面向对象写起来，一切都是class，class的方法等，所以这也是bug的由来。

问题来龙去脉

业务bug简单描述

一个学校有n个老师，每个老师一门课程，期末的时候，老师会给学生打分，学生同时也是一个用户。

问题：在打分的过程中，为了方便，对学生对象list转换成了map，然后每个老师都会对学生的分数进行统计，然后再把统计结果返回给学生，这样就会导致学生的分数被覆盖。发现学生的成绩到最后都是一个老师打的。

复现代码

class User {
    Name: string;
    Age: number;
}

class Student extends User {
    Grade: number;
}

class Teacher {
    Name: string;
    Class: string;
    Students: Student[];
}

const user1 = new User();
user1.Name = 'John';
user1.Age = 30;


const user2 = new User();
user2.Name = 'Jane';
user2.Age = 25;



const users = [user1, user2];

const teacher = new Teacher();
teacher.Name = 'Bob';
teacher.Class = '1A';

const teacher2 = new Teacher();
teacher2.Name = 'Alice';
teacher2.Class = '1B';

const teachers = [teacher, teacher2];

const userMap = users.reduce((acc, cur) => {
    acc[cur.Name] = cur;
    return acc;
  }, {});

const gradeTeacher = new Array<Teacher>();

teachers.forEach(teacher => {
    const students = new Array<Student>();
    const teacherName = teacher.Name;

    Object.entries(userMap).forEach(([key, value]) => {

        let student = new Student();
        student = userMap[key];
        if (teacherName === 'Bob') {
          student.Grade = 100;
        } else {
            student.Grade = 50;
        }
        students.push(student);

    });
    teacher.Students = students;
    gradeTeacher.push(teacher);
});


for (const teacher of gradeTeacher) {
    console.log(teacher); 
}

理论期望的结果

Teacher {
  Name: 'Bob',
  Class: '1A',
  Students: [
    User { Name: 'John', Age: 30, Grade: 100 },
    User { Name: 'Jane', Age: 25, Grade: 100 }
  ]
}
Teacher {
  Name: 'Alice',
  Class: '1B',
  Students: [
    User { Name: 'John', Age: 30, Grade: 50 },
    User { Name: 'Jane', Age: 25, Grade: 50 }
  ]
}

实际结果

Teacher {
  Name: 'Bob',
  Class: '1A',
  Students: [
    User { Name: 'John', Age: 30, Grade: 50 },
    User { Name: 'Jane', Age: 25, Grade: 50 }
  ]
}
Teacher {
  Name: 'Alice',
  Class: '1B',
  Students: [
    User { Name: 'John', Age: 30, Grade: 50 },
    User { Name: 'Jane', Age: 25, Grade: 50 }
  ]
}

why?

可以看到，user 被循环了两次，而且每次都是user1，user2，这样就导致了学生的分数被覆盖。

let student = new Student();
student = userMap[key];
student.Grade = 100;

也就是这段代码，执行之后，student 实际变成了一个 User对象，不再是一个Student对象，同时，对student的Grade赋值的时候，ts也没有报错，类型检查的时候，认为他是Student类型，但执行的时候，认为他是User类型，同时又由于js，没有类型约束，可以赋值，所以，这里的问题就出现了。

解决方案

知道了原因就好了，我们让student获得一个深拷贝的user即可，而不是引用，这样再赋值Grade的时候，就不会出现问题。

let student = new Student();
Object.assign(student, userMap[key]);
student.Grade = 100;

后记

JavaScript写业务，非强类型语言，还是要注意类型的约束，不然会出现一些问题。所以，在写业务的时候，Java和Go还是更加安全一些。

同时typeScript也是一个静态类型语言，可以更加的更加安全一些。但IDE的提示，还有程序员自己的熟练程度也是影响代码质量的一个很重要的因素，如果typeScript编译没有检查出来，则实际执行的过程中，也会出现问题。

go面试算法系列记录

Sat, 25 Jun 2022 19:55:00 +0000

面试

最近从阿里离职，开始准备面试，刷了一个月左右的leetcode,然后实践出真知，去面试了几家公司。

shopee 算法一面螺旋矩阵，反向螺旋矩阵

描述要求

给定一个n x n的，打印出一个螺旋矩阵，比如：

输入n= 3,

输出，则打印

9 8 7 2 1 6 3 4 5

思路和解决

其实考察的是对数组的理解，还有矩阵的理解，就是找到矩阵的上下左右边界，遍历即可。反向的话，无非是从高到低遍历，正向的话，是从低到高遍历。

代码

func main() {
    matrix := generateMatrix(3)
    printMatrix(matrix)
}

func printMatrix(matrix [][]int) {
    if matrix == nil || len(matrix) == 0 {
        return
    }
    n := len(matrix)
    for i := 0; i < n; i++ {
        for j := 0; j < n; j++ {
            fmt.Printf("%d ", matrix[i][j])
        }
        fmt.Println()
    }
}

func generateMatrix(n int) [][]int {
	upper_bound, left_bound := 0, 0
	lower_bound, right_bound := n-1, n-1
    // 反向的话，number是最大值
	number := n*n
	var matrix = make([][]int, n)
	for k := range matrix {
		matrix[k] = make([]int, n)
	}
	for number > 0 {
		if upper_bound <= lower_bound {
			for j := left_bound; j <= right_bound; j++ {
				number--
				matrix[upper_bound][j] = number
			}
			upper_bound++
		}
		if left_bound <= right_bound {
			for j := upper_bound; j <= lower_bound; j++ {
				number00
				matrix[j][right_bound] = number
			}
			right_bound--
		}
		if upper_bound <= lower_bound {
			for j := right_bound; j >= left_bound; j-- {
				number--
				matrix[lower_bound][j] = number
			}
			lower_bound--
		}
		if left_bound <= right_bound {
			for j := lower_bound; j >= upper_bound; j-- {
				number--
				matrix[j][left_bound] = number
			}
			left_bound++
		}

	}
	return matrix

}

shopee 算法二面手写LRU

描述

LRU，即Least Recently Used，最近最少使用，是一种缓存算法，它的主要目的是为了防止缓存中的数据过期，过期后就不能再使用。

实现LRU算法,O(1)的时间复杂度

思路

LRU，数据结构组成，是双向链表+map，其中双向链表是用来记录LRU的，map是用来记录key和value的。

问题一：为啥需要双向链表？

因为需要记录LRU的顺序，所以需要双向链表，map是无序的。

问题二：为啥需要map？

双向链表，增删改查，查是O(n)的，但是map的查是O(1)的，所以需要map，这里用到了空间换时间。用一个map来存储所有的双向链表的节点，这样就可以O(1)的查找。查到双向链表的节点后，则删除和插入都是O(1)的。

问题三：map 存储的是双向链表的节点，还是双向链表的节点的value？

node 是key，value，prev，next 四个元素，map存储是key， value是 &node 指针。

//below generated by github copilot
type Node struct {
    key int
    value int
    prev *Node
    next *Node
}
type LRUCache struct {
    map[int]*Node
    head *Node
    tail *Node

    capacity int
    size int
}
func Constructor(capacity int) LRUCache {
    return LRUCache{
        map[int]*Node{},
        &Node{},
        &Node{},
        capacity,
        0,
    }
}
func (this *LRUCache) Get(key int) int {
    if node, ok := this.map[key]; ok {
        this.remove(node)
        this.add(node)
        return node.value
    }
    return -1
}
func (this *LRUCache) Put(key int, value int) {
    if node, ok := this.map[key]; ok {
        this.remove(node)
        node.value = value
        this.add(node)
    } else {
        if this.size == this.capacity {
            delete(this.map, this.tail.key)
            this.remove(this.tail)
        }
        node := &Node{
            key: key,
            value: value,
            prev: nil,
            next: nil,
        }
        this.add(node)
        this.map[key] = node
        this.size++
    }
}
func (this *LRUCache) remove(node *Node) {
    if node.prev != nil {
        node.prev.next = node.next
    }
    if node.next != nil {
        node.next.prev = node.prev
    }
    if node == this.head {
        this.head = node.next
    }
    if node == this.tail {
        this.tail = node.prev
    }
}
func (this *LRUCache) add(node *Node) {
    node.next = this.head
    node.prev = nil
    if this.head != nil {
        this.head.prev = node
    }
    this.head = node
    if this.tail == nil {
        this.tail = node
    }
}

不知名公司1 算法一面

描述

给了两个题目，二选一，一个是快速排序，一个是实现string的parseFloat

可以使用ide

我选了个parseFloat，因为当时快速排序的题目还没有刷到 :)，所以我选了parseFloat

思路

首先，我们需要实现一个parseFloat函数，这个函数的功能是将一个string转换成float，如果转换失败，返回0.0。

float 就是有小数的了，有可能还会丢失精度，所以我们需要实现一个精度的转换，这里我是把所有的先使用int存储，然后再统一转换成小数。

同时考虑float的最大值，最小值问题。

剩下的就是通用的十进制计算了，正负号了

自己写的版本，比较简单，但是没有考虑最大值和最小值的问题，所以还是不能用了。

func parseFloat(s string) float64 {

	//negtive sign
	neg := false

	strconv.ParseFloat(s, 0)

	havePoint := false

	//a number res
	var res float64
	var resNeg float64

	negBase := 1.0

	//for loop to get sign and number
	for _, v := range s {
		n := v - '0'

		if v == '.' {
			if havePoint {
				return 0
			}
			havePoint = true
			continue
		}
		if v == '-' {
			neg = true
			continue
		}
		if !havePoint {
			if v >= '0' && v <= '9' {
				res = res*10 + float64(n)

			}
		} else if havePoint {
			f := 0.1
			negBase = negBase * f

			if v >= '0' && v <= '9' {
				resNeg = resNeg*10 + float64(n)
			}
		}

	}

	res = res + resNeg*negBase

	if neg {
		res = -res
	}

	return res
}

//below generated by github copilot，所以人还是打不过电脑
func parseFloat(s string) float64 {
    if s == "" {
        return 0.0
    }
    var sign int
    if s[0] == '+' {
        sign = 1
    } else if s[0] == '-' {
        sign = -1
    } else {
        sign = 1
    }
    var i int
    if sign == -1 {
        i = 1
    } else {
        i = 0
    }
    var res float64
    for ; i < len(s); i++ {
        if s[i] == '.' {
            break
        }
        if s[i] < '0' || s[i] > '9' {
            return 0.0
        }
        res = res*10 + float64(s[i]-'0')
    }
    if i == len(s) {
        return float64(sign)*res
    }
    var j int
    for ; i < len(s); i++ {
        if s[i] < '0' || s[i] > '9' {
            return 0.0
        }
        res = res + float64(s[i]-'0')*math.Pow(10, float64(-j))
        j++
    }
    return float64(sign)*res
}

不知名公司2，算法一面

描述

时间关系，两个人面，仅要求给思路，不看具体代码实现

1 LRU的实现，why ？为啥使用这些数据结构，lru的使用场景？

不再赘述

2 单链表判断回文数，不能使用其他数据结构，只能使用单链表，不能新建一个单链表。

这里有两种办法，一种是使用栈，就是用函数调用，也就是函数递归栈来解决反转的判断。

paypal 二面（全程英文面试）

描述

给定一个string，判断是回文数？

思路

没有要求，回文数很简单

//below generated by github copilot
func isPalindrome(s string) bool {
    if len(s) == 0 {
        return true
    }
    var i int
    var j int
    for i = 0; i < len(s)/2; i++ {
        j = len(s) - i - 1
        if s[i] != s[j] {
            return false
        }
    }
    return true
}

众安保险，一面

描述

使用两个goroutine交替打印1-100之间的奇数和偶数, 输出时按照从小到大输出.

思路

使用go的channel即可，本身就是一个队列，同时a b goroutine使用channel来交替获得channel的使用权，并且打印

func print100() {
	var ch = make(chan int, 1)
	var i = 1
	ch <- i
	var doneC = make(chan struct{})

	go func() {
		for {
			if len(ch) > 0 && i%2 == 0 {
				if i >= 100 {
					doneC <- struct{}{}
				}
				fmt.Println(<-ch)
				i++
				ch <- i

			}
		}

	}()
	go func() {
		for {
			if len(ch) > 0 && i%2 != 0 {
				if i >= 100 {
					doneC <- struct{}{}
				}
				fmt.Println(<-ch)
				i++
				ch <- i

			}
		}

	}()

	<-doneC
}

英语流利说一面

描述

输入：{1, 1, 2, 3, 4, 5, 6, 7, 7}, 要求两个和是8的元素个数

输出：6

要求：O(n)时间复杂度,不能使用其他数据结构存储，不能增添额外的空间

思路

双指针，一个指针从前往后，一个指针从后往前，如果两个指针相等，则两个指针向中间移动，如果不相等，则两个指针向中间移动，

同时这里有个问题，对于重复元素的计数问题，这里面1，1 7,7 是4对，而不是1对，不需要去重元素。


func count(a []int, sum int) int {

	left, right := 0, len(a)-1
	count := 0
	for left < right {
		target := a[left] + a[right]
		rightCount := 1
		leftCount := 1
		if target == sum {

			r := a[right]
			l := a[left]

			var pre = right - 1
			for left < pre && a[pre] == r {
				rightCount++
				pre--

			}
			pre++
			right = pre

			var next = left + 1
			for next < right && a[next] == l {
				next++
				leftCount++
			}
			left = next

			count += rightCount * leftCount
			rightCount = 1
			leftCount = 1
		} else if target > sum {
			right--
		} else if target < sum {
			left++
		}
	}

	return count
}

某上海不知名web3 公司一面

描述

1 15 threeSum https://leetcode.com/problems/3sum/

2 71 Simplify Path https://leetcode.com/problems/simplify-path/

思路

都是leetcode原题

threeSum的话，可以暴力解法，加一个map的key来去重，最后遍历map。或者使用递归，先twosum，再三sum，对于重复的元素，只计算一次，控制指针往前移并且忽略重复元素

//below generated by github copilot
func threeSum(nums []int) [][]int {
	var res [][]int
	if len(nums) < 3 {
		return res
	}
	sort.Ints(nums)
	var i int
	for i = 0; i < len(nums)-2; i++ {
		if i > 0 && nums[i] == nums[i-1] {
			continue
		}
		var j int
		for j = i + 1; j < len(nums)-1; j++ {
			if j > i+1 && nums[j] == nums[j-1] {
				continue
			}
			var k int
			for k = j + 1; k < len(nums); k++
				if k > j+1 && nums[k] == nums[k-1] {
					continue
				}
				if nums[i]+nums[j]+nums[k] == 0 {
					res = append(res, []int{nums[i], nums[j], nums[k]})
				}
			}
		}
	}
	return res
}

simple path 的话，其实就是数据结构要用对，我自己用了队列，结果不对，实际要用栈。

//below generated by github copilot
func simplifyPath(path string) string {
	var res string
	var stack []string
	var i int
	for i = 0; i < len(path); i++ {
		if path[i] == '/' {
			continue
		}
		if path[i] == '.' {
			if i+1 < len(path) && path[i+1] == '.' {
				if len(stack) > 0 {
					stack = stack[:len(stack)-1]
				}
				i++
			} else if i+1 < len(path) && path[i+1] == '/' {
				i++
			} else {
				continue
			}
		} else if path[i] == '/' {
			if i+1 < len(path) && path[i+1] == '/' {
				i++
			}
		} else {
			var j int
			for j = i; j < len(path); j++ {
				if path[j] == '/' {
					break
				}
			}
			stack = append(stack, path[i:j])
			i = j - 1
		}
	}
	if len(stack) > 0 {
		res = "/" + strings.Join(stack, "/")
	}
	return res
}

SAP accessments

描述

全是英文，题目比较简单，easy 水平，重要的是读懂问题，很长的描述

1 数组求和

2 路灯开关问题，8个路灯，有短路问题，如果前一天左右两个都开或者关，则自己今天是开，否则其他情况是关，开 1，关0,边界条件是最边上的两盏灯，认为他们两侧的灯都是关即可。问n天后，路灯的开关情况。

思路

比较简单，不写了

重点是英文

How to install archlinux on a m1 mac

Fri, 24 Jun 2022 20:40:00 +0000

Reason

I just have installed archlinux on a m1 mac. The reason is that I have a m1 mac.

How to install

Like this:

Download the archlinux iso
Mount the iso
Copy the archlinux folder to the root of the iso
Unmount the iso
Boot the iso
Install the archlinux
Reboot the mac
Enjoy your new linux

wait wait ??? right now is 2022, why the steps are so complicated?

dang dang dang

This time I just use the UTM to install it.

So the reallly steps are:

Download the utm App
Install the utm App
Open the utm App
Open the UTM Gallery
Select the archlinux iso
Click the Open In UTM button
Wait for the installation to finish
Enjoy your new linux

archlinux on a m1 mac

Performance is so good, I didn’t need to install gui tools. I just need a terminal. And I use Warp to connect to the archlinux ssh server.

Then I will try docker. And different softwares with the great gui mac provides.

Using pacman -Syu to go.

Problems && Solutions

1. can’t boot the iso, error is like `__get_cpu_fpsimd_context+0x2c/0x38`

Solution: Change the System->CPU Option from Default to ‘a64fx’.

2. pacman -Syu update error, like `error key "xxx...xxx" could not be looked up remotely on ArchLinux`

Solution: follow this one error key “xxx…xxx” could not be looked up remotely on ArchLinux.

pacman-key --init
pacman-key --populate archlinuxarm

3. network link dev lost, when I have multiple linux, and alter the first one network choices, the first one lost the network link

Solution: just reinstall the linux.

4. add a port forward, then network link dev lost

Solution: give up utm.

华为社招机考-字符串解压缩

Tue, 21 Jun 2022 20:40:00 +0000

缘起

最近参加华为的社招，有个牛客网的机考题。总分400分，共两道题，任选一道题，160分即可算即可。

从网上搜索了下，题目是这样的

字符串解压缩

题目介绍

将一段压缩后的字符串解压缩，并且排序输出。

解压规则：

每个字符串后面跟着一个数字，表示这个字符串的重复次数。例如，”a5”解压后的结果为”aaaaa”；’abc3’解压后的结果为”abcabcabc”。

排序规则：

1、根据每个字符串的重复次数升序排序，然后输出结果。例如，”a3b2”，输出的结果为”bbaaa”。 2、如果字符重复次数一样，则根据ASCII编码顺序做升序排序，然后输出结果。例如，”b2a2”，输出的结果为”aabb”。

输入描述：

输入的原始字符串仅包含字母与数字

输出描述：

输出的结果字符串仅包含字母

示例1

输入

a11b2bac3bad3abcd2

输出

abcdabcdbbbacbacbacbadbadbadaaaaaaaaaaa

我的实现


func decompress(s string) string {
	// using map to store freq
	freq := make(map[string]int)
	var key = ""
	var num = 0
	for i := 0; i < len(s); i++ {
		v := s[i]
		if v >= '0' && v <= '9' {
			//store string frequency
			num = num*10 + int(s[i]-'0')
			//for keeping get numbers
			for i+1 < len(s) && s[i+1] >= '0' && s[i+1] <= '9' {
				num = num*10 + int(s[i+1]-'0')
				i++
			}
			// set freq
			freq[key] = num
			//set key = "" and num = 0
			key = ""
			num = 0
		} else {
			// set new key
			key = key + string(v)
		}
	}

	// sort nums freq low to high
	sortRes := sortFreq(freq)
	//print numbers
	var res = ""
	for k := 0; k < len(sortRes); k++ {
		f := freq[sortRes[k]]
		for j := 0; j < f; j++ {
			res = res + sortRes[k]
		}
	}

	return res
}

type kv struct {
	Key   string
	Value int
}

func sortFreq(m map[string]int) []string {
	var kvs []kv
	for k, v := range m {
		kv := kv{
			Key:   k,
			Value: v,
		}
		kvs = append(kvs, kv)
	}

	sort.Slice(kvs, func(i, j int) bool {
		if kvs[i].Value < kvs[j].Value {
			return i > j
		}
		if kvs[i].Value == kvs[j].Value {
			return kvs[i].Key < kvs[j].Key
		}
		return i < j
	})

	var res []string
	for i := 0; i < len(kvs); i++ {
		res = append(res, kvs[i].Key)
	}
	return res
}

Go slice的一个坑

Wed, 08 Jun 2022 10:51:57 +0800

问题

最近在刷leedcode，求二叉树的路径和，给定一个二叉树，求所有符合条件的路径。原题见 113. Path Sum II

这道题需要遍历所有的节点，并且记录遍历路径上的节点，可以使用回溯法，深度优先的方法。

不过最近用习惯了广度优先的方法，把二叉树变成一个有序的队列，这种思想很好玩，把多个选择的，需要遍历的变成一个有序的来进行遍历即可，就是一个万能模板。

下面贴下代码

var result [][]int

var ch = make(chan *TreeNode, 100)
var sumChan = make(chan int, 100)
var nodes = make(chan []int, 100)

for len(ch) > 0 {
    for i := 0; i < len(ch); i++ {
        //获取当前节点
        cur := <-ch
        //获取父节点的总和
        parentSum := <-sumChan
        //获取父节点的所有路径节点序列
        parents := <-nodes
        //当前节点的总和
        curSum := parentSum + cur.Val
        //当前节点的序列
        curNodes := append(parents, cur.Val)

        if cur.Left == nil && cur.Right == nil {
            if curSum == targetSum {
                // 添加当前节点序列到结果集
                result = append(result, curNodes)
            }
        } else {
            if cur.Left != nil {
                ch <- cur.Left
                sumChan <- cur.Val + parentSum
                nodes <-  curNodes
            }
            if cur.Right != nil {
                ch <- cur.Right
                sumChan <- cur.Val + parentSum
                nodes <- curNodes
            }
        }

    }
}

大家细读一下，不知道有没有看出来哪里不对，我先贴一下结果

Input: root = [5,4,8,11,null,13,4,7,2,null,null,5,1], targetSum = 22
Output: [[5,4,11,2],[5,8,4,5]]
Explanation: There are two paths whose sum equals targetSum:
5 + 4 + 11 + 2 = 22
5 + 8 + 4 + 5 = 22

上面这段代码的输出 Output: [[5,4,11,2],[5,8,4,1]]

why ？

可以看到，问题出在了最后一个右侧的子树和节点，看代码怎么看都没有错，为啥5 变成 1 了，肯定是哪里有引用了，导致被修改掉了。

go 不是引用传递，是指传递吗？

万事不决问google,贴一段stackoverflow的问题 are-slices-passed-by-value

package main

import "fmt"

func main() {
    x := []int{1, 10, 100, 1000}
    double(x)
    fmt.Println(x) // ----> 3 will print [2, 20, 200, 2000] (original slice changed)
}

func double(y []int) {
    fmt.Println(y) // ----> 1 will print [1, 10, 100, 1000]
    for i := 0; i < len(y); i++ {
        y[i] *= 2
    }
    fmt.Println(y) // ----> 2 will print [2, 20, 200, 2000] (copy slice + under array changed)
}

reflect.SliceHeader

type SliceHeader struct {
    Data uintptr
    Len  int
    Cap  int
}

按理来讲，main 函数里面的x 应该还是原样呀，对吧，为啥double了？贴一段最高票的答案

Everything in Go is passed by value, slices too. But a slice value is a header, describing a contiguous section of a backing array, and a slice value only contains a pointer to the array where the elements are actually stored. The slice value does not include its elements (unlike arrays).

So when you pass a slice to a function, a copy will be made from this header, including the pointer, which will point to the same backing array. Modifying the elements of the slice implies modifying the elements of the backing array, and so all slices which share the same backing array will “observe” the change.

翻译过来就是go 是值传递，没有问题的，slice也是值传递，不过因为slice是一个header，所以传递的是一个header，而不是一个slice，所以修改slice的值，会修改数组的值，所以所有共享同一个数组的slice都会观察到这个修改。

回过来我们的问题

可以发现右侧的5-8-4-5 是一个符合答案的结果，但当遍历右侧子树的时候，5-8-4-1 的时候，5-8-4-1 与5-8-4-5 共享了一个5-8-4 的parents nodes，当把1 添加到5-8-4 的nodes的时候，5-8-4-5 的序列被改成了5-8-4-1。

怎么解决？

当前节点的序列应该都创建一个新的slice，然后把当前节点添加到这个新的slice里面，然后把这个新的slice添加到结果集里面。

var result [][]int

var ch = make(chan *TreeNode, 100)
var sumChan = make(chan int, 100)
var nodes = make(chan []int, 100)

for len(ch) > 0 {
    for i := 0; i < len(ch); i++ {
        //获取当前节点
        cur := <-ch
        //获取父节点的总和
        parentSum := <-sumChan
        //获取父节点的所有路径节点序列
        parents := <-nodes
        //当前节点的总和
        curSum := parentSum + cur.Val
        //当前节点的序列
        curNodes := append(parents, cur.Val)
        //新增一个nodes slice，复制之前的序列，并且更改传递
        resNodes := make([]int, len(curNodes))
        copy(resNodes, curNodes)

        if cur.Left == nil && cur.Right == nil {
            if curSum == targetSum {
                // 添加当前节点序列到结果集
                result = append(result, resNodes)
            }
        } else {
            if cur.Left != nil {
                ch <- cur.Left
                sumChan <- cur.Val + parentSum
                nodes <-  resNodes
            }
            if cur.Right != nil {
                ch <- cur.Right
                sumChan <- cur.Val + parentSum
                nodes <- resNodes
            }
        }

    }
}

结语

每一门语言都不是完美的，最好的语言，应该尽量简化理解成本，而不是让用户自己去理解。每个语言的设计也都是有tradeoffs的，有些语言的设计是为了提高性能，有些语言的设计是为了提高可读性。

高级语言是在人类和汇编语言之间的桥梁，汇编语言是高级语言和计算机之前的桥梁。

自然语言是人类的语言，会有新的AI将人类的语言变成计算机的语言吗？这些中间层，可能效率低一些，但他是增加了人类的参与度的，普适度的。

软路由系列--你的家庭linux服务器

Wed, 12 Aug 2020 22:07:00 +0000

不仅仅是路由

软路由不仅仅是一个路由器，如果你安装了发行版linux，那么他还是一台高性能的linux server，可以做很多有趣的事情。

家庭服务器

1 备份中心 必要性：假如你也有很多网站，博客，自己的一些网盘等，你怕这些数据可能会丢失，所谓狡兔三窟，自己的数据至少也要保留两份把，并且需要是不同的介质。

怎么做：软路由挂一个本地硬盘，写一些shell备份脚本，每天把你的网站的内容、数据库备份，网盘数据等同步拉到本地。并且设置备份策略，只保留30天以内，一年以内的，只保留每月初的备份。

2 code server，让vscode 无处不在 如果你要写代码，后端使用code server，可以在各个移动端，电脑等通过浏览器直接使用vscode 教程直接见github

3 mysql、mongo等数据库 配合你本地电脑使用，防止占用你的本地笔记本资源，现在的笔记本性能不要求太高，只要有个好屏幕+键盘就可以连接一个强大的后端服务器，随意玩耍

4 docker 这个就不用讲了，有了docker各种软件随意安装使用，真正的开箱即用

5 爬虫 你可以放一些自己的爬虫，让他来跑一些任务，爬一些你自己感兴趣的东西

6 bt下载&nas服务器

7 配合树莓派硬件使用 树莓派有一些gpio硬件接口，可以从淘宝买一些硬件，实现烟雾报警器、光线感应、温度计、遥控车等等好玩的东东。

软路由系列--路由器系统&软件篇

Sat, 08 Aug 2020 14:38:00 +0000

软路由的系统

软路由，软字排在了路由器前面，说明软件是软路由的头等大事。

软件分为操作系统和应用程序两类，选择了操作系统，也就选了对应的软件生态。那我们先来看操作系统。

由于我们的路由是一个网络硬件，那么哪个操作系统软件的网络软件最丰富呢？毋庸置疑，就是linux了。windows和macos也是可用的，但没有linux的网络库全和大。

适用路由器的linux操作系统，分为两种，路由器专用系统，和常见的linux发行版。下面分别讲下他们的优缺点。

路由器专用系统

如LEDE/openwrt，爱快，koolshare，是专门为路由器开发的嵌入式系统

优点自带套件，安装方便，为了软路由而生,有web管理页面,配置管理方便

缺点软件源没有常见linux发行版多，很多软件需要适配

常见linux发行版

如centos、ubuntu、debian、archlinux等

优点软件丰富，可以装几乎所有的软件

缺点配置复杂，安装麻烦，需要一定的shell、系统管理的知识

结论如果你有一定的动手能力，我推荐你使用linux发行版做你的路由器系统（有一定的硬件配置要求，比如我的是4核赛扬的cpu、2G内存，128G的ssd硬盘+1T的hdd硬盘），如果你路由器配置比较低，那么推荐使用路由器专用系统，占用资源较少。

软路由的软件

假设跟我一样，你选择了安装常见linux发行版，并且为了稳定选择了centos当作操作系统（当然你也可以选择自己的发行版），那么需要安装什么软件才能让他变成一个路由器呢？

操作系统安装 centos安装指南官方版

软件列表

dnsmasq （必选）提供dns、dhcp等功能
iptables (可选）网络利器
shadowsocks(可选）网络软件
samba(可选）本地共享
adbyby（可选）广告过滤透明代理
transmission(可选） bt下载

软件配置指南

1 dnsmasq

由于我家里是光纤，网络运营商自带了一个modem兼路由器。从网上翻了下，找到一个超密，并且超密到路由器，可以设置这个路由器为桥接或者路由功能，如果选择桥接，相当于他什么作用也没有，仅仅是一个光纤信号转换器了，这里我选择的是路由，所以也不需要安装拨号软件了。

首先：设置dhcp server，dns转发，编辑 /etc/dnsmasq.conf

interface=br0 ## 设置你的网络接口，可能与我的不同 dhcp-range=10.0.1.2,10.0.1.254,72h ## 设置你要分配的内网地址段，租约时间，dhcp server resolv-file=/etc/resolv.dnsmasq.conf ## 设置你要使用的默认dns

其次：配置系统转发封包，开启linux路由功能，这样你的linux服务器就是一个路由器了

echo 1 > /proc/sys/net/ipv4/ip_forward sysctl -p net.ipv4.ip_forward = 1

2 shadowsocks 你既然配置了dnsmasq,我推荐你设置全局透明翻墙，使用gfwlist 方案

优点：只要你局域网内的设备连上了你的路由器，所有自动翻墙，无需设置，可以让特定域名根据dnsmasq解析出来的ip强制走ss。缺点：域名列表需要维护，你可以自己设置，也可以直接使用gfwlist

首先：配置dns解析，配合使用dnsmasq进行dns转发,让你获取正确的ip。这里如果你安装的dnsmaq已经包含了ipset，则直接使用即可。把dns请求根据域名路由到特定的服务器，可以把他添加到你的配置文件即可,如下（具体示例配置如下）。

配置说明：对于google.com 的域名dns解析请求转发到本地的5353端口，并且把解析出来的ip地址放入gfwlist这个ipset集合里面。

server=/.google.com/127.0.0.1#5353 ipset=/.google.com/gfwlist

其次：设置iptables 路由规则，把上一步获取的正确的ip地址进行路由，把gfwlist ipset里面的ip地址自动路由到你的ss-server ss-redir监听的端口，iptables nat 规则如下,设置prerouting 是为了你的局域网内设备翻墙，设置output 是为了你路由器自己也能翻墙。

iptables -t nat -A PREROUTING -p tcp -m set –match-set gfwlist dst -j REDIRECT –to-port 1080 iptables -t nat -A OUTPUT -p tcp -m set –match-set gfwlist dst -j REDIRECT –to-ports 1080

最后：设置好后，你的设备先通过dnsmasq 把dns解析路由到你的ss的服务器，防止dns污染。然后根据解析出来的正确的地址，再把这些地址的访问请求路由到代理服务器，获得正确的连接。

3 adbyby 广告过滤安装启动后，会有一个监听端口，这个软件可以过滤http流量的广告，足够用了，所以只要把80端口的流量转发即可。（这个软件开启后会有性能损失）

配置iptables 规则，8118 是adbyby 监听端口

iptables -t nat -A PREROUTING -p tcp –dport 80 -j REDIRECT –to-ports 8118

4 transmission & samba

如何配置，请查看软件官方指导，比较简单。作用：下载bt，本地看视频等一个是下载bt软件，一个是本地共享服务器，bt下载的视频等可以通过samba协议在手机端&电脑端&电视等各个下挂设备使用。（这里推荐你局域网的设备，有线一定要千兆，无线也一定要千兆，传输速度不要是瓶颈） transmission 还有一个网页管理页面，还可以随时随地往里面放入下载任务。咱不多说。

软路由其他玩法

由于他是一个linux系统，你还可以把他当作一个代码仓库，可以放你自己的爬虫，可以做网络qos等管理，设置某些网站无法访问（防止熊孩子系列）等等，只要你可以想到，就可以做到，还可以配合树莓派等硬件做一些只能硬件，快乐玩耍吧

软路由系列--强大的软路由

Wed, 05 Aug 2020 20:53:00 +0000

什么是软路由？

是相对于硬路由而来的概念，先说硬路由，市面上常见的路由器基本都是各个厂商自己订购的硬件，加上自己的嵌入式系统，组成了一个常见的路由器，它可以提供路由功能，NAT,现在主流的基本都有无线AP，可以供无线上网的功能。软路由呢？软路由是软件模拟路由，它不像传统路由器有专门的硬件设备来做路由，他的路由功能由软件来模拟，系统可以跑在任何支持linux的系统之上。

为什么有软路由？

还不是市场上的路由器性能太差，cpu能力太弱，普通家庭上个网是没啥问题，但涉及到加解密等cpu消耗型工作或者一些定制化的网路需求，就无能为力了。软路由还有个优点，即价格便宜，同样性能的路由器，你买市面大厂商的可能需要几千大洋，但软路由可能几百就有同样的性能。

选择什么牌子的？

如果你有钱，土豪，不在乎电费，那随便来一台高配版都可以。如果你差钱，但不在乎电费，可以使用家里旧的电脑来搞搞，但记得要买个网卡。如果你有一丢丢预算，在乎电费，推荐买一些工控机，直接关键词软路由就可以找到很多你想要的，几百块钱就可以买一个。

软路由装什么系统？

如果你是小白，就想搞个成品的，我推荐你使用LEDE,基本的路由功能都有，而且还有很多插件可以选择，可以进行扩展。如果你是爱折腾的，我推荐你安装一个linux 发行版，而且不需要安装图形界面，装一个console的即可，常见发行版如centos，ubuntu，debian，archlinux等等

无线AP选购

软路由设置好了后，一般都是没有无线AP模块的，需要你有个专门的AP搭配使用，你可以选择购买市场上的ap，也可以买一些便宜的路由器，仅仅把它当作一个无线AP使用，因为路由器比AP便宜。由于我穷，所以买的是网件的路由器，设置成无线AP模式，当作AP使用。

软路由能干啥？

我仅仅讲下我的日常使用，我的软路由是淘宝买的一个工控机，4核的6w的小机器，性能足够。路由器系统选择的是centos。这台小机器，也是我自己的一个家庭服务器，可以装各种软件。可以当作家庭存储中心，可以播放视频，可以当作下载机器，可以翻墙，可以去广告，可以跑爬虫等等。只要你能想到，他基本都能做到。

接下来会分开讲讲软路由系统软件的选择和安装

google pixelbook install ubuntu archlinux

Fri, 24 Jan 2020 15:59:00 +0000

Happy Chinese Luner New Year

So I bought a pixelbook(2017 i5 256G) from Taobao for 450$.Then I began to tweak my pixelbook. First I switch my pixelbook to develop mode.

Install Arch Linux

First I follow a article install archlinux with legacy boot,I spent half my day troubleshooting. install-archlinux-on-pixelbook

Archlinux Problems

I install a console environment, I can’t connect to wifi,but my archlinux usb stick work well,then I found I forget install dialog and wpa_supplicant library,I install those,then I only got a ipv6 address,I know that I did not got a address, Then I go back to my chroot environment install dhclient, I manuly run dhclient got a ipv4 address,then I got connected to internet, then I install a gnome desktop environtment ,but the trackpad is lagged and I can’t stand it. So I switch back to google official linux on chromeos.

Install GalliumOs

After My first try on standlone linux, I began to know there is a website named MrChromeBox. And I know a lot of about my pixelbook.And I happend to know chrx script. So I tried and change proper mirror and downloaded finally.

GalliumOs Problem

My trackpad not working. and the hiDpi not support,so I switch back.

Install Ubuntu

I read a lot from MrChromeBox. chrx is just a legacy boot dual system. You can spare your ssd with your chrome book. and I spare 128Gb to my newly install Ubuntu.

Ubuntu problem

Ubuntu is the best ever linux on chromebook standalone I experienced. Also I got some little problems,but it work fine and gorgerous.

The stock Ubuntu is not good, the trackpad not good,the screen backlight is 100% ,voice not work. And I got answer from a website pixelbook-linux

The script above do a lot of tweaking for ubuntu.After that my trackpad is almost work like on stock chromeos, but audio not working. and the ubuntu is beautiful .

Final Advice

So in my opinion, If you want try standalone linux, I would suggest You try chrx ubuntu standard version,then install gnome-desktop,and got tweaking use pixelbook-linux.

Finally I switch back to stock chromeos.

Pixelbook Is not friendly to web development enough,Not good compared to macbook pro.

Maybe I just do little development with stock linux on chromeos. Although sometimes a little laggy and not responsive.

golang爬虫之无名小说网站

Sun, 14 Jul 2019 14:46:00 +0000

最近无聊，在看一些之前追更的小说，发现一些下载的完本质量太差，排版太乱，发现一个在线网站排版优美，质量上乘，于是简单写一个爬虫下载下来，放到 kindle 看，美哉。

当然使用自己最喜欢的 golang 了，短短几行代码就足够了。

源码贴出来，我的代码写的很烂，不过能用就行。

使用：命令行下执行命令，输入书名 id 即可下载。

后续：当然也可以改善下，使用书名下载，不过需要多一步，再加几行代码，懒得做了，以下是源码。

代码见github gist

使用letsencrypt 来加密自己的个人网站

Fri, 12 Jul 2019 22:42:00 +0000

流量黑产，在有了加密的https后偃旗息鼓，中国的大型网站为了自己的收益，也早早就拥抱了https。

自己的小站很早使用了letsencrypt，之前是ubuntu系统，certbot 机器人很好用，直接傻瓜输入命令即可。

后来从ubuntu 搬到了centos，因为自己的nginx是自定义路径安装，certbot无法使用，只好手动生成后拷贝密钥。但每隔3个月就要拷贝太麻烦。于是花点时间研究下。

letsencrypt是一个证书签署机构，原理很简单，分为两步 1 给一串文本，引导你放到自己域名的机器上，然后验证这串文本，通过后即可知道此域名属于你。 2 本地生成你自己的key，根据你提供的key，签署生成你的ca证书，并且给到你使用。

因为我的web server是nginx，所以证书的使用放到了nginx。

以上可以搞成自动化，certbot不好用的话，从官方推荐工具中选择了一个纯bash的小工具。官方小工具列表： https://letsencrypt.org/docs/client-options/ 个人推荐小工具： https://github.com/Neilpang/acme.sh

一句话理解反射

Sun, 26 May 2019 11:10:00 +0000

反射其实很简单，就是一句话的事情，看了网上的各种文章，都是讲了各种使用方法，基本都没提及为啥要有反馈？仅仅做到了知其然，不知其所以然。

我们都知道整个软件工程其实就是0和1.

数据的存储其实是存储的0和1，计算的过程中就是0和1的各种运算。随之衍生的是存储用的数据结构，运算使用的算法。

一个语言是否支持反射需要看这个语言是否有一个父类（如java的object，go的interface）。这门语言的数据结构里面存储了类型信息和数据，也就是他自己约定好的格式。

举个例子 ipv4 数据包

也就是说，当一个数据过来的时候，你就知道他是v4还是v6，知道他的长度，知道他的协议，这些都是约定好的数据。同理各语言支持的反射也是如此，当一个数据过来，他自己本身已经自带解释了，他是什么类，他有啥方法，有啥数据，只要程序读出来就好了。

以上，反射就是如此简单。

openwrt 更改登录用户名

Thu, 10 Nov 2016 12:52:00 +0000

换了电信宽带，网速很是令人沮丧，虽然是100兆的光纤，但是访问外网的话，就是4M小水管了，期间为了不停测试各个vps，为自己的路由器加了个ddns，然而这样以后，就是相当于把自己的服务器放到互联网上了，很是不安全，于是更改用户名。

更改 /etc/shadow,/etc/shadow-,/etc/passwd,/etc/passwd-,把其中的第一个root换成自己的username后，就ok了，ssh已经没问题了，可是新问题又出来了，http没法登录了。

google后发现还需要更改 /usr/lib/lua/luci/controller/admin/index.lua 把其中的 page.sysauth = “root” 换成 page.sysauth = “username” ，其中username为你想要更换的名字，而后就可以愉快的登录了。

这样其实还有个问题，我的是15.05版本，登录页默认有用户名，而且这个还没有防暴力登录机制，为了安全，我把默认的用户名修改了，当然也可以去掉，修改/usr/lib/lua/luci/view/sysauth.htm 模板文件，把其中的

<input class="cbi-input-user" type="text" name="luci_username" value="<%=duser%>" />

改为

<input class="cbi-input-user" type="text" name="luci_username" value="username" />

或者，直接把value去掉也可以，混淆敌人。

Inbox Gmail 邮件通知推送收不到

Wed, 12 Oct 2016 17:26:00 +0000

最近折腾手机，最新的Pixel 出来后，Android 给他一个专属App ，名叫Google Assistant。看着就是很有趣，而且很方便，最主要还是比较智能。可惜自己的手机是Nexus6，并不能使用。刷Xda，看到修改build.prop 就可以成功欺骗Google 从而使用，于是修改build.prop为

    ro.product.model=Pixel XL
    ro.opa.eligible_device=true

然后重启手机，清空Google App 的data，长按中间home键，然后就可以使用了。

可惜，这样完了以后，Google App 的信息流就没了，也就是以前的Google Now，而且选择加入也不行，说是你的账户不能使用此服务，只能按照老方法，清除 Google Play Service，Google App，Google Play Store，Google Service Framework数据，桌面长按，选择 Setting，选择Accounts&Privacy，点击Google Account，点击Sign Out，然后返回桌面，选择 I’m In，开启Google Now.

问题接踵而至，然后邮件推送失败，gmail，inbox 都是收不到邮件推送了。接着；继续清除数据才能成功，方法如下

清除 Google Play Service，Google Play Store，Google Service Framework， Inbox， Gmail， Exchange Services（这个最重要，莫要忘了）的数据，如无意外，发一封测试邮件吧，就能看到邮件推送通知了。

另外吐槽，Google自家的设备推送邮件太慢，还没有Apple 的设备快，每次邮件都是我的iPhone 先收到推送，反而是Nexus 后收到推送，垃圾 Google（手动滑稽）。

typecho 搬家出现500数据库错误

Thu, 29 Sep 2016 15:42:00 +0000

这两天，测试了vultr，用站长ping测试了下，这个ping比我远在美国的机器好多了，虽然以前的vps用着也还行，但好在vultr很便宜，而且现在还有各种优惠赠送，所以就把博客什么的一块迁移到这里来了。

打包，备份数据库，scp到新的机器上，添加nginx信息，而后打开首页，我就坑了，发现是500 数据库错误，百思不得其解，自己本地数据库链接信息没有错误，google 也没有找到正确答案，于是乎，我拿出杀器，从官方下载原版的typecho，把install.php 拷贝到网站目录下，然后安装，重新生成config.inc.php；对比了一下以前的config.inc.php发现，数据库的参数设置有误，我的可工作的数据库配置如下图 ![BA82D82C-7709-4E86-96D0-6CEF40B28B3E.png][1] [1]: http://zhaowang.me/usr/uploads/2016/09/1050427988.png

应该是我的数据库变化了吧，不管如何，搞定成功。

首页是ok了，兴高采烈了没多久，发现子页面全部是404；

这个一看就知道是php-pathinfo的锅，以前的配置文件也不管用了，所以直接把include enable-php.conf 改成 include enable-php-pathinfo.conf 搞定，顺带贴出来

  location ~ [^/]\.php(/|$)
  {
      fastcgi_pass  unix:/tmp/php-cgi.sock;
      fastcgi_index index.php;
      include fastcgi.conf;
      include pathinfo.conf;
  }

搞定，终于可以愉快的写博客了。

openvpn 折腾记

Thu, 12 May 2016 21:54:00 +0000

自己平时用的vps，一直使用的是centos，可是后来自从用了ubuntu以后，发现ubuntu很简单，而且对于自己这个半吊子来说，ubuntu很好用。

于是把vps重装了个ubuntu的发行版，而后以前所用的openvpn就不能用了。

按照以前教程，使用的ufw防火墙，然后配置使用，折腾了半天，也没弄好。

于是google了一番，发现一个国外大神做了一个自动安装的脚本，哇哈哈，看了一下代码，知道自己的iptables没有设置转发，而ufw貌似设置了，没管用。对于半吊子的我来说，能用就足够了。

附上脚本地址。https://github.com/Nyr/openvpn-install/

欺骗你的进度条

Mon, 15 Feb 2016 10:50:53 +0000

打开极品飞车，然后显示更新，出现一个进度条，进度条一共是80m，显示已经下载了70m，还有10m正在走进度条。我为此特意去看了下使用流量，果然就是走了10m。

同样的还有google play store更新app的时候，比如说显示一共是25m，下载到10m就开始安装了，不明白这个25m难道是全量包，下载的10m是增量更新吗？亦或这是压缩算法所致？25m的压缩到10m，然后解压更新，亦或也是如同极品飞车的逻辑，逗你玩，欺骗你呢。

利用hosts走向世界

Wed, 30 Sep 2015 11:16:00 +0000

这肯定是老生常谈了，至于为什么发个这个，因为我的伪技术分类下没有文章，所以就随便写一篇凑数。

=================================

hosts文件，其实就是起到域名转换作用，正常情况下，计算机器是通过ip地址通讯的，显然人脑比较笨，记不住ip地址，所以有了一个转换，也就是有了域名，人们输入域名，然后需要去dns提供商查询下该域名所对应的ip地址，然后计算机继续通过ip地址通讯。

替换系统的hosts文件后，省去dns查询，直接给了计算机ip地址，省去了去查dns，dns就给不了你不能用的ip，你也能上网了。

以上，科普不一定对，反正我也不知道。

=================================

linux和os x下，替换 /etc/hosts 文件，记得不要把 localhost 127.0.0.1 给删了

windows下，替换 /windows/system32/drivers/hosts 文件。

至于其他设备，详见 https://en.wikipedia.org/wiki/Hosts_(file)

=================================

福利：hosts文件百度盘：http://pan.baidu.com/s/1bnyQXLP

伪技术 on 黑猫说

软路由系列--Others

Others

Samba

把Sonarr的docker IP添加到Transmission 访问白名单

fstab

rc.local

软路由系列--Docker

Why Docker

Docker 安装

Docker 软件列表

软路由系列--续篇--代理和DNS设置

为啥要写这个

Clash代理

禁用Ubuntu自带的DNS

开启dhcp服务,给其他设备分配ip或者提供dns服务

Clash的DNS设置

软路由系列--路由器系统-Ubuntu

软路由的系统

Ubuntu 22.04.02

开启软路由功能

开启dhcp服务,给其他设备分配ip或者提供dns服务

开启linux转发和nat功能

完结

go解决c10k problem(二)--db版下单场景

前言

DB选择

业务场景

主要对象

主要流程

表现

get 接口 读

下单接口 事务写

问题出现了

1 慢sql

原因

解决

2 锁表导致的

原因-为啥锁表报错

锁表报错解决

解决1-读加缓存

解决2-库存拆分

解决3-订单单表新增

切换成mysql

解决4-db最大连接数

解决5-docker-proxy load 高

解决6-换DB，加配置

结论

go解决c10k problem(一)

零：缘起

一：go http server

二：go http client 压测的client

2.1 压测client选择

2.2 先选择现有的试试效果

三：可观测

3.1 观测内容

3.2 观测方案

四：实战

4.1 Mac 实践

问题

解决

4.2 Linux 实践

问题1

结果1

解决1

解决2

30k+的top 和并发数

40k的结果

结语

参考

typeScript的一个坑

缘起

问题来龙去脉

业务bug简单描述

复现代码

理论期望的结果

实际结果

why?

解决方案

后记

get 接口读

下单接口事务写

shopee 算法一面螺旋矩阵，反向螺旋矩阵

shopee 算法二面手写LRU

英语流利说一面

某上海不知名web3 公司一面

1. can’t boot the iso, error is like `__get_cpu_fpsimd_context+0x2c/0x38`

2. pacman -Syu update error, like `error key "xxx...xxx" could not be looked up remotely on ArchLinux`