Coding and Life

初识RAG

Wed, 02 Oct 2024 23:11:05 +0800

初识RAG

RAG: Retrieval Augmented Generation检索增强生成

任务说明：了解到现有大模型的缺陷和RAG的优点和流程

任务要求：

了解大模型现有的缺点

理解RAG的流程和实现步骤

清楚RAG的需要的技术

打卡要求：阅读LangChain与RAG的文章 579和LangChain的官方文档 228，列举LangChain能实现的功能。

vagrant + centos7创建3节点集群

Sun, 15 Jan 2023 21:33:12 +0000

vagrantcentos创建节点集群坑设置节点的网络的时候需要给一个属性name确保节点启动的时候集群里面的节点会绑定到同一个网络平面_nodevmnetwork为了防止节点启动的时候端口被随机分配绑定宿主机端口我们可以配置将其转发到一个固定的端口_nodevmnetwork配置文件_#vagrantfilevagrantconfigure()do_config_#configvmnetworkauto_config_false()eachdo_i_configvmdefinedo_node_#设

Argparse Entrance Like Click

Mon, 19 Sep 2022 00:30:54 +0800

使用python argparse实现简单的click

python3 argparse 文档

python3 ArgParse教程

需求

实现一个类似click command的类，支持将函数作为命令注册进去，调用这个类的时候，解析命令行参数，执行对应的注册函数。

可以用装饰器的方法进行函数注册以及参数添加

类名： Entrance

方法：

注册： Entrance.register
参数：Entrance.option

实现

entrance.py

# encoding: utf-8
"""the only entrance for the program"""
import argparse


class EntranceConflict(Exception):
    pass


class Entrance:
    def __init__(self):
        self.parser = argparse.ArgumentParser()
        self.sub_parser = self.parser.add_subparsers()
        self.entrances = {}

    def register(self, name=None):
        """ 注册一个函数作为入口
        可以指定name，否则默认使用函数的名字
        """
        def decorator(f):
            entrance_name = name or f.__name__
            if entrance_name in self.entrances:
                raise EntranceConflict(f"entrance {entrance_name} already registered.")
            # make parser
            _parser = self.sub_parser.add_parser(name=entrance_name)
            _params = f.__entrance_params__
            for _args, _kwargs in _params:
                _parser.add_argument(*_args, **_kwargs)
            _parser.set_defaults(processor=f)
            # add parser to entrances
            self.entrances[entrance_name] = _parser

            return f

        return decorator

    def option(self, *args, **kwargs):
        """ 注册一个函数的参数
        参数格式参考 argparse.ArgumentParser.add_argument
        """
        def decorator(f):
            # set tmp attrs for f
            if not hasattr(f, '__entrance_params__'):
                f.__entrance_params__ = []
            f.__entrance_params__.append((args, kwargs))
            return f

        return decorator

    def __call__(self, *args, **kwargs):
        args = self.parser.parse_args()
        # extrac args
        params = vars(args)
        processor = params.get('processor')
        if processor:
            del params['processor']
            return processor(**params)
        else:
            print('un processable entrance: {}'.format(args))
            self.parser.print_help()


entrance = Entrance()

调用

写一个简单的调用demo

使用mongodb自带的ObjectID获取记录生成时间

Wed, 01 Jun 2022 14:02:38 +0800

有些时候，我们在写入mongo数据的时候，可能需要记录这条数据的插入时间，我们一般情况下回给记录增加一个 create_time。

实际上，如果我们插入的数据含有 ObjectId 的话，那么其实这个id是包含了生成时间的，同时也可以作为记录的主键，一举多得。

以python为例，我们有这样一条记录：

document = {
    "_id": ObjectId("5dfc8ac5d3fa12967b8888ec"),
    "user": "mike",
    "age": 19,
}

这时候，我们可以使用ObjectId自带的generation_time属性，获取这条记录的插入时间：

time = ObjectId("5dfc8ac5d3fa12967b8888ec").generation_time
print(time)

输出：

datetime.datetime(2019, 12, 20, 8, 48, 5, tzinfo=<bson.tz_util.FixedOffset object at 0x7f874030f9a0>)

需要注意到的是，里面的时区信息，显示的是一个 FixedOffset，即固定偏移，我们看 generation_time 属性的定义：


utc = FixedOffset(0, "UTC")
"""Fixed offset timezone representing UTC."""

class ObjectId(object):
    # ... 省略其他代码 ...
    @property
    def generation_time(self):
        """A :class:`datetime.datetime` instance representing the time of
        generation for this :class:`ObjectId`.

        The :class:`datetime.datetime` is timezone aware, and
        represents the generation time in UTC. It is precise to the
        second.
        """
        timestamp = struct.unpack(">I", self.__id[0:4])[0]
        return datetime.datetime.fromtimestamp(timestamp, utc)

可以看到这个属性是从一个时间戳生成的，并且生成的时候指定了固定的 UTC-0 时区，而我们是处于东八区，因此，如果直接使用 generation_time 属性的话，得到的时间并非我们当前时区的时间，还需要做一个转化，只需要简单的对 datetime.datetime 对象调用astimezone方法，即可：

使用Pip Tools生成好看的依赖文件

Tue, 24 May 2022 14:16:18 +0800

项目地址： https://pypi.org/project/pip-tools/

pip-tools 是一个命令行工具集合，主要有两个命令： pip-compile，pip-sync，现在主要用的是 pip-compile

在写python项目的时候，我们通常会依赖到其他的包，比如写一个后端的服务，我们可能会依赖到flask/pymysql这些基础的包，随着开发的进行，我们还可能会引入更多的依赖。

这些python依赖包构成了一个完整的服务，开发完成后，我们将这些服务部署到服务器上时，只需要安装好对应的依赖，便可以直接运行服务。

但是，如果我们不将生产环境的依赖固定下来的话，整个服务可能会因为某一次服务更新，其中某个的更新带来的不兼容导致整个服务崩溃。比如pyjwt，在1.7.1版本之前生成的jwt-token是一个bytes类型，我们将其转换成为字符串需要使用到decode()方法。但是在更新到2.0之后，生成的jwt-token是一个字符串类型，如果我们对其再调用decode方法的话，就会发生错误。

这就显现出了固定依赖的重要性了。

通常，固定依赖，我们可以在开发环境使用 pip freeze命令，直接将开发环境的所有版本固定下来到一个 requirements.txt 文件里面，这是懒人做法，当然也很有效。但是文件里面会带有一些系统的依赖版本，比如urllib 之类的，这些我们是不需要再次安装的，所以，如果这些依赖出现在 requirements.txt 文件里面，就会显得不那么干净。

这时，我们可以使用 pip-tools里面的 pip-compile 工具，对依赖进行编译，生成一份漂亮的依赖文件。

直接生成最新依赖

首先，我们将项目中直接依赖的包写到requirements.in文件里面

requirements.in

pymysql
flask

使用 pip-compile 自动使用最新依赖版本生成依赖文件

命令： pip-compile, 输出requirements.txt文件：

requirements.txt

#
# This file is autogenerated by pip-compile with python 3.8
# To update, run:
#
#    pip-compile
#
--index-url https://pypi.doubanio.com/simple
--trusted-host pypi.doubanio.com

click==8.1.3
    # via flask
flask==2.1.2
    # via -r requirements.in
importlib-metadata==4.11.4
    # via flask
itsdangerous==2.1.2
    # via flask
jinja2==3.1.2
    # via flask
markupsafe==2.1.1
    # via jinja2
pymysql==1.0.2
    # via -r requirements.in
werkzeug==2.1.2
    # via flask
zipp==3.8.0
    # via importlib-metadata

这样，我们就得到了一份漂亮的依赖文件，我们还可以清晰的看到某一个依赖包是哪个包的依赖。

HTML a标签下载json数据

Mon, 09 May 2022 20:52:39 +0800

假如我们有一个json文件：example.json，我们想要将这个文件的连接放到网站上提供下载。

在HTML中这样写：

<a href="http://lingzihuan.icu/leetcode-submissions.json">点击下载</a>

点击下载

当我们点击链接的时候，chrome浏览器会自动打开一个页面，然后将json文件的内容加载进来，但是，当我们想要将文件下载到本地的时候，还得自己右键点击，然后选择”另存为“。

看过 Stack Overflow 上的提示，看到可以给其设定 download属性：

<a href="http://lingzihuan.icu/leetcode-submissions.json" download>点击下载</a>

点击下载

需要注意的是，href里面的内容需要是与当前网页同源的url才可使用。

Python Functools: 几个有意思的工具函数

Thu, 05 May 2022 09:38:45 +0800

functools 模块应用于高阶函数，即参数或（和）返回值为其他函数的函数，如装饰器、sorted函数的key参数等。通常来说，此模块功能适用于所有可调用对象。

https://docs.python.org/zh-cn/3/library/functools.html

发现functools里面有几个有意思的函数，记录一下：

cmp_to_key

将(旧式的)比较函数转换为新式的 key function . 在类似于 sorted() ， min() ， max() ， heapq.nlargest() ， heapq.nsmallest() ， itertools.groupby() 等函数的 key 参数中使用。此函数主要用作将 Python 2 程序转换至新版的转换工具，以保持对比较函数的兼容。

比较函数意为一个可调用对象，该对象接受两个参数并比较它们，结果为小于则返回一个负数，相等则返回零，大于则返回一个正数。key function则是一个接受一个参数，并返回另一个用以排序的值的可调用对象。

实例：

使用sorted + cmp_to_key，实现逆序排序

from functools import cmp_to_key
def mycmp(a, b):
    return b - a
arr = [1,9,3,7,8,2]
arr = sorted(arr, key=cmp_to_key(mycmp))
print(arr)

输出：

[9, 8, 7, 3, 2, 1]

一般的 key function 只接受一个参数，使用cmp_to_key，可以实现自定义的排序逻辑，如上述，也可以实现其他逻辑，比较经典的是 leetcode-179最大数，要求我们将数字按照特定的规律排序，然后返回一个长的字符串，参考答案：

class Solution:
    def largestNumber(self, nums: List[int]) -> str:
        # 第一步：定义比较函数，把最大的放左边
        # 第二步：排序
        # 第三步：返回结果
        def compare(x, y): return int(y+x) - int(x+y)
        nums = sorted(map(str, nums), key=cmp_to_key(compare))
        print(cmp_to_key)
        return "0" if nums[0]=="0" else "".join(nums)

如上述的排序，也可以做一个自定义的排序逻辑，如：如果是偶数，排序在前面，奇数排序在后面，然后奇数和偶数各自排序：

Linux创建简单的systemd服务

Wed, 04 May 2022 22:38:12 +0800

参考地址：

前言

systemd是系统的服务和进程的管理工具，在linux系统下，我们使用 ps aux | head，我们可以看到，系统启动的第一个进程就是systemd。

有时候，我们想要让程序运行在后台，而不是一直在前台，开一个终端挂着。（使用nohup可以实现这个）

有时候，想要在开机的时候就自动启动某个服务，比如redis、mysql、nginx这些，这时候，我们就可以将这些程序的启动编写成为一个服务，这样，在系统启动的时候，systemd会自动加载服务配置，然后启动这些服务。

现在，我想要创建一个python jupyter notebook服务。

创建文件

systemd services存在路径 /etc/systemd/system 下，我们在这路径下创建的 .service 文件，都可以作为系统服务运行。

我们创建一个 notebook.service

vi notebook.service

文件创建完毕后，我们开始编写里面的内容，一个 .service文件里面包含三个关键部分： Unit, Service, Install

Unit

对于一个简单服务来说，我们在 [Unit] 这个块只要写上服务描述就可以了，字段为Description。

[Unit]
Description=Jupyter notebook service at port[8080]

Serivce

[Service] 块是服务配置的集合，这里面的配置声明了该如何去运行这个服务。

[Service]
Type=simple
ExecStart=/usr/bin/env /root/miniconda3/bin/jupyter notebook
Restart=on-failure
User=root
WorkingDirectory=/tmp/notebook

在Serivce声明中，我们首先要说明这个服务的类型 Type=simple

然后，是最重要的部分，我们需要告诉系统应该去执行什么东西： ExecStart=/usr/bin/env /root/miniconda3/bin/jupyter notebook，这里，我们指定了执行 jupyter notebook 这个命令，前面加载了用户的环境变量。

随后指定这个服务的重启策略：Restart=on-failure，我要求的是启动失败后重启

最后，这个服务运行的角色：User=root，以及运行时所在路径： WorkingDirectory=/tmp/notebook

Install

[Install] 块声明了当前服务应该应该怎样启用，常用的就是 WantedBy=multi-user.target

[Install]
WantedBy=multi-user.target

启动服务

服务写完了，我们需要将其启动起来：

LeetCode 179：最大数 -- 一道有点意思的题目

Thu, 28 Apr 2022 22:24:12 +0800

今天做了一道有点意思的算法题目，在这里记录下。提交记录

leetcode 179: 最大数

给定一组非负整数 nums，重新排列每个数的顺序（每个数不可拆分）使之组成一个最大的整数。

注意：输出结果可能非常大，所以你需要返回一个字符串而不是整数。

示例 1：

输入：nums = [10,2] 输出：“210” 示例 2：

输入：nums = [3,30,34,5,9] 输出：“9534330”

提示：

1 <= nums.length <= 100 0 <= nums[i] <= 109

上最终AC代码：

def greater(a, b):
    # 对比函数，a > b
    # a, b expect str
    return int(a + b) - int(b + a) > 0

# 快排
def pivot(arr, low, high):
    x = arr[high]
    j = low - 1
    for i in range(low, high):
        if greater2(arr[i], x):
            j += 1
            arr[i], arr[j] = arr[j], arr[i]
    j += 1
    arr[j], arr[high] = arr[high], arr[j]
    return j

def quick_sort(arr, low, high):
    if low < high:
        pi = pivot(arr, low, high)
        quick_sort(arr, low, pi - 1)
        quick_sort(arr, pi + 1, high)

class Solution:
    def largestNumber(self, nums: List[int]) -> str:
        nums = [str(n) for n in nums]
        quick_sort(nums, 0, len(nums) - 1)
        if nums[0] == '0':
            return '0'
        return ''.join(nums)

自己写一个快排有点多此一举的意思，完全可以用到python自带的sorted函数。

Go与Hdf5，数据读写实践

Sat, 23 Apr 2022 22:10:10 +0800

前言

HDF5 (Hierarchical Data Format) 是由美国伊利诺伊大学厄巴纳-香槟分校，是一种跨平台传输的文件格式，存储图像和数据

优势

通用数据模型，可以通过无限多种数据类型表示非常复杂、异构的数据对象和各种各样的元数据
高速原始数据采集
可移植和可扩展，文件大小没有限制
自描述的，不需要外部信息应用程序来解释文件的结构和内容
拥有用于管理、操作、查看和分析数据的开源工具和应用程序软件生态系统
在各种计算平台和编程语言（包括C、C++、Fortran90和Java）上运行的软件库。

参考文章链接：大数据存储 hdf5简介

实践

环境安装

对于go语言，hdf5已经有了支持的库： gonum/hdf5，我们可以直接安装这个包，并且使用。

需要注意的是，这个包使用了 cgo，依赖了hdf5的C语言库，因此，需要我们自己预先安装，使用centos系统，可以很方便安装，直接使用命令：

yum install -y hdf5 hdf5-devel

当然，如果系统没有软件源的话，hdf5也提供了源码安装，下载 hdf5-1.12.1，解压后，执行安装：

cd hdf5-1.12.1
./configure --prefix /usr/local
make -j 2 && make install

然后我们初始化一个项目，名为 h5，用于编写go、hdf5 的简单测试用例

mkdir -p ~/go/src/h5
cd ~/go/src/h5
go mod init
# 安装
go get -v gonum.org/v1/hdf5

使用

创建文件

func main() {
	// 创建hdf5文件
	f, err := hdf5.CreateFile("data.h5", hdf5.F_ACC_TRUNC)
	if err != nil {
		panic(fmt.Errorf("failed to create hdf5 file: %e", err))
	}
	defer f.Close()
    fmt.Println("File created.")
}

创建文件的代码就一行： hdf5.CreateFile("data.h5", hdf5.F_ACC_TRUNC)，其中 data.h5 为文件的名称，使用flag为hdf5.F_ACC_TRUNC，如果文件已存在的话，会清除原始文件里面的内容。

使用python socket实现双向的tcp通信

Fri, 22 Apr 2022 13:53:32 +0800

很久之前玩过的python socket，今天用来做个双向的通信程序。

服务端代码：

server.py

# coding: utf-8
# tcp stream server
import socket
import logging
import time
import datetime as dt
from threading import Thread, currentThread
# 配置logging
logging.basicConfig(
    level=logging.INFO,
    format="%(asctime)s %(levelname)s %(process)s %(threadName)s |%(message)s",
)


class Server:
    """ socket 服务端 """
    def __init__(self, host='localhost', port=8099):
        self._sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        self._sock.bind((host, port))
        self.msg = None

    def read(self, conn: socket.socket = None):
        """ 从tcp连接里面读取数据 """
        while True:
            try:
                data = conn.recv(1024).decode()
            except Exception as e:
                logging.info("recv failed: %s", e)
                return
            logging.info("[R %s]<< %s", currentThread().getName(), data)
            self.msg = data
            time.sleep(1)

    def write(self, conn: socket.socket = None):
        """ 向tcp连接里面写入数据 """
        while True:
            msg = f"{dt.datetime.now()} - {self.msg}"
            logging.info("[W %s]>> %s", currentThread().getName(), msg)
            try:
                conn.send(msg.encode())
            except Exception as e:
                logging.info("send failed: %s", e)
                return
            time.sleep(1)

    def serve(self):
        """ 开启服务 """
        self._sock.listen()
        logging.info("Serving...")
        while True:
            logging.info("Waiting for connection...")
            conn, addr = self._sock.accept()
            logging.info("Recived new conn: %s from %s", conn, addr)
            # 开启读写线程处理当前连接
            Thread(target=self.read, args=(conn, )).start()
            Thread(target=self.write, args=(conn, )).start()


if __name__ == '__main__':
    s = Server()
    s.serve()

以上就是服务端代码，简单的开启了一个socket服务器，接受连接，然后开启两个线程，每隔一秒，同时向连接中读写数据。

go: 读取文件

Mon, 18 Apr 2022 00:05:28 +0800

学习网站： https://gobyexample.com/reading-files

可以直接读取文件里面的所有内容到内存里面：

data, err := os.ReadFile("/tmp/data")
fmt.Println(string(data))

有时候想要自定义一些操作，比如读取文件里面的某些内容，从某个位置开始读取等，这时候，我们可以用 os.Open 打开一个文件，返回一个 os.File 对象。

f, err := os.Open("/tmp/data")

我们可以定义一个缓存（5个字节的[]byte类型），然后从文件中读取内容，读取的内容大小上限为5：

b1 := make([]byte, 5)
n1, err := f.Read(b1)
fmt.Printf("%d bytes read from file: %s\n", n1, string(b1))

调用 f.Read来读取文件，返回两个结果，第一个为实际读取的内容长度，第二个为error。我们定义了一个长度为5的 b1 来存储文件内容，但是文件里面的内容长度可能只有3，因此，n1不一定等于5，它是实际读取的长度。

同样，我们还能用 os.Seek，来查找文件的位置，第一个参数为 offset，意味着偏移量，第二个参数为 whence，

0表示从文件的开始位置进行偏移查找
1表示从文件的当前位置开始偏移，如果之前已经设置过偏移，再次设置则从当前位置开始偏移
2表示从文件的末尾开始偏移

o2, err := f.Seek(6, 0)
b2 := make([]byte, 2)
n2, err := f.Read(b2)
fmt.Printf("%d bytes read at %d\n", n2, o2)
fmt.Printf("Value is : %s\n", string(b2[:n2]))

golang 的 io包提供了一些有用的函数，帮助我们高效读取。比如 io.ReadAtLeast，可以更健壮地实现上的读取操作：

o3, err := f.Seek(6, 0)
b3 := make([]byte, 2)
n3, err := io.ReadAtLeast(f, b3, 2)
fmt.Printf("%d bytes @ %d: %s\n", n3, o3, string(b3))

如果想要将文件指针倒回到最初的位置，没有内置的函数，但是使用 f.Seek(0, 0) 可以实现同样的效果：

_, err := f.Seek(0, 0)

golang的 bufio 包提供了 缓冲读取器，它提供和额外的读取方法，对于少量的读取很有用：

r4 := bufio.NewReader(f)
b4, err := r4.Peek(5)
fmt.Printf("5 bytes: %s\n", string(b4))

最后，我们应该在结束的时候关闭文件：

go: grpc和protobuf

Sat, 16 Apr 2022 22:34:33 +0800

gRPC

一个高性能、开源的通用RPC框架。

gPPC是一个现代的开源高性能的远程过程调用框架，并且可以运行在任何环境中。它可以有效地连接数据中心内和跨数据中心的服务，支持负载均衡、跟踪、健康检查和身份验证。它也适用于分布式计算的最后一英里，将设备、移动应用程序和浏览器连接到后端服务。

gRPC is a modern open source high performance Remote Procedure Call (RPC) framework that can run in any environment. It can efficiently connect services in and across data centers with pluggable support for load balancing, tracing, health checking and authentication. It is also applicable in last mile of distributed computing to connect devices, mobile applications and browsers to backend services.

github 地址： https://github.com/grpc/grpc

原来是用 C++ 写的，后来也有了go语言版本：https://github.com/grpc/grpc-go

gRPC 和 go

gPPC支持多个语言和平台，包括GO、Python、C++、Nodejs等，我们接下来学习的是使用go来体验一下gRPC的功能。

go 和 protobuf

Thu, 14 Apr 2022 21:14:52 +0800

Google protocol buffers

简称protobuf，它是谷歌提供的跨语言，跨平台的，可扩展的用来将结构化的数据进行序列化的一种机制。就像XML，但是更加精简、快速和简单。我们可以先预先定义我们的协议（写到一个 .proto 文件里面），里面声明了我们需要怎么去将数据结构化，然后，我们可以使用这份proto，去生成我们指定的语言源代码文件，我们就能够很方便地从各种数据流中读取结构化数据，或者是写入结构化数据。并且是跨语言的。

Protocol buffers are Google’s language-neutral, platform-neutral, extensible mechanism for serializing structured data – think XML, but smaller, faster, and simpler. You define how you want your data to be structured once, then you can use special generated source code to easily write and read your structured data to and from a variety of data streams and using a variety of languages.

安装protoc编译器

.proto文件只是我们定义的协议文件，一般来讲，编程语言是不能直接使用这份文件的（除非是自己针对proto写一个自定义的解析逻辑，但是没人会这么闲），我们想要的，应该是简单高效的开发，可以即写即用那种。

因此，我们使用特定的编程语言编写服务时，需要将我们定义的 .proto 文件翻译（编译）成为对应的语言文件，这时，google 给我们提供了 protoc。

Go 使用mongodb

Sun, 10 Apr 2022 16:06:40 +0800

安装

mkdir go-mongo
go mod init go-mongo
go get go.mongodb.org/mongo-driver/mongo

使用

数据库里面有一条这样的数据：

{
  "_id": {
    "$oid": "6252912ec4495f97bccf41aa"
  },
  "title": "My Mongo Post",
  "create_time": {
    "$date": "2022-04-10T10:33:45.149Z"
  },
  "viewer": 201
}

连接数据库

// 关键代码
const MONGO_URI = "mongodb://localhost:27017/test"
client, err := mongo.Connect(context.TODO(), options.Client().ApplyURI(MONGO_URI))

// 优雅关闭连接
defer client.Disconnect(context.TODO())

数据查询

首先获取到对应的database以及collection

coll := client.Database("test").Collection("post")

然后查询：

coll := client.Database("test").Collection("post")
var result bson.M	// 需要一个bson.M 对象，用于存储查询回来的数据
// FindOne 接受2个参数，一个context，一个filter，filter 为 bson.D类型
err = coll.FindOne(context.TODO(), bson.D{}).Decode(&result)
if err == mongo.ErrNoDocuments {
    fmt.Printf("No document found.\n")
    return
} else if err != nil {
    panic(err)
}
fmt.Printf("Found document result: %s\n", result)

数据查询注意点：

需要一个 bson.M 对象，用于存储返回的数据
Collection.FindOne 接受3个参数，ctx、filter和opts，返回的是一个 SingleResult 对象
- ctx可以为nil，如果为nil的话，默认会创建一个 context.Backgroud的context
- filter为查询条件，为 bson.D 类型，上面代码默认为空，意味着查询任意一条数据。也可以指定特定的条件，如 bson.d{{"title", "first post"}}，意味着查询 tile 为 first post 的文档。
- opts：类型为 options.FindOneOptions 类型，查询的额外条件，比如限定返回的具体字段：&options.FindOneOptions{Projection: map[string]int{"_id": 0}}，这个options禁止返回_id字段。
使用 SingleResult.Decode方法将返回的SingleResult反序列化为 bson.M 对象，SingleResult.Decode(&result)

上述查询输出：

go：简简单单的并发网络连接

Wed, 06 Apr 2022 20:45:19 +0800

go 是天生支持并发的，我们只要使用 go func() 就可以快速实现并发。在网络服务的处理中，实现并发可以大大提高服务的吞吐量，我们来研究一下。

简单的TCP服务器

我们先来实现一个简单的tcp服务，监听8989端口，从连接中读取一段数据，这段数据表示的是当前请求的id，然后返回一段话。

服务器

server/main.go

package main

import (
	"fmt"
	"log"
	"net"
)

func main() {
	// 启动tcp连接，监听8989端口
	l, err := net.Listen("tcp", ":8989")
	if err != nil {
		log.Fatalf("Server listening error: %s\n", err)
	}
	for {
		conn, err := l.Accept()
		if err != nil {
			log.Printf("Accept error: %s\n", err)
			continue
		}
		// 接收连接,调用handleConn处理当前连接
		handleConn(conn)
	}
}

func handleConn(conn net.Conn) {
	defer conn.Close()		// 优雅关闭连接
	data := make([]byte, 4)
	conn.Read(data)
	log.Printf("Recieved connection from %s, ID[%s]\n", conn.RemoteAddr(), data)
	// 向客户端返回一句 Hello World
	if n, err := conn.Write([]byte(fmt.Sprintf("Hello world! -> ID[%s]", data))); err != nil {
		log.Printf("Write error: %s | %s\n", err, conn.RemoteAddr())
	} else {
		log.Printf("%d bytes wrote for ID[%s]", n, data)
	}
}

服务器简单，直接启动一个tcp服务，监听8989端口，然后接收到客户端连接的时候，从连接中获取当前请求的ID，然后向当前客户端返回一句 Hello World

Go：简单的跨平台rpc服务

Wed, 30 Mar 2022 10:52:00 +0800

RPC

RPC - Remote Procedure Call 称为远程过程调用，是分布式系统中，不同节点调用的方式（进程间通信），属于 C/S 模式。由客户端发起，调用服务端的方法进行通信，服务端将结果返回给客户端。

RPC的两个核心：

通信协议
序列化

序列化和反序列化是一种把传输内容编码和解码的方式，常见的编解码方式有 JSON、Protobuf 等。

大多数 RPC 架构中，都有 Client、Client Stub、Server、Server Stub这四个组件，Client 和 Server 通过 Socket 进行通信。

flowchart LR
subgraph 服务端进程
s(Server)
ss(Server Stub)
s --调用--> ss
ss --返回--> s
end
subgraph 客户端进程
c(Client)
cs(Client Stub)
c --调用--> cs
cs --返回--> c
end
客户端进程 ==网络消息==> 服务端进程
服务端进程 ==> 客户端进程

调用流程：

client 调用 client stub，同时把参数传给 client stub
client stub将参数打包编码，然后通过系统调用发送到服务端进程
客户端本地系统发送信息到服务器
服务器系统将信息发送到 server stub
server stub 将信息解码
server stub 调用真正的服务端程序 server
server 处理后，通过同样的方式，将结果返回到 client

go 实现简单的RPC服务

go内置了 net/rpc 包帮助我们实现rpc服务。

Go：简单的http服务以及Restful Api

Sun, 27 Mar 2022 15:27:00 +0800

简易 http 服务

使用 go 自带的 http 模块实现一个简单的 http 服务器，对请求者说一句 Hello, go http!

func main(){
	http.HandleFunc("/hello", sayHello)
	http.ListenAndServe(":8080", nil)
}

func sayHello(resp http.ResponseWriter, req *http.Request) {
	log.Println("In say hello")
	resp.WriteHeader(http.StatusOK)
	resp.Write([]byte("Hello, go http!"))
}

运行上述代码，在终端使用 curl 访问该地址，返回正常：

>curl http://localhost:8080/hello
Hello, go http!

且程序使用 log 打印了一句： 2022/03/27 15:32:48 In say hello

但是，我们的http方法有很多， GET/POST/PUT/PATCH/DELETE 等，我们使用任意一个方法，访问上述地址，都能得到 Hello, go http! 这句返回，如 POST:

>curl -X POST http://localhost:8080/hello
Hello, go http!

http.Request 这个结构体中，包含了一个 Method 字段，让我们可以根据不同的方法，决定不同的处理方式，我们将 sayHello 方法改造如下：

func sayHello(resp http.ResponseWriter, req *http.Request) {
	log.Println("In say hello")
	switch req.Method {
	case "GET":
		fmt.Fprintln(resp, "GET: Hello, go http!")
	case "POST":
		fmt.Fprintln(resp, "POST: Hello, go http!")
	default:
		resp.WriteHeader(http.StatusNotFound)
		fmt.Fprintln(resp, "Not found")
	}
}

请求输出：

17.go: 代码检查和性能优化

Sat, 26 Mar 2022 20:01:10 +0800

对我们的代码进行检查，有助于提高代码质量，确保代码更加符合规范。

使用 golangci-lint 进行代码检查

go语言代码分析的工具有很多，如 golint、gofmt、misspell等，我们一般使用 集成工具 golangci-lint，而不是单独使用他们。

安装

go install github.com/golangci/golangci-lint/cmd/golangci-lint@v1.32.2

查看版本

golangci-lint version

输出：

golangci-lint has version v1.32.2 ...

运行检查：

golangci-lint run quality/

这里的 quality是一个包，里面有一个 main.go 文件，内容如下：

quality/main.go

package main

import "os"

func main(){
	os.Mkdir("/tmp", 0666)
}

运行检查后，输出如下：

quality\main.go:6:10: Error return value of `os.Mkdir` is not checked (errcheck)
        os.Mkdir("/tmp", 0666)

因为 os.Mkdir 返回一个 error，但是我们没有处理这个 error，因此提示了这个错误。

golangci-lint 配置

golangci-lint是一个集成工具，里面有很多linters，我们可以用 golangci-lint linters 查看有哪些linters，以及他们的作用、启用情况，默认启用的linters如下：

deadcode - 死代码检查
errcheck - 返回错误是否使用检查
gosimple - 检查代码是否可以简化
govet - 代码可疑检查，比如格式化字符串和类型不一致
ineffassign - 检查是否有未使用的代码
staticcheck - 静态分析检查
structcheck - 查找未使用的结构体字段
typecheck - 类型检查
unused - 未使用代码检查
varcheck - 未使用的全局变量和常量检查

我们可以通过一个 .golangci.yml 来对 golangci-lint 进行自定义的配置：

16.go: 单元测试和基准测试

Mon, 21 Mar 2022 22:23:25 +0800

单元测试

单元测试就是对单元进行测试（听起来是一句废话），单元可以是一个函数、一个模块等，我们最小的单元是一个函数。

以斐波那契数列为例，实现一个测试用例

test/main.go

package main

// 斐波那契数列
func Fibonacci(n int) int {
	if n <= 0 {
		return 0
	} else if n == 1 {
		return 1
	}
	return Fibonacci(n-1) + Fibonacci(n-2)
}

我们在 main.go 里面写了一个 Fibonacci函数，用于计算对应的斐波那契值。

我们接下来写一个测试用例，测试的文件名应该是以 _test.go 结尾的，前面的名称最好是需要测试的文件名称，比如要测试 main.go，则测试文件命名为 main_test.go，而在测试文件里面，需要一个以 Test开头的函数，后面接需要测试的函数名称，如 TestFibonacci，这个函数接受一个 *Testing.T指针，且不返回任何值

test/main_test.go

func TestFibonacci(t *testing.T) {
	result := map[int]int{
		1: 1, 2: 1, 3: 2, 4: 3, 5: 5,
		6: 8, 7: 13, 8: 21,
	}
	for n, expect := range result {
		got := Fibonacci(n)
		if expect != got{
			t.Fatalf("Test Fibonacci failed: expect %d, got %d", expect, got)
		} else {
			fmt.Printf("ok, Fibonacci(%d) = %d\n", n, got)
		}
	}
}

在代码所在目录下，运行测试用例（所有）

go test -v .

输出：

15.go深入：SliceHeader，高效的slice

Fri, 18 Mar 2022 14:34:12 +0800

数组

数组由两部分组成：数组的大小和数组内部的元素类型。

// 伪代码表示
array {
  len
  item type
}

看以下两个数组的定义：

a1 := [1]string{"mike"}
a2 := [2]string{"mike"}

上述定义的两个变量，a1的类型为 [1]string，a2的类型为 [2]string，所以说，数组的大小也属于数组类型的一部分。

数组的两个限制

**一旦一个数组被声明，它的大小和内部的类型就不能改变，**我们将不能随意向其中追加任意多的元素。
另外，当我们使用数组存储大量数据，然后将数组作为函数的参数进行传值时，由于函数之间是值传递的，因此，数组的拷贝将会耗费巨大的内存。

slice 切片

我们可以将切片理解为动态的数组。

切片是对数组的封装，它的底层是一个数组存储了所有的元素，但是它可以动态地添加元素，容量不足时可以自动扩容。

动态扩容

使用内置的append方法，向切片中追加元素，返回一个新的切片。

同时，当容量不足的时候，append会自动对切片进行扩容。

func main(){
    ss := []string{"mike"} // 定义切片ss
    fmt.Printf("slice before append: %s, length=%d, cap=%d\n", ss, len(ss), cap(ss))    
    ss = append(ss, "lucy", "john") // append 追加元素
    fmt.Printf("slice after append: %s, length=%d, cap=%d\n", ss, len(ss), cap(ss))
}

输出：

slice before append: [mike], length=1, cap=1
slice after append: [mike lucy john], length=3, cap=3

数据结构

切片在go语言中是一个数据结构：

type SliceHeader struct {
	Data uintptr	// 指向存储切片元素的数组
	Len int			// 切片长度
	Cap int			// 切片容量
}

示例证明：

14.go深入：非类型安全unsafe

Tue, 15 Mar 2022 22:26:20 +0800

unsafe是不安全的，可以绕过go的安全检查机制，直接对内存进行读写，非必要不使用。

指针类型转换

go是一门强类型的静态语言，意味着一旦定义了，类型就不能改变，且类型检查在运行前已经完成。

出于安全考虑，go不允许两个指针类型进行转换，比如 *int 不能转换成 *float。

i := 10
ip := &i
var fp *float64 = (*float64)(ip)	// 尝试将 *int 转换成 *float64

在编译的时候，会报错： cannot convert ip (type * int) to type * float64，提示不可转换

unsafe.Pointer

unsafe.Pointer表示任意类型的指针，上述例子中，我们使用 unsafe.Pointer进行中转，实现指针类型转换

i := 10
ip := &i
var fp *float64 = (*float64)(unsafe.Pointer(ip))	// 尝试将 *int 转换成 *float64
*fp = *fp * 3
fmt.Println(i,*fp, ip, fp)

输出：

30 1.5e-322 0xc0000aa058 0xc0000aa058

可以看到，通过转化后的指针修改指向内存的值，原始值i也变成了30，ip和fp指向的是同一块内存地址。需要注意的是，试图通过 *fp 打印出原来内存的数据时，却出现了一个异常值，说明指针可以通过 unsafe.Pointer 进行转化，但转化后的指针不一定可以访问到原始内存的值。

unsafe.Pointer源码定义：

// ArbitraryType is here for the purposes of documentation
// only and is not actually part of the unsafe package. 
// It represents the type of an arbitrary Go expression.
type ArbitraryType int
type Pointer *ArbitraryType

ArbitraryType可以表示任意类型，在源码中只是文档需要。unsafe.Pointer是 *ArbitraryType，表示通用型指针，可以表示任何内存地址。

13.go深入：reflect 运行时反射

Mon, 14 Mar 2022 00:33:13 +0800

啥是反射

go语言中，反射为我们提供了一种可以在运行时操作任意类型对象的能力，比如，查看一个接口变量的具体类型、看一个结构体有多少字段、修改某个字段的值等。

比如 fmt.Println：

func Println(a ...interface{}) (n int, err error) {
    return Fprintln(os.Stdout, a...)
}

函数定义中有一个可变参数 a ...interface{}，我们在调用的时候，可以传1个到多个参数进去。

reflect.Value 和 reflect.Type

go语言的反射定义中，任何接口都有两个部分组成：接口的具体类型，以及具体类型对应的值。如 var i in = 3，由于 interface{}可以表示任何类型，因此i可以转化为 interface{}，将其当做一个接口，此时它在go反射中就表示成 <Value, Type>，其中Value为3，Type为int。

go反射中，标准库为我们提供了两种类型 reflect.Value和 reflect.Type分别表示变量的值和类型，并且可以用函数 reflect.ValueOf和 reflect.TypeOf分别获取任意对象 Value和Type。

func main(){
    var i int = 3
    iv := reflect.ValueOf(i)
    it := reflect.TypeOf(i)
    fmt.Println(iv, it)
}

reflect.Value

结构体定义

reflect.Value 可以通过 reflect.ValueOf获得，其结构体定义如下

type Value struct {
    typ *rtype
    ptr unsafe.Pointer
    flag
}

其里面的变量都是私有的，意味着我们只能使用它的方法，它的常用方法有：

//针对具体类型的系列方法
//以下是用于获取对应的值
Bool
Bytes
Complex
Float
Int
String
Uint
CanSet //是否可以修改对应的值
// 以下是用于修改对应的值
Set
SetBool
SetBytes
SetComplex
SetFloat
SetInt
SetString
Elem //获取指针指向的值，一般用于修改对应的值
//以下Field系列方法用于获取struct类型中的字段
Field
FieldByIndex
FieldByName
FieldByNameFunc
Interface //获取对应的原始类型
IsNil //值是否为nil
IsZero //值是否是零值
Kind //获取对应的类型类别，比如Array、Slice、Map等
//获取对应的方法
Method
MethodByName
NumField //获取struct类型中字段的数量
NumMethod//类型上方法集的数量
Type//获取对应的reflect.Type

可以总结为3类：

12.go深入：new、make和内存分配

Sun, 13 Mar 2022 23:35:38 +0800

Go语言程序所管理的虚拟内存空间会被分为两部分：堆内存和栈内存。栈内存主要由Go语言来管理，开发者无法干涉太多，堆内存则有开发者进行分配。

变量

一个数据类型，在声明之后，会被赋值给一个变量，变量存储了程序所需的数据。

变量的声明

单纯的声明变量，可以使用var关键字，如：

var s string		// 声明一个[字符串]变量，初始值为零值""
var sp *string		// 声明一个[字符串指针]变量，初始值为 nil

变量的初始化

有3种方法

声明的时候直接初始化： var name string = "mike"
声明之后再进行赋值初始化： name = "mike",此前 name 变量已经声明
直接使用 := 进行初始化： name := "mike"

值变量和指针变量初始化的区别

我们使用值初始化的时候，可以简单的这样写：

var name string
name = "mike"

但是，当我们使用指针初始化的时候：

var nameP *string   // 声明一个字符串指针
*nameP = "mike"		// 给nameP指向的地址赋值初始化

这时候，由于 nameP 指向的是一个空地址 nil，我们对这个空地址进行赋值初始化的时候，会报以下错误：

panic: runtime error: invalid memory address or nil pointer dereference

显而易见，我们无法对一个空地址赋值。

因此，**如果要对一个变量赋值，这个变量必须有对应的分配好的内存，这样才可以对这块内存操作，完成赋值的目的。**不止是赋值操作，针对指针变量，如果没有分配内存，对其进行取值时一样会报 nil异常，因为没有可以操作的内存。

new函数

声明指针变量的时候，是默认没有分配内存的，因此，我们可以使用 new 函数来进行内存的分配：

var nameP *string
nameP = new(string) 	// 分配一块string类型的内存
*nameP := "mike"
fmt.Println(*nameP)

这样，我们的nameP变量指向的就不是一个 nil 空地址了，而是指向了一块具体的字符串的内存。因此可以对其进行赋值操作。

11. go深入：值、指针以及引用类型

Thu, 10 Mar 2022 14:44:08 +0800

值类型

假设我们有一个这样的结构体：

type person struct {
    name string
    age uint
}

然后我们试图定义一个函数，修改这个结构体实例的值：

func modify(argP person){
    argP.name = "Nobody"
    argP.age = 10
}

// 我们实际运行一下这个函数
func main(){
    p := person{name: "mike", age: 19}
    fmt.Println(p)
    modify(p)
    fmt.Println(p)
}

上述的例子中，我们期望在经过了modify函数修改后，打印出来的结果是 {Nobody, 10}，然而实际上，输出的仍然是初始化的值： {mike, 19}

为啥会这样呢，因为上面定义的变量 p 是值类型，而通过modify函数传入的变量值argP只是原始值变量p的一份值拷贝，而不是原来的数据本身。

其实，我们只要在modify函数内部和外部打印出变量p和argP的地址，就可以发现他们的不同之处。

func modify(argP person){
    fmt.Printf("address of arg p: %p\n", &argP)
    // ... 
}

func main(){
    // ...
    fmt.Printf("address of p: %p\n", &p)
    modify(p)
    // ...
}

输出为：

address of p: 0xc0002905a0
address of arg p: 0xc0000d01b0

可以看到，在函数内部和外部，变量的地址是不一样的。

实际上，在go语言中，函数的传参都是值传递，也就是原来数据的一份拷贝，而不是数据本身。以上述的modify函数来说，参数argP就是原始变量p的一份值拷贝。除了struct之外，还有浮点型、整形、字符串、布尔、数组等，这些都是值类型

指针类型

回到最初的期望，我们想要修改 person 的值，只需要修改modify函数的参数为指针类型（*person），然后在对应的函数体中修改原始数据的值：

func modify(argP *person) {
    fmt.Printf("address of arg p: %p\n", argP)
    argP.name = "Nobody"
    argP.age = 10
}

这样，就Ok了。

让Hugo Papermod主题支持 Mermaid

Thu, 10 Mar 2022 09:40:06 +0800

由于我的博客文章里面用到了mermaid绘制流程图，从Jekyll迁移到Hugo之后，使用的PaperMod主题是默认不支持mermaid渲染的，搜了很多帖子，看到有很多解决办法。

比如有定义 /layouts/shortcodes/mermaid.html 的，然后在代码里面，需要用到mermaid的地方（文章里面）这样写：

{{ <mermaid> }}
... 这里写mermaid内容
{{ </mermaid> }}

但是这样的写法不是我想要的，我想要的是保留原来的写法，能够在渲染成html的时候，动态渲染 .language-mermaid 这个类的元素为 mermaid代码块。

查了一下PaperMod这个主题的代码，发现预留了 extend_head.html 这个扩展html头，太棒了！我们就可以在不改变原有主题代码的情况下，增添自己的head内容！

首先，我们新建一个文件： layouts/partials/extend_head.html，然后在里面写上mermaid的初始化代码：

<!-- 使用cdn加载文件 -->
<script src="https://cdn.jsdelivr.net/npm/mermaid/dist/mermaid.min.js"></script>
<script>
// 自定义mermaid配置
const config = {
    startOnLoad:true,
    theme: 'forest',
    themeVariables: {
        lineColor: "#fafafa"    // 由于paperMod的代码块背景是黑色的，这里将线条设置为白色
    },
    flowchart: {
        useMaxWidth:false,
        htmlLabels:true
        }
};
mermaid.initialize(config);
// 需要注意的是，要将初始化代码放到 window.onload 回调函数里面才有用
// 否则会因为在html元素加载前进行初始化，找不到元素而失效
window.onload = () => {
    window.mermaid.init(undefined, document.querySelectorAll('.language-mermaid'));
}
</script>

Ok！现在，我的文章就可以支持使用mermaid画图了！

graph LR
Hello --> Mermaid --> Yes

Jinja2: 判断变量是否为空、存在等

Wed, 09 Mar 2022 00:00:00 +0000

在 Jinja2 模板中，我们经常需要判断一个变量是否存在，里面的值是否为空等等。

检查变量是否存在，或者是否被定义

{% if variable is defined %}
    variable is defined
{% else %}
    variable is not defined
{% endif %}

检查数据的长度是否为空

对于列表类型的变量，我们可能需要知道这个列表是否为空的

{% if variable | length %}
    variable is not empty
{% else %}
    variable is empty
{% endif %}

需要注意的是，如果这个变量为非列表类型，模板渲染的时候会报错

检查变量值是否为True

{% if variable is sameas true %}
    variable is true
{% else %}
    variable is not true
{% endif %}

同样，我们也可以用关键字`and`来实现多个判断

判断变量存在且不为空（列表型变量）

{% if variable is defined and variable | length %}
    variable is defined and is not empty
{% else %}
    variable is not defined or empty
{% endif %}

判断变量存在且为true（布尔型变量）

{% if variable is defined and is sameas true %}
    variable is defined and is true
{% else %}
    variable is not defined or not true
{% endif %}

10. go深入：Go 中的指针

Sun, 06 Mar 2022 00:00:00 +0000

什么是指针

可以简单将指针理解为内存地址。

指针是一种数据类型，用来存储一个内存地址，该地址指向存储在该内存中的对象，可以是整型、字符串、或者是我们自定义的任意结构体类型。

也可以理解为：指针就是一本书上的目录上面的页码，这个页码指向具体的内容。

指针的声明和定义

以字符串指针为例

// 声明一个字符串指针变量
var sp *string
// 直接通过 & 操作符获取一个字符串的地址
s := "Hello world."
sp := &s
// 还可以使用 new 函数，传入一个类型作为参数，用以返回该类型的指针
sp := new(string)

指针的操作

针对指针的操作，有两种：获取或者修改指针指向的值

获取指针指向的值

使用 *指针变量 获取指针指向的值，如 *sp 获取sp指针指向的内存地址的值。

修改指针指向的值

修改跟获取值也是类似的，使用 *指针变量 = 值 来修改，如 *sp = "new value"，这样，就把 sp指针指向的内存地址值修改为了 new value

注意

另外，通过 var sp *string 定义的sp指针，初始值是nil，表示它没有指向任何一块内存地址，我们不能够对它进行取值和赋值操作，否则，会提示：

invalid memory address or nil pointer dereference

要解决这个问题，只需要使用 new 函数给该地址分配一块内存即可：

var sp *string = new(string)

9. go并发：Go 中的并发模式

Fri, 04 Mar 2022 00:00:00 +0000

for select 模式

这是一种常见的并发模式，我们一般使用 for {} 死循环，然后里面加select配合channel，获取协程的终止信号，来控制协程的退出

for {
    select {
    case <- done:
        // received stop signal, stopping.
        return
    default:
	    // processing ... 
    }
}

类似的还有 for range select模式，主要就是使用 for ... range 遍历某个数据数组，将数据发送到channel里面：

for _, value := range []int{} {
    select {
    case <- done:
        // 接受到终止信号
        return
    case resultCh <- value:
        // do nothing but put value to rsult channel
    }
}

select timeout 模式

select timeout模式，核心在于使用 time.After(t time.Duration) 返回一个定时的channel，使用select配合这个channel控制协程的退出。

来看一个网络访问超时的demo：

func main(){
    result := make(chan string)
    go func(){
        // simulate internet visiting...
        time.Sleep(5 * time.Second)
        result <- "Done, internet visited."
    }()
    select {
        case v := <-result:
    	    fmt.Println("result from internet: ", v)
        case <- time.After(3 * time.Second):
	        fmt.Println("Timeout!")
    }
}

pipeline 模式

pipeline流水线模式，顾名思义，就是整一个生产流程中有多个工序，后面的工序依赖前面一道工序的结果。

让github page支持mermaid语法

Fri, 04 Mar 2022 00:00:00 +0000

目前，github page 会将 markdown里面的 mermaid 块渲染成为一个 div.language-mermaid 的 html 代码块，但是，mermaid-js仅支持渲染 div.mermaid 的html代码块，因此，我们需要做一点处理。

我们只需要在文章模板的末尾，添加如下转化代码即可：

文件：_layouts/post.html
{%- if content contains 'mermaid' -%}
<script src="https://cdn.jsdelivr.net/npm/mermaid/dist/mermaid.min.js"></script>
<script>
const config = {
    startOnLoad:true,
    theme: 'forest',
    flowchart: {
        useMaxWidth:false,
        htmlLabels:true
        }
};
mermaid.initialize(config);
window.mermaid.init(undefined, document.querySelectorAll('.language-mermaid'));
</script>
{% endif %}

上述代码手动将 div.language-mermaid 添加到 mermaid引擎的渲染中。

引用

在文章里面指定文章layout，即可引用，并且渲染mermaid！

---
layout: post
---

其他方法

当然也可以在 _config.yml 配置kramdown, 让其可以将 mermaid 块渲染成 div.mermaid 这样的html的代码块，但是实现起来有点复杂。

参考： Issue https://github.com/gettalong/kramdown/issues/637

8. go并发：Context-多线程并发控制神器

Sun, 27 Feb 2022 00:00:00 +0000

协程如何退出

一般来说，我们执行协程，需要等到协程执行完毕，才能够退出。但是，当我们想要让协程提前退出，就需要一种机制，去控制协程的退出。

以下例子使用select + channel的方式，控制协程的退出


func main() {
	ch := make(chan bool)
	var wg sync.WaitGroup
	go func() {
		defer wg.Done()
        // 开启looper协程
		looper(ch)
	}()
	wg.Add(1)
    // 5秒后发送中断信号
	time.Sleep(time.Second * 5)
	fmt.Println("Signal to goroutine exit...")
	ch <- true
	fmt.Println("Signal sent.")
	wg.Wait()  // 等待协程完全退出
	fmt.Println("Exit.")
}

func looper(ch <-chan bool){
	for {
		select {
		case <-ch:
			fmt.Println("go break signal")
			return
		default:
			fmt.Println("looper is running...")
			time.Sleep(time.Second * 1)
		}
	}
}

上述例子通过一个ch channel 发送信号，让协程收到信号后终止循环。

使用Context控制协程退出

上述，我们可以通过select+ channel 的方式进行控制协程的退出，但是那是单个协程的退出，当我们想要控制多个协程的退出时，也可以用定义多个channel的方法，但是这会让代码变得十分复杂。

而Context，可以让我们跟踪到每个协程，从而更好地进行限制和控制。

使用 Context 改造上述的代码：

func main() {
	var wg sync.WaitGroup
	ctx, stop := context.WithCancel(context.Background())
	go func() {
		defer wg.Done()
		looper(ctx)
	}()
	wg.Add(1)
	time.Sleep(time.Second * 5)
	fmt.Println("Signal to goroutine exit...")
	stop()	// 向context发送停止指令
	fmt.Println("Signal sent.")
	wg.Wait()
	fmt.Println("Exit.")
}

func looper(ctx context.Context){
	for {
		select {
		case <-ctx.Done():
			fmt.Println("go break signal")
			return
		default:
			fmt.Println("looper is running...")
			time.Sleep(time.Second * 1)
		}
	}
}

上述代码实现的功能和使用select + channel也是一样的，主要改动为：

使用 getopts 获取命令行中的参数

Thu, 24 Feb 2022 00:00:00 +0000

在某些场景中，我们写的bash脚本需要获取命令行中指定的某些参数，用以判断某些条件，或者设置某些变量等。

getopts可以让我们通过指定 -a 1 的方式指定对应的参数名称和参数值。

一个更详细的小教程，可以看这里： getopts_tutorial

使用

可以使用 while getopts ":a:p:" opt; do... 的方式，将参数名称读取到 opt 变量中，然后，在循环体中，使用 $OPTARG 获取到具体的参数值。

一个小栗子，用于快捷创建新的 gihub pages 博客模板：

#!/usr/bin/env bash

# 用于快捷创建新博客
# 命令： ./new.sh -t 标签1,标签2 -n 文章标题 -l layout -c 1

layout="post"
title="new-post"
now=$(date +%Y-%m-%d)
can_comment="false"
author="ZihuanLing"

while getopts ":l:t:c:n:" opt; do
  case $opt in 
    l)
      layout="$OPTARG"
      ;;
    t) 
      tags="[$OPTARG]"
      ;;
    c)
      can_comment="true"
      ;;
    n)
      title=$(echo "$OPTARG" | sed "s/ /\-/g")
      ;;
    \?) echo "Invalid option -$OPTARG" >&2
    exit 1
    ;;
  esac 
done

if [ -z $tags ]; then
  tags="[]"
fi

filename="_posts/${now}-${title}.md"

read -r -d '' content << EOM
---
layout: ${layout}
title: "${title}"
date: ${now}
tags: ${tags}
comments: ${can_comment}
author: ${author}
---

<!-- more -->

EOM

echo "$filename"
echo "$content"
echo "$content" > $filename

第一篇GitHub Page博客

Wed, 23 Feb 2022 00:00:00 +0000

从 lemonchan.github.io fork了这个博客项目，感觉太棒了，设计很简洁，我需要的功能基本上都有。

感谢！

7. go并发：同步原语，用sync包控制并发

Sat, 19 Feb 2022 00:00:00 +0000

go在并发的时候，可能会出现多个协程同时访问一个资源的时候，这就出现了资源竞争。也可能出现协程还在运行，但是主程序却退出了的情况，这是缺少控制导致的。

用sync包，可以方便的控制资源的访问，也可以方便实现阻塞等待，让协程执行完毕再退出程序，或者执行下一步。

资源竞争

在同一个goroutine中，如果分配的内存没有被其他的goroutine访问，只在该goroutine中使用，则不存在资源竞争问题

如果同一块内存被多个goroutine同时访问，就会产生不知道谁先访问，也无法预料最后结果的情况，这就是资源竞争：

// 共享的资源
var sum = 0
func main(){
  for i := 0; i < 100; i++ {
    go add(10)
  }
  // goroutine 不会阻塞下面的代码，此处Sleep一下，防止main goroutine直接退出
  // 而导致未完成的goroutine也被终止
  time.Sleep(time.Second * 2)
  fmt.Println("Sum is:", sum)
}

func add(i int) {
  sum += i
}

上述例子中，sum变量为共享的资源，程序运行的过程中会发生资源竞争。

使用 go build、go run、go test 这些 Go 语言工具链提供的命令时，添加 -race 标识可以帮你检查 Go 语言代码是否存在资源竞争

同步原语

sync.Mutex

互斥锁，同一个时刻，只有一个goroutine能执行某段代码，其他协程需要等待该协程执行完毕后才能继续执行。

var (
	sum int
  mutex sync.Mutex
)

func add(i int) {
  mutex.Lock()
  // defer mutex.Unlock()		// 使用defer，关闭更加优雅
  sum += i
  mutex.Unlock()
}

sync.RWMutex

读写锁

6. go并发：Goroutines和Channels的声明和使用

Fri, 18 Feb 2022 00:00:00 +0000

并发，就是让程序在同一时刻做多件事情。

go语言天生自带并发属性，使得并发编程十！分！方！便！，我们只需要 go 函数名() 即可！\(^o^)/

进程和线程

进程

程序启动时，系统会为其创建一个进程

线程

是进程的执行空间，一个进程可以包含多个线程，线程被操作系统调度执行一个程序启动，对应的进程会被创建，同时也会创建一个线程（主线程），主线程结束，整个程序也就退出了。我们可以从主线程创建其他的子线程，这就是多线程并发

协程 Goroutine

goroutine比线程更加轻盈，被Go runtime调度。启动协程： go function()

// 这里启动了两个goroutine， 一个是用go关键字触发的，另一个是 main goroutine（主线程）
func main(){
  go fmt.Println("Hello goroutine.")
  fmt.Println("Main goroutine.")
  time.Sleep(time.Second)
}

Channel

多个goroutine之间，使用 channel进行通信

声明一个channel

// 直接使用 make 创建一个channel，接受的数据类型是string
ch := make(chan string)
// 一个channel的操作只有两种：
// - 发送，向chan中发送值： chan<-
// - 接受，从chan中获取值： <-chan

demo

func main(){
  ch := make(chan string)
  go func(){
    fmt.Println("Message in goroutine")
    ch <- "goroutine finished."	// send message to channel.
  }()
  fmt.Println("Main goroutine.")
  v := <-ch		// receive message from channel
  fmt.Println("Message from channel: ", v)
}

在上面的示例中，我们在新启动的 goroutine 中向 chan 类型的变量 ch 发送值；在 main goroutine 中，从变量 ch 接收值；如果 ch 中没有值，则阻塞等待到 ch 中有值可以接收为止。

5. go基础：通过 error/deffer/panic 处理错误

Thu, 17 Feb 2022 00:00:00 +0000

正确处理错误，可以让程序更加稳定。error是一个错误接口，一般来说，error是不会影响到整个程序运行的，我们可以自行处理。而panic是会导致程序直接崩溃退出的，我们也可以用 go自带的recover()来恢复panic，在程序崩溃前进行资源的释放工作。

错误

error接口

error接口只有一个Error方法，返回具体的错误信息（string）

type error interface {
    Error() string
}

一个字符串转整数的例子：

func main(){
    // try to conver alpha "a" to integer
    i, err := strconv.Atoi("a")
    if err != nil {
        fmt.Println(err)
    } else {
        fmt.Println(i)
    }
}

尝试将字符 a 转换成为整数，显然是不成功的，因此返回了err

一般而言，error 接口用于当方法或者函数执行遇到错误时进行返回，而且是第二个返回值。通过这种方式，可以让调用者自己根据错误信息决定如何进行下一步处理。

error 工厂函数

除了可以使用其他函数，自己定义的函数也可以返回错误信息给调用者

自定义error

自定义error就是先自定义一个新的类型，然后实现error接口

// 自定义一个结构体，携带错误码和具体的错误信息
type commonError struct {
    errorCode int	// 错误码
    errorMsg string // 错误信息
}

// 实现error接口
func (ce *commonError) Error() string {
    return ce.errorMsg
}

error 断言

func add(a, b int) int, error {
    if a < 0 || b < 0 {
        return 0, &commonError{
            errorCode: 1,
            errorMsg: "a and b must >= 0"
        }
    }
    return a + b, nil
}

func main(){
    sum, err := add(-1, 2)
    // 错误类型断言
    if cm, ok := err.(*commonError); ok {
        fmt.Printf("Error code = %d, error message = %s\n", cm.errorCode, cm.errorMsg)
    } else {
        fmt.Printf("Sum = %d\n", sum)
    }
}

错误嵌套 Error Wrapping

需求，将一个错误嵌套到另一个错误中：

3. go基础：函数和方法

Tue, 15 Feb 2022 00:00:00 +0000

函数和方法，大大提高了我们的代码复用率，也提高了代码的可读性。 go语言的函数和方法的定义十分简单，直接使用 func 关键字即可。

不同于python、C++等有类的概念，而这些类中，又有自己的方法，或者父类的方法。go语言中，我们可以定义一个数据结构，然后给这个数据结构实现自己的方法，同样可以实现【类】的效果，通过组合，同一个结构体中，也可以使用或者覆写其他结构体的方法。

函数

函数的组成：

关键字 func
函数名 funcName
参数 params
返回值（返回值类型）
函数体

func funcName(params) result {
	// body
}
// 示例1：普通的函数定义
func sum(a int, b int) int {
	return a + b
}
// 示例2：参数表的类型合并，(a int, b int) -> (a, b int)
func sum2(a, b int) int {
	return a + b
}
// 示例3：多值返回，用 （） 包裹起来
func sum3(a, b int) (int, error) {
	if a < 0 || b < 0 {
		return 0, errors.New("invalid params")
	}
	return a + b, nil
}
// 示例4：命名返回参数
// 这里命名的返回值是 res 和 err
// 我们可以在函数体中直接使用这两个变量
func sum4(a, b int) (res int, err error) {
	if a < 0 || b < 0 {
		// 可以直接返回
		return 0, errors.New("invalid params")
	}
	// 也可以给参数赋值，然后return
	res = a + b
	err = nil
	return
}

可变参数

// 这里的可变参数类型是一个切片
func sum5(params ...int) int {
	res := 0
	for _, num := range params {
		res += num
	}
	return res
}

需要注意的是，当函数中有普通参数，也有可变参数的时候，那么可变参数一定是放在参数表的最后的。

4. go基础：结构体和接口

Tue, 15 Feb 2022 00:00:00 +0000

接口是一种聚合类型，结构体是和调用方的一种约定，有点抽象类的意思。:)

结构体

结构体定义

结构体是一种聚合类型，里面可以包含任意类型的值，这些值就是我们定义的结构体成员，也称为字段

在go语言中，要定义一个结构体，需要使用 type+struct 关键字组合。

// 定义一个代表【人】的结构体
type person struct {
  name string	// 名称
  age uint		// 年龄
}

结构体的成员字段并不是必需的，也可以一个字段都没有，这种结构体成为空结构体。

type s struct {}

结构体声明使用

// 使用var声明一个person变量，未初始化，里面的值为各自变量的零值
var p person
// 可以使用结构体字面量初始化的方式
p2 := person{"Mike", 10} // 第一个值为 name，第二个值为age，与结构体字段定义顺序有关
// 可以指定字段名初始化，不按定义顺序
p3 := person{age: 10, name: "Mike"}

字段结构体

type address struct {
  province string
  city string
}
// 结构体的字段可以是任意类型，也可以是自定义的结构体
type person struct {
  name string
  age uint
  addr address
}

// 初始化
p := person{
  name: "Mike",
  age: 10,
  addr: address{
    province: "Guandong",
    city: "Maoming",
  },
}
fmt.Println(p.addr.province)

接口

接口的定义

接口是和调用方的一种约定，是一个高度抽象的类型，不需要和具体的实现细节绑定在一起。接口要做的就是定义好约定，告诉调用方，自己可以做什么，但是不需要知道它的内部是如何实现的我们通过 type + interface关键字定义一个接口

2. go基础：使用array/slice/map

Thu, 10 Feb 2022 00:00:00 +0000

数组，大概是每个变成语言都有基础数据结构。

Go的切片类型（slice）提供了一种方便和有效的方法来处理类型化数据序列（数组）。slice类似于其他语言中的数组，但有一些不同寻常的属性。

map可以理解为一个字典。

数组声明

可以使用 [长度]类型{} 来定义，比如 [2]string{}定义一个长度为2的字符串数组

这里的长度必须是一个常量，如果要使用变量去动态生成数组的话，需要使用make，如

make([]string, size) 这里的size是一个变变量，生成size长度的字符串数组

另外需要注意的是, [1]string 和 [2]string 不是用一种类型，长度也是数组类型的一部分

定义数组时可以省略数组的长度，此时会根据大括号{}里面的元素个数推到出数组的长度：

arr := []string{"a", "b", "c", "d", "e"}

这里会自动生成长度为5的字符串数组，适用于所有元素都被初始化的数据

但是如果只有特定元素被初始化的数组，就不合适了：

arr := [5]string{1: "a", 3: "c"}

上述表示数组初始化索引为1的值为a，索引为3的值为c，其他未初始化的为空值（字符串的空值为""）

如果我们不指定 [5]string，那么go就会根据我们定义的最大索引值3 来确定数组的长度为4

数组循环

使用传统的数组循环：

for i := 0; i < len(arr); i++ {
		fmt.Println(arr[i])
}

使用 for range 数组遍历，写法更加简洁

for index, value := range arr {
		fmt.Printf("index = %v, value = %v\n", index, value)
}

切片 Slice

切片的区间是左闭右开，如arr[2:5]，选取的索引取数是[2,3,4] 切片的底层是（原）数组，将切片内容修改之后，原数组也会改变

arr := []int{1,2,3,4,5}
sliced := arr[1:3]
// sliced = {2,3}
sliced[0] = 0
// 切片修改后，原数组内容有会改变
// arr = {1, 0, 3, 4, 5}

使用make声明切片

声明一个元素类型为string的切片，长度为5：slice1 := make([]string, 5) 还可以传入一个容量参数：slice2 := make([]string, 4, 8) 这里声明了一个长度为4，容量为8的字符串数组长度是切片内元素的个数，容量是切片的空间

1. go基础：数据类型，以及控制结构

Fri, 07 Jan 2022 00:00:00 +0000

go最近很火啊，自带高并发，内置网络模块强大，作为后端工程师一枚，自然也要学起来！

go 的基础部分跟我们之前学过的大部分语言是都是十分相似的，上手十分简单。

第一个go程序

第一个程序大都是hello嘛，向新世界打个招呼 :)

import fmt

func main(){
    fmt.Println("hello golang!")
}

数据类型以及变量声明的方式

变量声明的方式

// var 变量名 类型 = 表达式
var num int = 1
// 也可以声明变量，但是不赋值
var num int		// 这样的默认值就是int的默认值 0 
// 可以直接赋值并且声明类型
num := 1
// 可以实现多值定义
a, b, c := 1, 2, "hello"
var (
    a = 1
    b = 2
    c = "hello"
)

常量声明

常量声明，我们可以直接使用 const 关键字，不需要指定数据的类型，通常，常量我们用大写进行命名

我们指定变量的值，会自定将变量转为对应的类型

const MAX_SIZE = 10

基础类型

整型
- 有符号：int， int8， int16， int32， int64
- 无符号：uint，uint8，uint16，uint32，uint64
浮点数：float，float32， float64
布尔型：bool
字符串：string
指针
常量：使用const声明 const name = "Mike"

字符串转换

字符串转数字： strconv.Atoi("123")
数字转字符串：strconv.Itoa(123)

数字类型的强制转换：

Leetcode

Mon, 01 Jan 0001 00:00:00 +0000

Leetcode 解题记录 :)