typedef char *sds;

static inline size_t sdslen(const sds s) {
    unsigned char flags = s[-1];
    switch(flags&SDS_TYPE_MASK) {
        case SDS_TYPE_5:
            return SDS_TYPE_5_LEN(flags);
        case SDS_TYPE_8:
            return SDS_HDR(8,s)->len;
        case SDS_TYPE_16:
            return SDS_HDR(16,s)->len;
        case SDS_TYPE_32:
            return SDS_HDR(32,s)->len;
        case SDS_TYPE_64:
            return SDS_HDR(64,s)->len;
    }
    return 0;
}

/* Create a new sds string with the content specified by the 'init' pointer
 * and 'initlen'.
 * If NULL is used for 'init' the string is initialized with zero bytes.
 * If SDS_NOINIT is used, the buffer is left uninitialized;
 *
 * The string is always null-termined (all the sds strings are, always) so
 * even if you create an sds string with:
 *
 * mystring = sdsnewlen("abc",3);
 *
 * You can print the string with printf() as there is an implicit \0 at the
 * end of the string. However the string is binary safe and can contain
 * \0 characters in the middle, as the length is stored in the sds header. */ // sds的头部存储了它的长度
sds _sdsnewlen(const void *init, size_t initlen, int trymalloc) {
    void *sh; // sds的header
    sds s;
    char type = sdsReqType(initlen); // 根据size大小返回类型
    /* Empty strings are usually created in order to append. Use type 8
     * since type 5 is not good at this. */
    if (type == SDS_TYPE_5 && initlen == 0) type = SDS_TYPE_8;
    int hdrlen = sdsHdrSize(type); // 根据类型返回header长度
    unsigned char *fp; /* flags pointer. */
    size_t usable; // 可用的内存大小

    assert(initlen + hdrlen + 1 > initlen); /* Catch size_t overflow */
    sh = trymalloc?
        s_trymalloc_usable(hdrlen+initlen+1, &usable) :
        s_malloc_usable(hdrlen+initlen+1, &usable); // 三元运算符，根据trymalloc的值选择用哪个alloc函数，分配后，还会标志可用内存大小
    if (sh == NULL) return NULL; // 分配失败返回NULL
    if (init==SDS_NOINIT)
        init = NULL;
    else if (!init)
        memset(sh, 0, hdrlen+initlen+1);
    s = (char*)sh+hdrlen; // 将sh转为char*，赋值给最终字符串s
    fp = ((unsigned char*)s)-1;
    usable = usable-hdrlen-1;
    if (usable > sdsTypeMaxSize(type))
        usable = sdsTypeMaxSize(type);
    switch(type) { // 根据类型决定对s做不同的sds hdr操作
        case SDS_TYPE_5: {
            *fp = type | (initlen << SDS_TYPE_BITS);
            break;
        }
        case SDS_TYPE_8: {
            SDS_HDR_VAR(8,s);
            sh->len = initlen;
            sh->alloc = usable;
            *fp = type;
            break;
        }
        case SDS_TYPE_16: {
            SDS_HDR_VAR(16,s);
            sh->len = initlen;
            sh->alloc = usable;
            *fp = type;
            break;
        }
        case SDS_TYPE_32: {
            SDS_HDR_VAR(32,s);
            sh->len = initlen;
            sh->alloc = usable;
            *fp = type;
            break;
        }
        case SDS_TYPE_64: {
            SDS_HDR_VAR(64,s);
            sh->len = initlen;
            sh->alloc = usable;
            *fp = type;
            break;
        }
    }
    if (initlen && init)
        memcpy(s, init, initlen); // 复制initlen的init内容到s
    s[initlen] = '\0';
    return s;
}

package main

func fakeBurn() {
 for {

 }
}

package main

import (
 "flag"
 "fmt"
 "runtime"
 "time"
)

var (
 numBurn        int
 updateInterval int
)

func cpuBurn() {
 for {
  for i := 0; i < 2147483647; i++ {
  }

  // Gosched yields the processor, allowing other goroutines to run. It does not suspend the current goroutine, so execution resumes automatically.
  // Gosched让当前goroutine让出处理器，从而使得其它goroutine可以运行。它不会挂起/暂停当前的goroutine，它会自动恢复执行。
  runtime.Gosched()
 }
}

func init() {
 flag.IntVar(&numBurn, "n", 0, "number of cores to burn (0 = all)")
 flag.IntVar(&updateInterval, "u", 10, "seconds between updates (0 = don't update)")
 flag.Parse()
 if numBurn <= 0 {
  numBurn = runtime.NumCPU()
 }
}

func main() {
 runtime.GOMAXPROCS(numBurn)
 fmt.Printf("Burning %d CPUs/cores\n", numBurn)
 for i := 0; i < numBurn; i++ {
  go cpuBurn()
 }

 // 一直执行，区别是其中一个会定期打印，另一个不会打印
 if updateInterval > 0 {
  t := time.Tick(time.Duration(updateInterval) * time.Second)
  for secs := updateInterval; ; secs += updateInterval {
   <-t
   fmt.Printf("%d seconds\n", secs)
  }
 } else {
  select {} // wait forever
 }
}

127.0.0.1       localhost
::1     localhost ip6-localhost ip6-loopback
fe00::0 ip6-localnet
ff00::0 ip6-mcastprefix
ff02::1 ip6-allnodes
ff02::2 ip6-allrouters
172.17.0.1      host.docker.internal # --add-host的作用就是添加了这行到/etc/hosts
172.17.0.3      cb0565ceea26

version: "2.3" # 因为某个bug的存在，只能用version2，不能用version3
services:
  tmp:
    build:
      context: .
    extra_hosts: # 配置extra_hosts
      - "host:IP"
    command: -kIL https://host
    tty: true
    stdin_open: true

package domain

import (
 "crypto/rand"
 "math/big"

 "github.com/pkg/errors"
)

// 关键词：用户、店铺、商品、订单
//
// 场景描述：店铺展示商品，其价格为P、库存为N，用户（余额为Y）看到商品觉得合适，于是下单购买B个；
// 购买前，用户余额Y必须不小于P，商品库存N不小于B；购买后，用户余额减少P，库存减少B；
//
// 先不考虑并发情况，建立此时的领域模型

type User struct {
 name  string // 名称
 phone string // 电话

 balance Money // 余额
}

type Shop struct {
 name string // 名称
 addr string // 地址
}

type Product struct {
 name  string // 名称
 price Money  // 价格
 stock int    // 库存

 ownShop *Shop // 所属商铺
}

type Order struct {
 name string // 名称

 user    *User    // 用户
 product *Product // 商品
}

type Money int

func NewUser(name, phone string, bal Money) *User {
 return &User{
  name:    name,
  phone:   phone,
  balance: bal,
 }
}
func (u *User) Balance() Money {
 return u.balance
}
func (u *User) DeductBalance(amount Money) {
 if u.balance < amount {
  panic("not enough money")
 }
 u.balance -= amount
}

func NewShop(name, addr string) *Shop {
 return &Shop{
  name: name,
  addr: addr,
 }
}
func NewProduct(name string, price Money, stock int, shop *Shop) *Product {
 return &Product{
  name:    name,
  price:   price,
  stock:   stock,
  ownShop: shop,
 }
}
func (p *Product) Stock() int {
 return p.stock
}
func (p *Product) DeductStock(c int) {
 if p.stock < c {
  panic("not enough stock")
 }
 p.stock -= c
}

// NewOrder 用户对商品下单c个
func NewOrder(user *User, product *Product, c int) *Order {
 name, err := GenerateRandomString(12)
 if err != nil {
  panic(err)
 }

 user.DeductBalance(product.price * Money(c))
 product.DeductStock(c)

 return &Order{
  name:    name,
  user:    user,
  product: product,
 }
}

func (o *Order) User() *User {
 return o.user
}

func (o *Order) Product() *Product {
 return o.product
}

// GenerateRandomString 随机字符串包含有数字和大小写字母
func GenerateRandomString(n int) (string, error) {
 const (
  letters = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
 )

 return generate(n, letters)
}

func generate(n int, letters string) (string, error) {
 ret := make([]byte, n)
 for i := 0; i < n; i++ {
  num, err := rand.Int(rand.Reader, big.NewInt(int64(len(letters))))
  if err != nil {
   return "", errors.WithStack(err)
  }
  ret[i] = letters[num.Int64()]
 }

 return string(ret), nil
}

name: blog # 做什么都好，别忘了先起个平凡（kuxuan）的名字

on: # 指定触发动作
  push: # 动作是：git push
    branches:
      - main # 指定分支： main

jobs:
  build-deploy:
    runs-on: ubuntu-latest # 基于ubuntu
    steps:
    - uses: actions/checkout@v2 # 切换分支：git checkout
      with:
        submodules: recursive  # Fetch Hugo themes (true OR recursive)
        fetch-depth: 0    # Fetch all history for .GitInfo and .Lastmod

    - name: Setup Hugo # 博客所用的打包和部署工具
      uses: peaceiris/actions-hugo@v2
      with:
        hugo-version: latest

    - name: Build # 打包
      run: hugo --minify --baseURL=https://donnol.github.io # 指定base url，确保构建出来的内容里的超链接都在它里面

    - name: Deploy # 部署
      uses: peaceiris/actions-gh-pages@v3
      with:
        deploy_key: ${{ secrets.ACTIONS_DEPLOY_KEY }} # 这个key非常关键，一言两语很难讲清楚
        external_repository: donnol/donnol.github.io # 我的github page所在的仓库
        PUBLISH_BRANCH: main
        PUBLISH_DIR: ./public # 将本仓库的public目录下的内容提交到github page仓库
        commit_message: ${{ github.event.head_commit.message }} # 提交信息