并行：多线程同时操作多个资源类（两个或多个事件在同一时刻发生）

并发：多线程交替操作同一资源类（宏观上的并行，微观上的串行）

## concurrent.futures

是Python 3.2引入的新模块，它是在threading和multiprocessing之上的一个通用抽象层，提供了ThreadPoolExecutor和ProcessPoolExecutor两个类，以便使用线程池/进程池并发地执行任务。

## map与submit方法

map方法很简单，map的结果和入参顺序是对应的。

future模式更强大，用as_completed顺序是不定的。

import httpx from parsel import Selector from concurrent.futures import ThreadPoolExecutor, as_completed urls = [f"https://news.cnblogs.com/n/page/{page}" for page in range(1, 10 + 1)] def craw(url): r = httpx.get(url) return r.text def parse(html): selector = Selector(html) title = selector.css(".content h2.news_entry a::text")[0].get() return title with ThreadPoolExecutor() as pool: htmls = pool.map(craw, urls) htmls = list(zip(urls, htmls)) for url, html in htmls: print(url, len(html)) print("craw over") with ThreadPoolExecutor() as pool: futures = {} for url, html in htmls: future = pool.submit(parse, html) futures[future] = url for future in as_completed(futures): url = futures[future] print(url, future.result()) print("parse over")

## Web服务多线程加速

import flask import json import time from concurrent.futures import ThreadPoolExecutor

app = flask.Flask(**name**)
pool = ThreadPoolExecutor()

def read_file():
time.sleep(0.1)
return "file rusult"

def read_db():
time.sleep(0.2)
return "db rusult"

def read_api():
time.sleep(0.1)
return "api rusult"

@app.route("/")
def index():
result_file = pool.submit(read_file)
result_db = pool.submit(read_db)
result_api = pool.submit(read_api)
return json.dumps(
{
"result_file": result_file.result(),
"result_db": result_db.result(),
"result_api": result_api.result(),
}
)

if **name** == "**main**":
app.run()

## Web服务多进程加速

from flask import Flask import json import math from concurrent.futures import ProcessPoolExecutor

app = Flask(**name**)

def is_prime(n):
if n < 2:
return False
if n == 2:
return True
if n % 2 == 0:
return False

    sqrt_n = int(math.floor(math.sqrt(n)))
    for i in range(3, sqrt_n, 2):
        if n % i == 0:
            return False
    
    return True
    

@app.route("/is-prime/<numbers>")
def api_is_prime(numbers: str):
number_list = [int(x) for x in numbers.split(",")]
results = process_pool.map(is_prime, number_list)
return json.dumps(dict(zip(number_list, results)))

if **name** == "**main**":
process_pool = ProcessPoolExecutor()
app.run()


Python并发编程标准库concurrent.futures模块

## 读者阁

是一个读者杂志免费在线阅读和下载网站，提供《读者》PDF版电子杂志免费在线阅读、下载，而且网站还在不断更新关于读者杂志的信息，直接打开网站即可，无需注册登录，用爱发电，读者杂志通过AList网盘提供分享。

## 读者

《读者》杂志创刊于1981年3月，是读者出版集团主办的一份综合类文摘杂志，月发行量达1000万册，居亚洲第一，世界综合类期刊第三位。

创刊30余年，《读者》始终坚持“博采中外、荟萃精华、启迪思想、开阔眼界”的办刊宗旨和“高雅、清新、隽永”的办刊风格，发掘人性中的真善美，体现人文关怀，在海内外亿万读者中产生了深远的影响，具有很高知名度和美誉度，被誉为“中国人的心灵读本”、“中国期刊第一品牌”。

## 网站地址

读者阁：[https://duzhege.cn/](https://duzhege.cn/)


读者阁-在线阅读故事会、读者等彩色PDF杂志更新快

## RPC协议

Remote Procedure Call Protocol，远程过程调用协议，IPC是进程间通信，RPC是远程进程通信。

## 服务端和客户端编码实现

服务端：

    package main
    import (
    "fmt"
    "net"
    "net/rpc"
    )
    // 定义类对象
    type World struct {
    }
    // 绑定类方法
    func (this *World) SayHello(name string, resp *string) error {
    *resp = name + " 你好！"
    return nil
    }
    func main() {
    // 1. 注册RPC服务，绑定对象方法
    err := rpc.RegisterName("hello", new(World))
    if err != nil {
    fmt.Println("注册RPC服务失败:", err)
    return
    }
    // 2. 创建RPC服务器，监听端口
    listen, err := net.Listen("tcp", "127.0.0.1:8080")
    if err != nil {
    fmt.Println("net.Listen err:", err)
    }
    defer listen.Close()
    fmt.Println("开始监听...")
    // 3. 建立连接
    conn, err := listen.Accept()
    if err != nil {
    fmt.Println("Accept err:", err)
    }
    defer conn.Close()
    fmt.Println("连接成功...")
    // 4. 绑定服务
    rpc.ServeConn(conn)
    }

客户端：

    package main
    import (
    "fmt"
    "net/rpc"
    )
    func main() {
    // 1. 用RPC连接服务器
    conn, err := rpc.Dial("tcp", "127.0.0.1:8080")
    if err != nil {
    fmt.Println("Dial err:", err)
    return
    }
    defer conn.Close()
    // 2. 调用远程函数
    var reply string
    err = conn.Call("hello.SayHello", "张三", &reply)
    if err != nil {
    fmt.Println("Call err:", err)
    return
    }
    fmt.Println("Reply:", reply)
    }

## JSON版RPC

修改服务端代码：`jsonrpc.ServeConn(conn)`

修改客户端代码：`conn, err := jsonrpc.Dial("tcp", "127.0.0.1:8080")`


Go微服务

## IP地址

在IP地址中，全0代表网络地址，全1代表广播地址，这两个特殊用途IP地址，不可作为主机地址使用。

为了科学使用IP地址，减少浪费，将IP地址根据使用数量级划分为：

- A类：1.0.0.1~126.255.255.254，有126个网络，即共有2^7-2个网络号，每个网络最多有2^24-2个主机地址。127开头的地址可以说是A类的保留地址，用于本地软件环回测试
- B类：128.0.0.1~191.255.255.254
- C类：192.0.0.1~223.255.255.254
- D类：224.0.0.0~239.255.255.255
- E类：240.0.0.1~255.255.255.254，科研用
- 常见为ABC类，DE类不常见

       0 1     7  8     15  16     23  24      31
    A: 0 网络地址 主机地址--------------------(24)
    B: 1 0 网络地址---(14)  主机地址----------(16)
    C: 1 1 0 网络地址------------(21)  主机地址(8)
    D: 1 1 1 0 组播、路由器修改---------------(28)
    E: 1 1 1 1 试验用地址---------------------(28)

私有IP地址范围：

- A类：10.0.0.0~10.255.255.255，子网掩码255.0.0.0
- B类：172.16.0.0~172.31.255.255，子网掩码255.255.0.0
- C类：192.168.0.0~192.168.255.255，子网掩码255.255.255.0

同一个网段的IP地址，物理线路接通就可以直接相互通信，不同网段的i地址，即便是物理线路接通，也不可以直接通信，需要路由器才能相互通信（路由器能够帮我们转发给对应网段的主机）。

### 子网掩码

单纯的IP地址（分为网络和主机部分）只是标识了IP地址的种类，是无法辨识一个IP所处的子网的。子网掩码用来区分网络号和主机号，不能单独存在，必须结合IP地址一起使用。

子网掩码在形式上等同于IP地址，其网络部分全为1（二进制），主机部分全为0（二进制），例如子网掩码：255.255.255.0（另一种写法：IP地址/24，即24个1）。

知道子网掩码，就能判断任意两个IP地址是否处在同一个子网络了。方法是将两个IP地址与子网掩码分别进行二进制与运算，然后比较结果是否相同，如果是，表明它们在同一个子网络中，否则就不是。


网络基础知识

Go语言自带一个轻量级测试框架testing和go test命令来实现单元测试（T类型）和性能测试（B类型）。

## 单元测试

### 表格驱动测试

main.go

    package main
    import (
    "math"
    )
    func triangle(a, b int) int {
    c := int(math.Sqrt(float64(aa + bb)))
    return c
    }
    func main() {
    a, b := 3, 4
    c := triangle(a, b)
    println(c)
    }

main_test.go

    package main
    import "testing"
    func TestTriangle(t *testing.T) {
    tests := []struct{ a, b, c int }{
    {3, 4, 5},
    {5, 12, 13},
    {8, 15, 17},
    {12, 35, 37},
    {30000, 40000, 50000},
    }
    for _, tt := range tests {
    if actual := triangle(tt.a, tt.b); actual != tt.c {
    t.Errorf("triangle(%d, %d): "+
    "got %d; expected %d",
    tt.a, tt.b, actual, tt.c)
    }
    }
    }

## 性能测试


Go测试

这里是 aboss.top 的自留地。写了十几年野路子代码，攒了些摸爬滚打的经验，做成系列课程慢慢讲；也留了一小块地方，记记代码之外的胡思乱想。