Golang on Winsome I Write

Docker 搭建 Redis Cluster 集群

Fri, 01 Nov 2024 18:40:15 +0800

本文仅介绍 Redis Cluster 模式，也是官方推荐的模式。

为了保证高可用性，Redis 要求 Cluster 模式至少需要3个主节点，而每个主节点至少要配备一个从属节点，因此我们至少需要6个节点才能搭建起来一个Redis 的 Cluster 集群。

例子中都写到了同一个服务器，实际中可以拆开放到多个服务器，只需要把相应的内容分开就好。

前期准备

拉取 redis 镜像

docker pull redis

创建 Docker 容器网络 主要是用于redis-cluster能于外界进行网络通信，一般常用桥接模式。

docker network create redis-cluster-net

编写配置文件 创建 Redis 宿主机配置文件

# 创建文件夹，7000 是将要设置的端口号，所以先用这个命名
sudo mkdir -p /data/redis7000/conf
# 创建配置文件
cd /data/redis7000/conf
sudo nano redis-cluster.conf

配置内容如下：

Mysql 主从复制读写分离 nginx 负载均衡

Fri, 25 Oct 2024 18:36:33 +0800

记录一篇流水账，关于这些配置。

场景概述：

服务器 A：将作为主服务器，Nginx 运行在 8080 端口。
服务器 B：将作为从服务器，Nginx 运行在 80 端口。
负载均衡目标：Nginx 实现两台服务器的流量均衡，将请求分发到两台服务器上。但写请求永远发送到主节点，读请求可以发往主或从节点。

MySQL 主从复制配置

1.1 主服务器 A（Master）的 MySQL 配置：

修改 MySQL 配置文件 /etc/mysql/mysql.conf.d/mysqld.cnf：

cd 进入该文件夹，然后 sudo nano mysqld.cnf
下面的配置如果原文件没有就添加进去
ctl + o 保存，ctl + x 退出

[mysqld]
server-id = 1                   # 唯一的服务器ID，主从服务器ID不能相同
log_bin = /var/log/mysql/mysql-bin.log  # 启用二进制日志
binlog_format = row             # 使用行格式日志
bind-address    = 0.0.0.0       # 允许所有网络接口
port            = 3306          # 端口 默认3306，可以改为别的

重启 MySQL 服务：

sudo systemctl restart mysql

创建复制用户： mysql -u root -p 进入mysql

CREATE USER 'replicator'@'%' IDENTIFIED BY 'password';  -- 创建复制用户
GRANT REPLICATION SLAVE ON *.* TO 'replicator'@'%';     -- 赋予复制权限
FLUSH PRIVILEGES;                                    -- 刷新权限

获取主服务器的二进制日志信息：

SHOW MASTER STATUS;

记录下 File 和 Position，在从服务器配置时需要使用。

Go 语言中局部变量的堆栈

Wed, 16 Oct 2024 18:27:39 +0800

在 Go 语言中，局部变量通常分配在栈上，栈内存用于存储局部变量和函数调用信息。当局部变量的生命周期超出了函数的作用范围，或当局部变量被传递给其他函数且可能被持久化时，Go 的编译器会将其转移到堆上，这种机制称为“逃逸分析”。

1）逃逸分析

在 Go 语言中，逃逸分析是一种编译时优化技术，用于确定变量的生命周期及其存储位置（栈或堆）。通过逃逸分析，Go 编译器可以决定哪些变量应该分配在栈上，哪些应该分配在堆上。同时，编译器能优化内存使用，提高程序的性能。

2）栈分配

局部变量：通常情况下，局部变量在函数调用期间分配在栈上。栈分配的变量在函数返回时会自动释放，因此其生命周期仅限于函数的执行期间。
栈的优势：栈分配通常比堆分配更高效，因为栈的内存管理相对简单，变量的分配和释放操作速度更快。 3）堆分配
逃逸变量：如果局部变量的生命周期超出了其所在的函数作用域（例如：它被返回或被引用到其他地方），则该变量会“逃逸”到堆上。堆内存需要显式的垃圾回收来管理，这样变量在函数返回后仍然可以被访问。
堆的优势：虽然堆分配比栈分配开销大，但它允许变量在函数调用结束后继续存在。

4）如何逃逸分析

静态分析：编译器在编译过程中通过静态分析确定变量的生命周期。它会检查变量是否在函数返回后仍然被引用，或者是否存储在全局变量或其他数据结构中，这些都会影响变量是否需要分配在堆上。
逃逸分析的例子：

返回值：如果你从函数中返回一个局部变量（如切片或结构体），这个变量会被分配到堆上，因为它的生命周期超出了函数调用的范围。

闭包：如果一个局部变量被闭包引用，那么这个变量也会逃逸到堆上，因为闭包可能在函数调用结束后继续存在。

代码示例：

package main

import "fmt"

func main() {
    // 1. 不会逃逸到堆
    a := 10
    fmt.Println(a)

    // 2. 逃逸到堆
    b := newSlice() // newSlice 返回一个切片，该切片的底层数组可能需要在堆上分配
    fmt.Println(b)
}

func newSlice() []int {
    s := make([]int, 0) // s 是一个局部变量
    s = append(s, 1)
    return s // s 的底层数组会逃逸到堆上，因为切片在函数返回后仍然被引用
}

总结

Go 语言中 defer 的变量快照

Wed, 16 Oct 2024 17:41:32 +0800

在 Go 语言中，defer 的变量快照是指在 defer 语句定义时所捕获的变量的状态。但有些情况下，defer 语句中的变量快照可能会失效，导致不如预期那样行为，如下：

1）匿名函数闭包：当 defer 语句中使用的匿名函数捕获了外部变量时。如果变量的值在 defer 语句定义后发生变化，defer 执行时会使用变化后的值。

2）引用类型：当 defer 引用持有引用类型的变量（如指针、切片、映射、通道和函数）时，虽然引用本身的地址不会变，但指向的内容可能变化，这也会导致最终的结果和预期的快照结果不同。

在编程的时候，经常需要打开一些资源，比如数据库连接、文件、锁等，这些资源需要在用完之后释放掉，否则会造成内存泄漏。在 Go 中 defer 一般用于资源清理、文件关闭、解锁互斥量等操作。

1） defer常见用法

在函数开始时定义 defer ，确保退出时资源能够正确释放。

package main

import (
    "fmt"
    "os"
)

func main() {
    file, err := os.Open("example.txt")
    if err != nil {
        fmt.Println("Error opening file:", err)
        return
    }
    defer file.Close()

    // 处理文件的逻辑
}

2）闭包的defer变量

package main

import "fmt"

func main() {
    x := 0
    defer func() { fmt.Println("deferred x:", x) }() // 这里捕获的是x的引用
    x = 1
    fmt.Println("Normal x:", x)
}

输出结果：