## FMHY

应该是互联网上最大最全的免费资源集散地，致力于汇聚网络上最丰富的免费资源，聚合影视、软件、教育资料等全领域内容，形成跨平台开源生态。平台采用树状导航体系，涵盖广告拦截配置、隐私保护方案、AI技术解析等21个垂直模块，为全球用户提供无门槛资源获取路径，提供多种下载和流媒体服务。

网页导航分为“广告拦截/隐私”、“人工智能”、“流媒体”、“听歌/播客”、“游戏/模拟”、“阅读”、“下载”、“Torrenting”、“教育”、“Android/iOS”、“Linux/macOS”、“非英语”和“杂项”共12大板块，每个板块下又细分相关子目录，方便用户快速定位。站点内置搜索功能，可按关键词检索备份文件、Glossary术语表以及生态系统相关文章。

在“系统工具”和“文件工具”两大分类中，用户能找到用于管理下载、加密隐私、社交媒体辅助、文本和多媒体处理的各类开源工具。社区活跃于Discord，不仅可以获取最新资源发布信息，还能参与内容维护与备份。通过“Contribute”入口，任何人都能上传或更新自身收集的文件，一同维护这座互联网最大免费资源库。

内容实在是太多了，感兴趣的自己到官网去慢慢看吧，真是太多了。。。

## 网站地址

FMHY：[https://fmhy.net/](https://fmhy.net/)

GitHub：[https://github.com/fmhy/edit](https://github.com/fmhy/edit)

另一个网址：[https://fmhy.pages.dev/](https://fmhy.pages.dev/)


FMHY-互联网上最全免费资源集散地

goroutine（go程）的概念类似于线程，但goroutine是由Go运行时（runtime）调度和管理的。Go程序会智能地将goroutine中的任务合理地分配给每个CPU。

go程占用的系统资源远远小于线程，一个go程大约需要4K-5K的内存资源，一个程序可以启动大量的go程。

## 协程

在Go中，协程（Coroutine）被称为goroutine，是单线程下的并发，又称微线程。 package main

import (
"fmt"
"time"
)

func test() {
for i := 0; i < 10; i++ {
fmt.Println(i)
time.Sleep(time.Second)
}
}

func main() {
go test() // 开启一个协程

for i := 100; i < 110; i++ {
fmt.Println(i)
time.Sleep(time.Second)
}
}

### 主死从随

如果主线程退出，协程即使没有执行完毕，也会退出。 func test() { for i := 0; i < 1000; i++ { fmt.Println(i) time.Sleep(time.Second) } }

func main() {
go test() // 开启一个协程

for i := 1000; i < 1010; i++ {
fmt.Println(i)
time.Sleep(time.Second)
}
}

WaitGroup用于等待一组线程结束。父线程调用Add方法来设定应等待的线程数量，每个被等待线程在结束时调用Done方法。同时，
主线程里可以调用Wait方法阻塞至所有线程结束，使得主线程在子协程结束后再自动结束。var wg sync.WaitGroup // 只定义无需赋值 func main() { // wg.Add(5) // 如果知道协程数量，可以直接设置计数器 for i := 1; i <= 5; i++ { wg.Add(1) // 协程开始，计数器加1 go func(n int) { defer wg.Done() // 协程结束，计数器减1 fmt.Println(n) }(i) } wg.Wait() // 主线程一直在阻塞，等待所有协程结束，直到wg计数器为0 }

### 互斥锁

多个协程操作同一数据，可能会导致不可预测的结果或者程序错误。

Mutex为互斥锁，Lock()加锁，Unlock()解锁，加锁后不能再次对其进行加锁，直到对其解锁后才能再次加锁，适用于读写不确定场景，即读写次数没有明显的区别。所以说，其性能、效率相对来说比较低。

var wg sync.WaitGroup var lock sync.Mutex var count int func add() { defer wg.Done() for i := 0; i < 100000; i++ { lock.Lock() // 加锁 count++ lock.Unlock() // 解锁 } } func sub() { defer wg.Done() for i := 0; i < 100000; i++ { lock.Lock() // 加锁 count-- lock.Unlock() // 解锁 } } func main() { wg.Add(2) go add() go sub() wg.Wait() println(count) // 0 }

### 读写锁

RWMutex是一个读写锁，其经常用于读次数远远多于写次数的场景。在读的时候，数据之间不产生影响，写和读之间才会产生影响。 var wg sync.WaitGroup var lock sync.RWMutex

func read() {
defer wg.Done()
lock.RLock()
println("read start")
time.Sleep(time.Second)
println("read stop")
lock.RUnlock()
}

func write() {
defer wg.Done()
lock.Lock()
println("write start")
time.Sleep(time.Second * 2)
println("write stop")
lock.Unlock()
}

func main() {
wg.Add(7)
for i := 0; i < 5; i++ {
go read()
}
go write()
go write()

wg.Wait()
}

### 原子操作

加锁操作性能开销大，原子操作性能由于加锁操作。 package main

import (
"fmt"
"sync"
"sync/atomic"
"time"
)

var x int64
var l sync.Mutex
var wg sync.WaitGroup

func mutexAdd() {
l.Lock()
x++
l.Unlock()
wg.Done()
}

func atomicAdd() {
atomic.AddInt64(&x, 1)
wg.Done()
}

func main() {
start := time.Now()
for i := 0; i < 1000000; i++ {
wg.Add(1)
// go mutexAdd() // 加锁版add函数
go atomicAdd() // 原子操作版add函数
}
wg.Wait()

end := time.Now()
fmt.Println(x)
fmt.Println(end.Sub(start))
}

### 提前退出go程

func main() { go func() { func() { println("子go程内部函数") // return // 退出当前函数 // os.Exit(-1) // 退出整个程序 runtime.Goexit() // 退出当前go程 }()

    println("子go程退出")
    

}()

println("主go程")
time.Sleep(time.Second)
println("主go程退出")
}

### runtime包

runtime.Gosched()让出CPU时间片，重新等待安排任务： func main() { go func(s string) { for i := 0; i < 3; i++ { fmt.Println(s) } }("world")

for i := 0; i < 3; i++ {
runtime.Gosched() // 切一下，再次分配任务
fmt.Println("hello")
}
}

runtime.GOMAXPROCS()：
Go运行时的调度器使用GOMAXPROCS参数来确定需要使用多少个OS线程来同时执行Go代码，默认值是机器上的CPU核心数，通过runtime.GOMAXPROCS()函数可设置当前程序并发时占用的CPU逻辑核心数。

Go 1.5版本之前，默认使用的是单核心执行。Go 1.5版本之后，默认使用全部的CPU逻辑核心数，可以通过将任务分配到不同的CPU逻辑核心上实现并行的效果。

## 管道

管道（channel）本质是一个数据结构-队列。数据是先进先出的，多协程访问时，不需要加锁，channel本身就是线程安全的。管道是有类型的，一个string管道只能存放string类型数据。

WaitGroup、Mutex、Cond是传统同步机制，可以使用管道来等待goroutine结束。

func main() { // 定义一个 int 类型的管道 var intChan chan int intChan = make(chan int, 3) // 初始化管道，容量为 3 intChan <- 1                // 向管道中写入数据 intChan <- 2 close(intChan) // 管道关闭后，不能再写入数据，但仍然可以读取数据 n1 := <-intChan // 从管道中读取数据 n2 := <-intChan println(n1, n2) }

默认情况下，管道是双向的，即可读可写。若想让管道只写：`var intChan chan<- int`，只读：`var intChan <-chan int`

func producer(out chan<- int) { for i := 0; i < 10; i++ { out <- i println("生产", i) } } func consumer(in <-chan int) { for i := range in { println("消费", i) } } func main() { numChan := make(chan int, 5) go producer(numChan) // 双向管道可以赋值给同类型单向管道，反之不行 go consumer(numChan) time.Sleep(time.Second * 2) }

### 管道遍历

func main() { var intChan chan int intChan = make(chan int, 100) for i := 0; i < 100; i++ { intChan <- i }

// 遍历前要关闭管道，否则会出现死锁（for range会一直等待）
close(intChan)
for v := range intChan {
println("value:", v)
}
}

### select

解决多个管道的选择问题，也可以叫做多路复用，可以从多个管道中随机公平地选择一个来执行。case后面必须进行的是io操作，不能是等值，随机去选择一个io操作。防止select被阻塞住，加入default。 func main() { intChan := make(chan int, 1) go func() { time.Sleep(time.Second * 10) intChan <- 10 }()

strChan := make(chan string, 1)
go func() {
time.Sleep(time.Second * 15)
strChan <- "hello"
}()

select {
case v := <-intChan:
println("int value:", v)
case v := <-strChan:
println("string value:", v)
default:
println("no value received")
}
}

### 无缓冲管道

使用无缓冲通道进行通信将导致发送和接收的goroutine同步化。因此，无缓冲通道也被称为同步通道。 func recv(c chan int) { ret := <-c // 接收数据 fmt.Println("recv:", ret) }

func main() {
ch := make(chan int)
go recv(ch) // 启用goroutine从管道接收数据
ch <- 100   // 向管道发送数据
fmt.Println("main: send 100 to channel")
}

### 有缓冲管道

只要管道容量大于零，那么该管道就是有缓冲管道，管道容量表示管道中能存放元素的数量。

### 管道总结

- 当管道写满了，写阻塞
- 当缓冲区读完了，读阻塞
- 从nil管道读取、写入数据，都会阻塞，不会崩溃
- 从一个已经close的管道读取数据，返回零值，不会崩溃
- 向一个已经close的管道写数据，会崩溃
- 关闭一个已经close的管道，会崩溃
- 读写次数，一定要对等


Go语言并发编程

## duck typing

“像鸭子走路，像鸭子叫，长得像鸭子，那么就是鸭子!”duck typing描述事物的外部行为而非内部结构。

严格说Go属于结构化类型系统，类似duck typing。

鸭子类型：在多个类中实现同一个方法，那么这些类可以看成同一个类型。

## 接口定义

接口由**使用者**定义，接口实现是隐式的（只要实现接口里的方法）。 // 接口定义 type SayHello interface { sayHello() // 声明但没有具体实现方法 }

// 中国人
type Chinese struct {
}

// 接口实现
func (c Chinese) sayHello() {
fmt.Println("你好，世界！")
}

// 专门用来各国人打招呼，接收具备SayHello接口能力的变量
func greet(s SayHello) {
s.sayHello()
}

func main() {
c := Chinese{}
greet(c) // 你好，世界！
}

接口本身不能创建实例，但可以指向一个实现了该接口的自定义类型变量（接口类型变量）：var s SayHello = c s.sayHello() // 你好，世界！

接口变量包含实现者的类型和值。

一个接口的方法，不一定需要由一个类型完全实现，可以通过在类型中嵌入其他类型或者结构体来实现。

## 接口继承

接口继承直接写接口名就可以，但要实现继承接口的所有方法： type AInterface interface { a() }

type BInterface interface {
AInterface
b()
}

type Chinese struct {
}

func (c Chinese) a() {
fmt.Println("a")
}

func (c Chinese) b() {
fmt.Println("b")
}

func main() {
c := Chinese{}
var b BInterface = c
b.a() // a
}

## 空接口

是指没有定义任何方法的接口，因此任何类型都实现了空接口。空接口类型变量可以存储任意类型的变量。

空接口应用：

- 空接口作为函数参数，实现可以接收任意类型的函数参数
- 空接口作为map值，实现可以保存任意值的字典

类型断言，其语法格式为`x.(T)`，该语法返回两个参数，第一个是x转化为T类型后的变量，第二个是一个布尔值，若为true则表示断言成功，为false则表示断言失败。 func main() { var x interface{} // 定义一个空接口x x = "Hello World!" v, ok := x.(string) if ok { fmt.Println(v) } else { fmt.Println("类型断言失败") } }

## type switch

是Go语言中一种特殊的switch语句`switch x.(type)`，它比较的是类型而不是具体的值。它判断某个接口变量的类型，然后根据具体类型再做相应处理。

其中，x必须是一个接口类型变量，且所有case语句后面跟的类型必须都实现了接口x。

switch x.(type) { case Type1: doSomeThingWithType1() case Type2: doSomeThingWithType2() default: doSomeDefaultThing() }


Go语言面向接口

## 中括号

中括号有两种使用方法：
用于比较操作符：比较两个值大小或者判断两个值是否相等。例如：

- `-eq`：判断两个值是否相等（equal to），例如`[ $a -eq $b ]`
- `-ne`：判断两个值是否不相等（not equal to），例如`[ $a -ne $b ]`
- `-lt`：判断左边的值是否小于右边的值（less than），例如`[ $a -lt $b ]`
- `-gt`：判断左边的值是否大于右边的值（greater than），例如`[ $a -gt $b ]`
- `-le`：判断左边的值是否小于等于右边的值（less than or equal to），例如`[ $a -le $b ]`
- `-ge`：判断左边的值是否大于等于右边的值（greater than or equal to），例如`[ $a -ge $b ]`

用于测试表达式：测试某个表达式是否成立。例如：

- `-f`：判断某个文件是否存在并且是一个常规文件（regular file），例如`[ -f file.txt ]`
- `-d`：判断某个文件是否存在并且是一个目录（directory），例如`[ -d dir ]`
- `-z`：判断某个字符串是否为空（zero length），例如`[ -z "$str" ]`
- `-n`：判断某个字符串是否非空（not zero length），例如`[ -n "$str" ]`
- `-e`：判断某个文件或目录是否存在（exist），例如`[ -e file.txt ]`

在多数Linux发行版中，测试表达式可以用中括号[]或者test命令实现，例如：`test -f file.txt`等价于`[ -f file.txt ]`。

需要注意，中括号中的空格很重要，空格缺少会导致语法错误。另外，在使用中括号[]时，要注意变量用双引号括起来，避免空值引起语法错误。

## if语句

    #!/bin/bash
    if [ -f file.txt ]; then
    echo "file.txt exists."
    elif [ -d dir ]; then
    echo "dir exists."
    else
    echo "file.txt and dir not found."
    fi

## 循环语句

### for循环

    #!/bin/bash
    for i in 1 2 3 4 5; do
    echo "The value of i is: $i"
    done

### while循环

    #!/bin/bash
    j=0
    while [ $j -lt 5 ]; do
    echo "The value of j is: $j"
    j=$((j + 1))
    done

注意：在Shell中，变量类型默认为字符串，所以在进行算术操作时需要使用$((...))算术扩展运算符来确保正确的结果。$(...)运算符会将结果直接返回，例如：

- $((j+1))，如果j是5，结果就会返回6（注意，使用这个运算符的时候，括号里面不能有空格）
- $(echo "hello world")，会将"hello world"打印，然后再将"hello world"字符串返回


Shell编程中的控制语句

在Linux中，有三种类型的Shell变量，包括：

- 环境变量
- 本地变量
- 特殊变量

变量名命名规范：

- 环境变量一般全部大写，单词和单词之间采用下划线分割：JAVA_HOME
- 本地变量一般小写

## 环境变量

环境变量是在Shell会话外设置的，可由多个脚本和进程共享。在Linux中，环境变量没有固定值，而是在需要时通过脚本或命令进行设置或更新，系统环境变量一般在/etc/profile文件中设置。

查看当前所有环境变量：`printenv`或`env`。

设置一个新环境变量，使用export命令，例如：`export MY_VAR="Hello World"`。要使用环境变量，必须在变量名称前加上$符号，例如：`echo $MY_VAR`。

## 本地变量

本地变量是一种临时变量，在Shell会话中设置和使用。与环境变量不同，本地变量仅限于当前Shell会话，不会被其他脚本或命令使用。

设置本地变量可以使用“=”号操作符，例如：`MY_VAR="Hello World"`。类似于环境变量，在使用本地变量时，变量名称前必须加上$符号。例如：`echo $MY_VAR`。

## 特殊变量

特殊变量是在Shell中预定义的变量名称，具有特殊含义。这些变量与当前Shell会话有关，可用于许多不同用途，包括文件和目录操作、命令历史记录和处理脚本参数等等。以下是常见的一些特殊变量：

- $0：当前脚本文件名
- $1, $2...：脚本参数列表中第1个、第2个参数等等
- $#：脚本参数数量
- $*：所有脚本参数列表（将所有参数作为一个字符串："a b c d"）
- $@: 所有脚本参数列表（将每个参数作为一个独立字符串："a" "b" "c" "d"）
- $$: 当前脚本进程ID号
- $?: 上一个命令退出状态，一个数值，0表示成功，其他值表示失败


Linux中的Shell变量

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