2022年世界杯正在举行中，有的小伙伴提问如何在哔哩哔哩上查看世界杯，小编下面就带来了具体的介绍，你可以来看一下哦。       哔哩哔哩如何查看2022世界杯？哔哩哔哩查看2022世界杯教程       1、首先点击上方的搜索，选择【世界杯】。       2、然后点击上方的【赛事专题】。       3、最后在此专题上，你就可以看到一系列的热门内容了。       以上就是哔哩哔哩如何看2022世界杯的全部内容，更多精彩教程请关注下载之家! ......查看全文

      很多小伙伴在使用五岳阅卷的时候，想知道怎么查分，下面小编就为大家分享五岳阅卷查分教程，感兴趣的小伙伴不要错过哦!       五岳阅卷怎么查分？五岳阅卷查分教程       1、首先点击选择立即登录。       2、然后验证身份切换所属城市区域学校名称。       3、接着在学校页面，点击选择搜索考试分类。       4、最后输入学生考生信息，提交查询相关学校考试分数。       以上这篇文章就是五岳阅卷查分教程，更多教程尽在下载之家。 ......查看全文

      使用话本小说的时候，很多小伙伴不知道怎么关闭个性化推荐，下面小编就给大家带来话本小说关闭个性化推荐教程，有需要的小伙伴不要错过哦。       话本小说怎么关闭个性化推荐？话本小说关闭个性化推荐教程       第一步：进入【话本小说】APP首页，点击右下角【我的】，详见下图所示;       第二步：点击【设置】，详见下图所示;       第三步：点击【个性化推荐】后的蓝色按钮，待显示灰色即可关闭，详见下图所示。       以上这篇文章就是话本小说关闭个性化推荐教程，更多教程尽在下载之家。 ......查看全文

      今天小编为大家带来了话本小说在线联系客服教程，想知道怎么做的小伙伴来看看接下来的这篇文章吧，相信一定会帮到你们的。       话本小说怎么在线联系客服？话本小说在线联系客服教程       1、首先进入话本小说，点击下面我的。       2、然后点击下面的设置选项。       3、点击客服咨询选项。       4、接着点击下面的联系客服。       5、最后输入要咨询的内容，进行发送即可。       以上这篇文章就是话本小说在线联系客服教程，更多教程尽在下载之家。 ......查看全文

      有的小伙伴会问小编话本小说怎么查看作家收入排行榜，下面小编就为大家详细的介绍一下，想知道的话就来看看吧，相信一定会帮到你们的。       话本小说怎么查看作家收入排行榜？话本小说查看作家收入排行榜教程       1、首先进入手机的话本小说，点击下面我的选项。       2、然后点击下面的网编专区选项。       3、接着点击下面的查看收入排行榜。       4、最后就可查看到作家的收入排行榜。       谢谢大家的观看，更多精彩教程请关注下载之家! ......查看全文

概述 Golang 是一个跨平台的新生编程语言. 今天小白就带大家一起携手走进 Golang 的世界. Go 运算符 运算符(operator) 可以帮助我们在程序中执行数学或逻辑运算. Go 语言内置的运算符有: 算术运算符 关系运算符 逻辑运算符 位运算符 赋值运算符 算术运算符 运算符 描述 + 相加 - 相减 * 相乘 / 相除 % 取余 ++ 自增 – 自减 例子: package main import "fmt" func main() { // 定义变量 var a = 10 var b = 2 // 调试输出 fmt.Println(a + b) // 相加 fmt.Println(a - b) // 相减 fmt.Println(a * b) // 相乘 fmt.Println(a / b) // 相除 fmt.Println(a % b) // 取余 // 自加 & 自减 a++ b-- fmt.Println(a) // 自加 fmt.Println(b) // 自减 } 输出结果: 12 8 20 5 0 11 1 关系运算符 运算符 描述 == 检查两个值是否相等. 如果相等返回 True, 否则返回 False != 检查两个值是否不相等, 如果不相等返回 True, 否则返回 False > 大于 < 小于 >= 大于等于 <= 小于等于 例子: package main import "fmt" func main() { // 定义变量 var a = 10 var b = 2 // 调试输出 fmt.Println(a == b) fmt.Println(a != b) fmt.Println(a > b) fmt.Println(a < b) fmt.Println(a >= b) fmt.Println(a <= b) } 输出结果: false true true false true false 逻辑运算符 运算符 描述 & 与运算符 | 或运算符 ^ 异或运算符 << 左移运算符, 左移 n 位就是乘以 2 的 n 次方. 低位补零. >> 右移运算符, 右移 n 位就是除以 2 的 n 次方. 低位舍弃. 例子: package main import "fmt" func main() { // 定义变量 var a = 60 // 00111100 var b = 13 // 00001101 // 调试输出 fmt.Println(a & b) // 00001100: 12 fmt.Println(a | b) // 00111101: 61 fmt.Println(a ^ b) // 00110001: 49 fmt.Println(a << 1) // 01111000: 120 fmt.Println(a >> 1) // 00011110: 30 } 输出结果: 12 61 49 120 30 赋值运算符 运算符 描述 = 简单的赋值 += 相加后再赋值 -= 相减后再赋值 /= 相除后再赋值 %= 取余后再赋值 例子: package main import "fmt" func main() { // 定义变量 var a = 10 var b = 2 var c int // 赋值运算符 c = a fmt.Println(c) b += 2 fmt.Println(b) b -= 2 fmt.Println(b) a *= 2 fmt.Println(a) a /= 2 fmt.Println(a) a %= 3 fmt.Println(a) } 输出结果: 10 4 2 20 10 1 到此这篇关于手把手带你走进Go语言之运算符解析的文章就介绍到这了,更多相关Golang 运算符内容请搜索M135模板网以前的文章或继续浏览下面的相关文章希望大家以后多多支持M135模板网！ ......查看全文

概述 Golang 是一个跨平台的新生编程语言. 今天小白就带大家一起携手走进 Golang 的世界. 常量 常量 (Constant) 是指程序在执行过程中不会改变的固定值. 常量可以是任何基本数据类型. 如整数常量, 浮点常量, 字符常量, 枚举常量. 常量一般都会被编译器视为常规变量, 只是常量的值不能再定义之后修改. 格式 1: const 变量名 = 值 格式 2: const 变量名 变量类型 例子: package main import "fmt" func main() { // 方法一 const num1 = 1 // 方法二 const num2 int = 2 // 调试输出 fmt.Println(num1, num2) } 输出结果: 1 2 例 2: package main import "fmt" func main() { // 字符串常量 const str1 = "我是小白呀" // 整数常量 const int1 = 1 // 浮点常量 const float1 = 1.2 // 布尔类型常量 const boolean1 = true // 调试输出 fmt.Println(str1) fmt.Println(int1) fmt.Println(float1) fmt.Println(boolean1) } 输出结果: 我是小白呀 1 1.2 true 常量计算 常量可以使用len(), cap(), unsafe.Sizeof()函数计算表达式的值. 常量表达式中函数必须是内置函数, 否则编译不过. 例子: package main import "fmt" import "unsafe" // 定义常量 const ( str = "iamlittlewhite" num = 1 ) func main() { // 计算字符串长度 fmt.Println(len(str)) // 计算整数占用字节 fmt.Println(unsafe.Sizeof(num)) } 输出结果: 14 8 iota iota 是 Go 语言的常量计数器, 只能在常量的表达式中使用. iota 在 const 关键字出现时将被重置为 0, const 中每新增一行常量, iota 就会计数一次. iota 可以帮助我们统计常量同一行代码被访问了多少次. 例子: package main import "fmt" func main() { // 定义iota const ( a = iota b = iota c = iota d = iota ) // 调试输出 fmt.Println(a, b, c, d) fmt.Println(a, d) } 输出结果: 0 1 2 3 0 3 到此这篇关于手把手带你走进Go语言之常量解析的文章就介绍到这了,更多相关Golang 常量内容请搜索M135模板网以前的文章或继续浏览下面的相关文章希望大家以后多多支持M135模板网！ ......查看全文

概述 Golang 是一个跨平台的新生编程语言. 今天小白就带大家一起携手走进 Golang 的世界. Go 语法基础 Go程序可以由多个标记组成: 关键字 标识符 常量 字符串 符号 关键字 Go 语言有 25 个关键字: 关键字 作用 var & const 变量和常量的声明 package & import 导入 func 用于定义函数和方法 return 用于函数返回 defer someCode 在函数退出前执行 go 用于并行 select 用于选择不同类型的通讯 interface 用于定义接口 struct 用于定义抽象数据类型 break, case, continue, for, falthrough, else, if. switch, goto, defult 流程控制 chan 用于 channel 通讯 type 用于声明自定义类型 map 用于声明 map 类型数据 range 用于读取 slice, map, channel 数据 标识符 标识符用来命名变量, 类型等程序实体. 一个标识符实际上就是一个或者多个字母 (A-Z 和 a-z), 数字 (0-9), 下划线 (_) 组成的序列. 但是第一个字符必须是字母或者下换线而不是数字. Go 不允许在表示符中使用标点符号, 例如: “@”, “$”, 和 “%”. 并且 Go 是一种区分大小写的编程语言. 数据类型 类型 说明 布尔类型 (Boolean) true / false 整数类型 (Integer) 1, 2, 3, 4, … 浮点类型 (Float) 1.1, 2.2, 3.3, 4.4, … 字符串类型 (String) 字符串类型表示字符串值的合集. 字符串是不可变类型, 一旦创建后, 就不可能改变字符串的内容. 派生类型 包括指针可型, 数组类型, 结构类型, 联合类型, 函数类型, 切片类型, 接口类型 例子: package main import "fmt" func main() { // 定义字符串变量 var str = "我是小白呀" // 定义整数型变量 var integer = 8 // 定义浮点型变量 var float = 1.2 // 定义布尔类型变量 var bool = true fmt.Println("string: ", str, "\ninteger: ", integer, "\nfloat: ", float, "\nboolean: ", bool) } 输出结果: string: 我是小白呀 integer: 8 float: 1.2 boolean: true 变量声明 格式 1, 指定变量类型, 声明后再进行赋值: var 变量名 变量类型 变量名 = 值 格式 2, 根据值自行判定变量类型: var 变量名 = 值 格式 3, 省略 var. (注意: “:=” 左侧的变量不应该是已经声明过的, 否则会导致编译错误): v_name := value 例子: package main import "fmt" func main() { // 方法一 var num1 int // 声明变量 num1 = 1 // 赋值 fmt.Println(num1) // 调试输出 // 方法二 var num2 = 2 // 自行判定变量类型 fmt.Println(num2) // 调试输出 // 方法三 num3 := 3 // 省略var fmt.Println(num3) // 调试输出 } 输出结果: 1 2 3 多变量声明 格式: var 变量名称1, 变量名称2, 变量名称3 = 值1, 值2, 值2 例子: package main import "fmt" func main() { // 多变量声明 var num4, num5, num6 = 1, 2, 3 fmt.Println(num4, num5, num6) // 调试输出 } 输出结果: 1 2 3 值类型和引用类型 所有像 int, float, bool 和 string 这些基本类型都属于值类型. 使用这些类型的变量直接指向存在内存中的值. 当使用等号 “=” 将一个变量赋值给另一个变量时 (num2 = num1). 实际上在内存中将 num1 的值进行了拷贝. 例子: package main import "fmt" func main() { // 定义变量 var num1 = 2 var num2 = num1 // 调试输出值和地址 fmt.Println(num1, &num1) fmt.Println(num2, &num2) } 输出结果: 2 0xc0000ac058 2 0xc0000ac070 到此这篇关于手把手带你走进Go语言之语法基础解析的文章就介绍到这了,更多相关Golang 语法基础内容请搜索M135模板网以前的文章或继续浏览下面的相关文章希望大家以后多多支持M135模板网！ ......查看全文

枚举，是一种重要的数据类型，由一组键值对组成，通常用来在编程语言中充当常量的标识符。在主流行编程语言如 c、 java 等，都有原生支持。在 go 中，大家却找不到 enum 或者其它直接用来声明枚举类型的关键字。从熟悉其它编程语言的开发者转用 go 编程，刚开始会比较难接受这种情况。其实，如果你看到如何在 go 中表示枚举类型时，可能会感受到 go 语言设计者对简洁性、问题考虑的深度，是一般资浅工程师无法比拟的。 其实，在 go 语言设计者的眼里，enum 本质是常量，为什么要多余一个关键字呢？在 go 只是没有 enum 关键字而已，其表现枚举的形式，与其它语言别无太大区别。下面来看看如果在 go 中表示枚举。 学习、使用一门语言，是学习、理解语言本身的设计哲学，同时也会感受到设计者的性格特点。 基础工作  为了下面讲解方便，这里使用 go modules 的方式先建立一个简单工程。 ~/Projects/go/examples mkdir enum ~/Projects/go/examples cd enum ~/Projects/go/examples/enum go mod init enum go: creating new go.mod: module enum ~/Projects/go/examples/enum touch enum.go const + iota 以 启动、运行中、停止 这三个状态为例，使用 const 关键来声明一系列的常量值。在 enum.go 中写上以下内容： package main import "fmt" const ( Running int = iota Pending Stopped ) func main() { fmt.Println("State running: ", Running) fmt.Println("State pending: ", Pending) fmt.Println("State Stoped: ", Stopped) } 保存并运行，可以得到以下结果， ~/Projects/go/examples/enum go run enum.go State running: 0 State pending: 1 State Stoped: 2 在说明发生了什么之前，我们先看来一件东西，iota。相比于 c、java，go 中提供了一个常量计数器，iota，它使用在声明常量时为常量连续赋值。 比如这个例子， const ( a int = iota // a = 0 b int = iota // b = 1 c int = iota // c = 2 ) const d int = iota // d = 0 在一个 const 声明块中，iota 的初始值为 0，每声明一个变量，自增 1。以上的代码可以简化成： const ( a int = iota // a = 0 b // b = 1 c // c = 2 ) const d int = iota // d = 0 设想一下，如果此时有 50 或者 100 个常量数，在 c 和 java 语言中写出来会是什么情况。 关于 iota，有更多的具体的技巧（例如跳数），详细请看官方定义 iota。 通过使用 const 来定义一连串的常量，并借助 iota 常量计数器，来快速的为数值类型的常量连续赋值，非常方便。虽然没有了 enum 关键字，在这种情况下发现，是多余的，枚举本质上就是常量的组合。 当然，你可以使用以下方式，来更接近其它语言的 enum， // enum.go ... type State int const ( Running State = iota Pending Stopped ) ... 把一组常量值，使用一个类型别名包裹起来，是不是更像其它语言中的 enum {} 定义了呢？ 你还可以将上面的例子改为： // enum.go ... type State int const ( Running State = iota Pending Stopped ) func (s State) String() string { switch s { case Running: return "Running" case Pending: return "Pending" case Stopped: return "Stopped" default: return "Unknown" } } ... 为定义的枚举类型加上 String 函数，运行结果如下： ~/Projects/go/examples/enum go run enum.go State running: Running State pending: Pending State Stoped: Stopped 是不是很魔幻，思路一下又开阔一些，长见识了。把实际的值与打印字符分开，一般语言设计者不会想到。看到这里，有没有这种的感觉，go 语言的设计者并不是偷懒，而是为了可以偷懒想了很多、做了很多。 到此这篇关于Golang表示枚举类型的详细讲解的文章就介绍到这了,更多相关Golang 枚举类型内容请搜索M135模板网以前的文章或继续浏览下面的相关文章希望大家以后多多支持M135模板网！ ......查看全文

前言 Go语言很强大并且现在也十分流行 — 许多项目都是用Go语言来实现的，如Kubernetes。Go语言的一个有趣特性是它的多值返回功能提供了一种与其他编程语言不同的错误处理方法。 Go将error视为具有预定义类型的值，其本身是一个interface类型。然而，编写多层体系结构应用程序并使用api暴露应用的特性需要有包含更多上下文信息的error处理，而不仅仅是一个值。 本文我们将探讨如何封装Go的error类型以在应用程序中带来更大的价值。 用户自定义类型 我们将重写的Go里自带的error类型，首先从一个自定义的错误类型开始，该错误类型将在程序中识别为error类型。因此，我们引入一个封装了Go的 error的新自定义Error类型。 type GoError struct { error } 上下文数据 当我们在Go中说error是一个值时，它是字符串值 - 任何实现了Error() string函数的类型都可以视作error类型。将字符串值视为error会使跨层的error处理复杂化，因此处理error字符串信息并不是正确的方法。所以我们可以把字符串和错误码解耦： type GoError struct { error Code string } 现在对error的处理将基于错误码Code字段而不是字符串。让我们通过上下文数据进一步对错误字符串进行解耦，在上下文数据中可以使用i18n包进行国际化。 type GoError struct { error Code string Data map[string]interface{} } Data包含用于构造错误字符串的上下文数据。错误字符串可以通过数据模板化: //i18N def "InvalidParamValue": "Invalid parameter value '{{.actual}}', expected '{{.expected}}' for '{{.name}}'" 在i18N定义文件中，错误码Code将会映射到使用Data构建的模板化的错误字符串中。 原因(Causes) error可能发生在任何一层，有必要为每一层提供处理error的选项，并在不丢失原始error值的情况下进一步使用附加的上下文信息对error进行包装。GoError结构体可以用Causes进一步封装，用来保存整个错误堆栈。 type GoError struct { error Code string Data map[string]interface{} Causes []error } 如果必须保存多个error数据，则causes是一个数组类型，并将其设置为基本error类型，以便在程序中包含该原因的第三方错误。 组件(Component) 标记层组件将有助于识别error发生在哪一层，并且可以避免不必要的error wrap。例如，如果service类型的error组件发生在服务层，则可能不需要wrap error。检查组件信息将有助于防止暴露给用户不应该通知的error，比如数据库error： type GoError struct { error Code string Data map[string]interface{} Causes []error Component ErrComponent } type ErrComponent string const ( ErrService ErrComponent = "service" ErrRepo ErrComponent = "repository" ErrLib ErrComponent = "library" ) 响应类型(ResponseType) 添加一个错误响应类型这样可以支持error分类，以便于了解什么错误类型。例如，可以根据响应类型(如NotFound)对error进行分类，像DbRecordNotFound、ResourceNotFound、UserNotFound等等的error都可以归类为 NotFound error。这在多层应用程序开发过程中非常有用，而且是可选的封装： type GoError struct { error Code string Data map[string]interface{} Causes []error Component ErrComponent ResponseType ResponseErrType } type ResponseErrType string const ( BadRequest ResponseErrType = "BadRequest" Forbidden ResponseErrType = "Forbidden" NotFound ResponseErrType = "NotFound" AlreadyExists ResponseErrType = "AlreadyExists" ) 重试 在少数情况下，出现error会进行重试。retry字段可以通过设置Retryable标记来决定是否要进行error重试: type GoError struct { error Code string Message string Data map[string]interface{} Causes []error Component ErrComponent ResponseType ResponseErrType Retryable bool } GoError 接口 通过定义一个带有GoError实现的显式error接口，可以简化error检查: package goerr type Error interface { error Code() string Message() string Cause() error Causes() []error Data() map[string]interface{} String() string ResponseErrType() ResponseErrType SetResponseType(r ResponseErrType) Error Component() ErrComponent SetComponent(c ErrComponent) Error Retryable() bool SetRetryable() Error } 抽象error 有了上述的封装方式，更重要的是对error进行抽象，将这些封装保存在同一地方，并提供error函数的可重用性 func ResourceNotFound(id, kind string, cause error) GoError { data := map[string]interface{}{"kind": kind, "id": id} return GoError{ Code: "ResourceNotFound", Data: data, Causes: []error{cause}, Component: ErrService, ResponseType: NotFound, Retryable: false, } } 这个error函数抽象了ResourceNotFound这个error，开发者可以使用这个函数来返回error对象而不是每次创建一个新的对象： //UserService user, err := u.repo.FindUser(ctx, userId) if err != nil { if err.ResponseType == NotFound { return ResourceNotFound(userUid, "User", err) } return err } 结论 我们演示了如何使用添加上下文数据的自定义Go的error类型，从而使得error在多层应用程序中更有意义。你可以在这里[1]看到完整的代码实现和定义。 到此这篇关于Go应用中优雅处理Error的文章就介绍到这了,更多相关Go优雅处理Error内容请搜索M135模板网以前的文章或继续浏览下面的相关文章希望大家以后多多支持M135模板网！ 参考资料 [1] 这里: https://gist.github.com/prathabk/744367cbfc70435c56956f650612d64b ......查看全文

etcd是近几年比较火热的一个开源的、分布式的键值对数据存储系统，提供共享配置、服务的注册和发现，本文主要介绍etcd的安装和使用。 etcdetcd介绍 etcd是使用Go语言开发的一个开源的、高可用的分布式key-value存储系统，可以用于配置共享和服务的注册和发现。 类似项目有zookeeper和consul。 etcd具有以下特点： 完全复制：集群中的每个节点都可以使用完整的存档 高可用性：Etcd可用于避免硬件的单点故障或网络问题 一致性：每次读取都会返回跨多主机的最新写入 简单：包括一个定义良好、面向用户的API（gRPC） 安全：实现了带有可选的客户端证书身份验证的自动化TLS 快速：每秒10000次写入的基准速度 可靠：使用Raft算法实现了强一致、高可用的服务存储目录 etcd应用场景 服务发现 服务发现要解决的也是分布式系统中最常见的问题之一，即在同一个分布式集群中的进程或服务，要如何才能找到对方并建立连接。本质上来说，服务发现就是想要了解集群中是否有进程在监听 udp 或 tcp 端口，并且通过名字就可以查找和连接。 配置中心 将一些配置信息放到 etcd 上进行集中管理。 这类场景的使用方式通常是这样：应用在启动的时候主动从 etcd 获取一次配置信息，同时，在 etcd 节点上注册一个 Watcher 并等待，以后每次配置有更新的时候，etcd 都会实时通知订阅者，以此达到获取最新配置信息的目的。 分布式锁 因为 etcd 使用 Raft 算法保持了数据的强一致性，某次操作存储到集群中的值必然是全局一致的，所以很容易实现分布式锁。锁服务有两种使用方式，一是保持独占，二是控制时序。 保持独占即所有获取锁的用户最终只有一个可以得到。etcd 为此提供了一套实现分布式锁原子操作 CAS（CompareAndSwap）的 API。通过设置prevExist值，可以保证在多个节点同时去创建某个目录时，只有一个成功。而创建成功的用户就可以认为是获得了锁。 控制时序，即所有想要获得锁的用户都会被安排执行，但是获得锁的顺序也是全局唯一的，同时决定了执行顺序。etcd 为此也提供了一套 API（自动创建有序键），对一个目录建值时指定为POST动作，这样 etcd 会自动在目录下生成一个当前最大的值为键，存储这个新的值（客户端编号）。同时还可以使用 API 按顺序列出所有当前目录下的键值。此时这些键的值就是客户端的时序，而这些键中存储的值可以是代表客户端的编号。 为什么用 etcd 而不用ZooKeeper？ etcd 实现的这些功能，ZooKeeper都能实现。那么为什么要用 etcd 而非直接使用ZooKeeper呢？ 为什么不选择ZooKeeper？ 部署维护复杂，其使用的Paxos强一致性算法复杂难懂。官方只提供了Java和C两种语言的接口。 使用Java编写引入大量的依赖。运维人员维护起来比较麻烦。 最近几年发展缓慢，不如etcd和consul等后起之秀。 为什么选择etcd？ 简单。使用 Go 语言编写部署简单；支持HTTP/JSON API,使用简单；使用 Raft 算法保证强一致性让用户易于理解。 etcd 默认数据一更新就进行持久化。 etcd 支持 SSL 客户端安全认证。 最后，etcd 作为一个年轻的项目，正在高速迭代和开发中，这既是一个优点，也是一个缺点。优点是它的未来具有无限的可能性，缺点是无法得到大项目长时间使用的检验。然而，目前 CoreOS、Kubernetes和CloudFoundry等知名项目均在生产环境中使用了etcd，所以总的来说，etcd值得你去尝试。 etcd集群 etcd 作为一个高可用键值存储系统，天生就是为集群化而设计的。由于 Raft 算法在做决策时需要多数节点的投票，所以 etcd 一般部署集群推荐奇数个节点，推荐的数量为 3、5 或者 7 个节点构成一个集群。 搭建一个3节点集群示例： 在每个etcd节点指定集群成员，为了区分不同的集群最好同时配置一个独一无二的token。 下面是提前定义好的集群信息，其中n1、n2和n3表示3个不同的etcd节点。 TOKEN=token-01 CLUSTER_STATE=new CLUSTER=n1=http://10.240.0.17:2380,n2=http://10.240.0.18:2380,n3=http://10.240.0.19:2380 在n1这台机器上执行以下命令来启动etcd： etcd --data-dir=data.etcd --name n1 \ --initial-advertise-peer-urls http://10.240.0.17:2380 --listen-peer-urls http://10.240.0.17:2380 \ --advertise-client-urls http://10.240.0.17:2379 --listen-client-urls http://10.240.0.17:2379 \ --initial-cluster ${CLUSTER} \ --initial-cluster-state ${CLUSTER_STATE} --initial-cluster-token ${TOKEN} 在n2这台机器上执行以下命令启动etcd： etcd --data-dir=data.etcd --name n2 \ --initial-advertise-peer-urls http://10.240.0.18:2380 --listen-peer-urls http://10.240.0.18:2380 \ --advertise-client-urls http://10.240.0.18:2379 --listen-client-urls http://10.240.0.18:2379 \ --initial-cluster ${CLUSTER} \ --initial-cluster-state ${CLUSTER_STATE} --initial-cluster-token ${TOKEN} 在n3这台机器上执行以下命令启动etcd： etcd --data-dir=data.etcd --name n3 \ --initial-advertise-peer-urls http://10.240.0.19:2380 --listen-peer-urls http://10.240.0.19:2380 \ --advertise-client-urls http://10.240.0.19:2379 --listen-client-urls http://10.240.0.19:2379 \ --initial-cluster ${CLUSTER} \ --initial-cluster-state ${CLUSTER_STATE} --initial-cluster-token ${TOKEN} etcd 官网提供了一个可以公网访问的 etcd 存储地址。你可以通过如下命令得到 etcd 服务的目录，并把它作为-discovery参数使用。 curl https://discovery.etcd.io/new?size=3 https://discovery.etcd.io/a81b5818e67a6ea83e9d4daea5ecbc92 # grab this token TOKEN=token-01 CLUSTER_STATE=new DISCOVERY=https://discovery.etcd.io/a81b5818e67a6ea83e9d4daea5ecbc92 etcd --data-dir=data.etcd --name n1 \ --initial-advertise-peer-urls http://10.240.0.17:2380 --listen-peer-urls http://10.240.0.17:2380 \ --advertise-client-urls http://10.240.0.17:2379 --listen-client-urls http://10.240.0.17:2379 \ --discovery ${DISCOVERY} \ --initial-cluster-state ${CLUSTER_STATE} --initial-cluster-token ${TOKEN} etcd --data-dir=data.etcd --name n2 \ --initial-advertise-peer-urls http://10.240.0.18:2380 --listen-peer-urls http://10.240.0.18:2380 \ --advertise-client-urls http://10.240.0.18:2379 --listen-client-urls http://10.240.0.18:2379 \ --discovery ${DISCOVERY} \ --initial-cluster-state ${CLUSTER_STATE} --initial-cluster-token ${TOKEN} etcd --data-dir=data.etcd --name n3 \ --initial-advertise-peer-urls http://10.240.0.19:2380 --listen-peer-urls http://10.240.0.19:2380 \ --advertise-client-urls http://10.240.0.19:2379 --listen-client-urls http:/10.240.0.19:2379 \ --discovery ${DISCOVERY} \ --initial-cluster-state ${CLUSTER_STATE} --initial-cluster-token ${TOKEN} 到此etcd集群就搭建起来了，可以使用etcdctl来连接etcd。 export ETCDCTL_API=3 HOST_1=10.240.0.17 HOST_2=10.240.0.18 HOST_3=10.240.0.19 ENDPOINTS=$HOST_1:2379,$HOST_2:2379,$HOST_3:2379 etcdctl --endpoints=$ENDPOINTS member lis Go语言操作etcd 这里使用官方的etcd/clientv3包来连接etcd并进行相关操作。 安装 go get go.etcd.io/etcd/clientv3 put和get操作 put命令用来设置键值对数据，get命令用来根据key获取值。 package main import ( "context" "fmt" "time" "go.etcd.io/etcd/clientv3" ) // etcd client put/get demo // use etcd/clientv3 func main() { cli, err := clientv3.New(clientv3.Config{ Endpoints: []string{"127.0.0.1:2379"}, DialTimeout: 5 * time.Second, }) if err != nil { // handle error! fmt.Printf("connect to etcd failed, err:%v\n", err) return } fmt.Println("connect to etcd success") defer cli.Close() // put ctx, cancel := context.WithTimeout(context.Background(), time.Second) _, err = cli.Put(ctx, "q1mi", "dsb") cancel() if err != nil { fmt.Printf("put to etcd failed, err:%v\n", err) return } // get ctx, cancel = context.WithTimeout(context.Background(), time.Second) resp, err := cli.Get(ctx, "q1mi") cancel() if err != nil { fmt.Printf("get from etcd failed, err:%v\n", err) return } for _, ev := range resp.Kvs { fmt.Printf("%s:%s\n", ev.Key, ev.Value) } } watch操作 watch用来获取未来更改的通知。 package main import ( "context" "fmt" "time" "go.etcd.io/etcd/clientv3" ) // watch demo func main() { cli, err := clientv3.New(clientv3.Config{ Endpoints: []string{"127.0.0.1:2379"}, DialTimeout: 5 * time.Second, }) if err != nil { fmt.Printf("connect to etcd failed, err:%v\n", err) return } fmt.Println("connect to etcd success") defer cli.Close() // watch key:q1mi change rch := cli.Watch(context.Background(), "q1mi") // <-chan WatchResponse for wresp := range rch { for _, ev := range wresp.Events { fmt.Printf("Type: %s Key:%s Value:%s\n", ev.Type, ev.Kv.Key, ev.Kv.Value) } } } 将上面的代码保存编译执行，此时程序就会等待etcd中q1mi这个key的变化。 例如：我们打开终端执行以下命令修改、删除、设置q1mi这个key。 etcd> etcdctl.exe --endpoints=http://127.0.0.1:2379 put q1mi "dsb2" OK etcd> etcdctl.exe --endpoints=http://127.0.0.1:2379 del q1mi 1 etcd> etcdctl.exe --endpoints=http://127.0.0.1:2379 put q1mi "dsb3" OK 上面的程序都能收到如下通知。 watch>watch.exe connect to etcd success Type: PUT Key:q1mi Value:dsb2 Type: DELETE Key:q1mi Value: Type: PUT Key:q1mi Value:dsb3 lease租约 package main import ( "fmt" "time" ) // etcd lease import ( "context" "log" "go.etcd.io/etcd/clientv3" ) func main() { cli, err := clientv3.New(clientv3.Config{ Endpoints: []string{"127.0.0.1:2379"}, DialTimeout: time.Second * 5, }) if err != nil { log.Fatal(err) } fmt.Println("connect to etcd success.") defer cli.Close() // 创建一个5秒的租约 resp, err := cli.Grant(context.TODO(), 5) if err != nil { log.Fatal(err) } // 5秒钟之后, /nazha/ 这个key就会被移除 _, err = cli.Put(context.TODO(), "/nazha/", "dsb", clientv3.WithLease(resp.ID)) if err != nil { log.Fatal(err) } } keepAlive package main import ( "context" "fmt" "log" "time" "go.etcd.io/etcd/clientv3" ) // etcd keepAlive func main() { cli, err := clientv3.New(clientv3.Config{ Endpoints: []string{"127.0.0.1:2379"}, DialTimeout: time.Second * 5, }) if err != nil { log.Fatal(err) } fmt.Println("connect to etcd success.") defer cli.Close() resp, err := cli.Grant(context.TODO(), 5) if err != nil { log.Fatal(err) } _, err = cli.Put(context.TODO(), "/nazha/", "dsb", clientv3.WithLease(resp.ID)) if err != nil { log.Fatal(err) } // the key 'foo' will be kept forever ch, kaerr := cli.KeepAlive(context.TODO(), resp.ID) if kaerr != nil { log.Fatal(kaerr) } for { ka := <-ch fmt.Println("ttl:", ka.TTL) } } 基于etcd实现分布式锁 go.etcd.io/etcd/clientv3/concurrency在etcd之上实现并发操作，如分布式锁、屏障和选举。 导入该包： import "go.etcd.io/etcd/clientv3/concurrency" 基于etcd实现的分布式锁示例： cli, err := clientv3.New(clientv3.Config{Endpoints: endpoints}) if err != nil { log.Fatal(err) } defer cli.Close() // 创建两个单独的会话用来演示锁竞争 s1, err := concurrency.NewSession(cli) if err != nil { log.Fatal(err) } defer s1.Close() m1 := concurrency.NewMutex(s1, "/my-lock/") s2, err := concurrency.NewSession(cli) if err != nil { log.Fatal(err) } defer s2.Close() m2 := concurrency.NewMutex(s2, "/my-lock/") // 会话s1获取锁 if err := m1.Lock(context.TODO()); err != nil { log.Fatal(err) } fmt.Println("acquired lock for s1") m2Locked := make(chan struct{}) go func() { defer close(m2Locked) // 等待直到会话s1释放了/my-lock/的锁 if err := m2.Lock(context.TODO()); err != nil { log.Fatal(err) } }() if err := m1.Unlock(context.TODO()); err != nil { log.Fatal(err) } fmt.Println("released lock for s1") <-m2Locked fmt.Println("acquired lock for s2") 输出： acquired lock for s1 released lock for s1 acquired lock for s2 查看文档了解更多 其他操作 其他操作请查看etcd/clientv3官方文档。 参考链接： https://etcd.io/docs/v3.3.12/demo/ https://www.infoq.cn/article/etcd-interpretation-application-scenario-implement-principle/ 代码改变世界，脚踏实地，python、Golang。 到此这篇关于Go操作etcd的实现示例的文章就介绍到这了,更多相关Go操作etcd内容请搜索M135模板网以前的文章或继续浏览下面的相关文章希望大家以后多多支持M135模板网！ ......查看全文

sync.Cond 可以用来干什么？ Golang 的 sync 包中的 Cond 实现了一种条件变量，可以使用多个 Reader 等待公共资源。 每个 Cond 都会关联一个 Lock ,当修改条件或者调用 Wait 方法，必须加锁，保护 Condition。 有点类似 Java 中的 Wait 和 NotifyAll。 sync.Cond 条件变量是用来协调想要共享资源的那些 goroutine, 当共享资源的状态发生变化时，可以被用来通知被互斥锁阻塞的 gorountine。 与 Sync.Mutex 的区别 sync.Cond 基于互斥锁，和互斥锁有什么区别？ sync.Mutex 通常用来保护临界区和共享资源，条件变量 sync.Cond 用来协调想要访问的共享资源。 sync.Cond 使用场景 有一个协程正在接收数据，其他协程必须等待这个协程接收完数据，才能读取到正确的数据。 上述情形下，如果单纯的使用 channel 或者互斥锁，只能有一个协程可以等待，并读取到数据，没办法通知其他协程也读取数据。 这个时候怎么办？ 可以用一个全局变量标识第一个协程是否接收数据完毕，剩下的协程反复检查该变量的值，直到读取到数据。 也可创建多个 channel, 每个协程阻塞在一个 Channel 上，由接收数据的协程在数据接收完毕后，挨个通知。 然后 Go 中其实内置来一个 sync.Cond 来解决这个问题。 sync.Cond // Each Cond has an associated Locker L (often a *Mutex or *RWMutex), // which must be held when changing the condition and // when calling the Wait method. // // A Cond must not be copied after first use. type Cond struct { noCopy noCopy // L is held while observing or changing the condition L Locker notify notifyList checker copyChecker } 可以看到每个 Cond 都会关联一个 锁 L (互斥锁 Mutex, 或者读写锁 * RMMutex), 当修改条件或者使用 Wait 的时候必须要加锁。 sync.Cond 有哪些方法 NewCond 创建实例 func NewCond(l Locker) *Cond NewCond 创建实例需要关联一个锁。 具体实例： cadence := sync.NewCond(&sync.Mutex{}) Broadcast 广播唤醒所有 // Broadcast wakes all goroutines waiting on c. // // It is allowed but not required for the caller to hold c.L // during the call. func (c *Cond) Broadcast() Broadcast 唤醒所有等待条件变量 c 的 goroutine，无需锁保护。 具体实例： go func() { for range time.Tick(1 * time.Millisecond) { cadence.Broadcast() } }() Signal 唤醒一个协程 // Signal wakes one goroutine waiting on c, if there is any. // // It is allowed but not required for the caller to hold c.L // during the call. func (c *Cond) Signal() Signal 只唤醒任意1个等待条件变量 c 的 goroutine，无需锁保护。 有点类似 Java 中的 Notify Wait 等待 // Wait atomically unlocks c.L and suspends execution // of the calling goroutine. After later resuming execution, // Wait locks c.L before returning. Unlike in other systems, // Wait cannot return unless awoken by Broadcast or Signal. // // Because c.L is not locked when Wait first resumes, the caller // typically cannot assume that the condition is true when // Wait returns. Instead, the caller should Wait in a loop: // // c.L.Lock() // for !condition() { // c.Wait() // } // ... make use of condition ... // c.L.Unlock() // func (c *Cond) Wait() 调用 Wait 会自动释放锁 c.L，并挂起调用者所在的 goroutine，因此当前协程会阻塞在 Wait 方法调用的地方。如果其他协程调用了 Signal 或 Broadcast 唤醒了该协程，Wait 方法结束阻塞时，并重新给 c.L 加锁，并且继续执行 Wait 后面的代码 代码示例： c.L.Lock() for !condition() { c.Wait() } ... make use of condition ... c.L.Unlock() 代码示例 package sync import ( "log" "sync" "testing" "time" ) var done = false func read(name string, c *sync.Cond) { c.L.Lock() for !done { c.Wait() } log.Println(name, "starts reading") c.L.Unlock() } func write(name string, c *sync.Cond) { log.Println(name, "starts writing") time.Sleep(time.Second) c.L.Lock() done = true c.L.Unlock() log.Println(name, "wakes all") c.Broadcast() } func TestSyncCond(t *testing.T) { cond := sync.NewCond(&sync.Mutex{}) go read("reader1", cond) go read("reader2", cond) go read("reader3", cond) write("writer", cond) time.Sleep(time.Second * 3) } 运行结果 === RUN   TestSyncCond 2021/08/26 11:06:48 writer starts writing 2021/08/26 11:06:49 writer wakes all 2021/08/26 11:06:49 reader3 starts reading 2021/08/26 11:06:49 reader2 starts reading 2021/08/26 11:06:49 reader1 starts reading --- PASS: TestSyncCond (4.01s) PASS 到此这篇关于Go语言中sync.Cond使用详解的文章就介绍到这了,更多相关Go sync.Cond内容请搜索M135模板网以前的文章或继续浏览下面的相关文章希望大家以后多多支持M135模板网！ ......查看全文

         在使用VScode编译多个go文件多次遇到过一个问题：无法找到对应的函数。具体提示在好像是：在GOPATH和GOROOT路径中都没有找到该package或者该函数。但是实际上，这个函数所在的go文件就在我的工作空间。 这里简单记录下来。         举个很简单的例子：src目录下有个main.go文件， 引用了当前目录下myTools文件夹中的Add函数：  其中 main.go的实现如下： package main import ( "fmt" "myTools" ) func main() { sum := myTools.Add(1, 2) fmt.Println(sum) }  ️myTools目录下的add.go实现如下： package myTools func Add(a, b int) int { return a + b } 但是在编译时，提示找不到myTools或者Add函数之类的。我确认环境变量，包括GOPATH, GOROOT没有什么问题，但是依然提示类似错误。 我最初认为必须将自己写的这部分go文件放到go的安装路径下，这样虽然能解决问题，但是工程不太好管理呀；还会将自己的代码与源码混在一起，污染源码，于情于理都不合适。当时也查过相关资料，网络好几篇都说将这两个同时编译即可 go build main.go myTools/add.go 这个确实可以，但是在不同目录时无法编译。我也没有研究这个问题，但是感觉也不方便，如果需要挨个指定要编译的文件，那岂不是又要写一个类似makefile的文件吗？？？ 后来，一个偶然的机会，他可以了  我回想了下，刚才做过的操作： go mod init go mod tidy 之后，便可以通过直接编译main.go来运行程序了，不再需要指定编译哪些.go文件，非常的方便。如果有人也遇到类似的问题，可以这样试一下，希望能解决这样的问题。 特别说明：          我目前对Go语言正处于学习阶段，感觉遇到问题比较多的就是：环境配置问题。各种安装失败、编译出错，VScode无法追踪代码等等奇形怪状的问题，这里权当做记录了。同时希望对于后面遇到此类问题的同学，能够快速解决此类问题。 到此这篇关于VScode 中编译多个Go文件的文章就介绍到这了,更多相关VScode 编译Go文件内容请搜索M135模板网以前的文章或继续浏览下面的相关文章希望大家以后多多支持M135模板网！ ......查看全文

Slice（切片） 切片和数组类似，可以把它理解为动态数组。切片是基于数组实现的，它的底层就是一个数组。对数组任意分隔，就可以得到一个切片。现在我们通过一个例子来更好地理解它，同样还是基于前面的 array。 基于数组生成切片 下面代码中的 array[2:5] 就是获取一个切片的操作，它包含从数组 array 的索引 2 开始到索引 5 结束的元素： array:=[5]string{"a","b","c","d","e"} slice:=array[2:5] fmt.Println(slice) 注意：这里是包含索引 2，但是不包含索引 5 的元素，即在 : 右边的数字不会被包含。 //基于数组生成切片，包含索引start，但是不包含索引end slice:=array[start:end] 所以 array[2:5] 获取到的是 c、d、e 这三个元素，然后这三个元素作为一个切片赋值给变量 slice。 切片和数组一样，也可以通过索引定位元素。这里以新获取的 slice 切片为例，slice[0] 的值为 c，slice[1] 的值为 d。 有没有发现，在数组 array 中，元素 c 的索引其实是 2，但是对数组切片后，在新生成的切片 slice 中，它的索引是 0，这就是切片。虽然切片底层用的也是 array 数组，但是经过切片后，切片的索引范围改变了。 通过下图可以看出，切片是一个具备三个字段的数据结构，分别是指向数组的指针 data，长度 len 和容量 cap： 这里有一些小技巧，切片表达式 array[start:end] 中的 start 和 end 索引都是可以省略的，如果省略 start，那么 start 的值默认为 0，如果省略 end，那么 end 的默认值为数组的长度。如下面的示例： array[:4] 等价于 array[0:4]。 array[1:] 等价于 array[1:5]。 array[:] 等价于 array[0:5]。 切片修改 切片的值也可以被修改，这里也同时可以证明切片的底层是数组。 对切片相应的索引元素赋值就是修改，在下面的代码中，把切片 slice 索引 1 的值修改为 f，然后打印输出数组 array： slice:=array[2:5] slice[1] ="f" fmt.Println(array) 可以看到如下结果： [a b c f e] 数组对应的值已经被修改为 f，所以这也证明了基于数组的切片，使用的底层数组还是原来的数组，一旦修改切片的元素值，那么底层数组对应的值也会被修改。 切片声明 除了可以从一个数组得到切片外，还可以声明切片，比较简单的是使用 make 函数。 下面的代码是声明了一个元素类型为 string 的切片，长度是 4，make 函数还可以传入一个容量参数： slice1:=make([]string,4) 在下面的例子中，指定了新创建的切片 []string 容量为 8： slice1:=make([]string,4,8) 这里需要注意的是，切片的容量不能比切片的长度小。 切片的长度你已经知道了，就是切片内元素的个数。那么容量是什么呢？其实就是切片的空间。 上面的示例说明，Go 语言在内存上划分了一块容量为 8 的内容空间（容量为 8），但是只有 4 个内存空间才有元素（长度为 4），其他的内存空间处于空闲状态，当通过 append 函数往切片中追加元素的时候，会追加到空闲的内存上，当切片的长度要超过容量的时候，会进行扩容。 切片不仅可以通过 make 函数声明，也可以通过字面量的方式声明和初始化，如下所示： slice1:=[]string{"a","b","c","d","e"} fmt.Println(len(slice1),cap(slice1)) 可以注意到，切片和数组的字面量初始化方式，差别就是中括号 [] 里的长度。此外，通过字面量初始化的切片，长度和容量相同。 Append 我们可以通过内置的 append 函数对一个切片追加元素，返回新切片，如下面的代码所示： //追加一个元素 slice2:=append(slice1,"f") //多加多个元素 slice2:=append(slice1,"f","g") //追加另一个切片 slice2:=append(slice1,slice...) append 函数可以有以上三种操作，你可以根据自己的实际需求进行选择，append 会自动处理切片容量不足需要扩容的问题。 小技巧：在创建新切片的时候，最好要让新切片的长度和容量一样，这样在追加操作的时候就会生成新的底层数组，从而和原有数组分离，就不会因为共用底层数组导致修改内容的时候影响多个切片。 切片元素循环 切片的循环和数组一模一样，常用的也是 for range 方式，这里就不再进行举例，当作练习题留给你。 在 Go 语言开发中，切片是使用最多的，尤其是作为函数的参数时，相比数组，通常会优先选择切片，因为它高效，内存占用小。 到此这篇关于Go之集合slice的实现的文章就介绍到这了,更多相关Go 集合slice内容请搜索M135模板网以前的文章或继续浏览下面的相关文章希望大家以后多多支持M135模板网！ ......查看全文

什么是死锁，在Go的协程里面死锁通常就是永久阻塞了，你拿着我的东西，要我先给你然后再给我，我拿着你的东西又让你先给我，不然就不给你。我俩都这么想，这事就解决不了了。 第一种情形：无缓存能力的管道，自己写完自己读 先上代码： func main() { ch := make(chan int, 0) ​ ch <- 666 x := <- ch fmt.Println(x) } 我们可以看到这是一个没有缓存能力的管道，然后往里面写666，然后就去管道里面读。这样肯定会出现问题啊！一个无缓存能力的管道，没有人读，你也写不了，没有人写，你也读不了，这正是一种死锁！ fatal error: all goroutines are asleep - deadlock! 解决办法很简单，开辟两条协程，一条协程写，一条协程读。 第二种情形：协程来晚了 func main() { ch := make(chan int,0) ch <- 666 go func() { <- ch }() } 我们可以看到，这条协程开辟在将数字写入到管道之后，因为没有人读，管道就不能写，然后写入管道的操作就一直阻塞。这时候你就有疑惑了，不是开辟了一条协程在读吗？但是那条协程开辟在写入管道之后，如果不能写入管道，就开辟不了协程。 第三种情形：管道读写时，相互要求对方先读/写 如果相互要求对方先读/写，自己再读/写，就会造成死锁。 func main() { chHusband := make(chan int,0) chWife := make(chan int,0) ​ go func() { select { case <- chHusband: chWife<-888 } }() ​ select { case <- chWife: chHusband <- 888 } } 先来看看老婆协程，chWife只要能读出来，也就是老婆有钱，就给老公发个八百八十八的大红包。 再看看老公的协程，一看不得了，咋啦？老公也说只要他有钱就给老婆包个八百八十八的大红包。 两个人都说自己没钱，老公也给老婆发不了红包，老婆也给老公发不了红包，这就是死锁！ 第四种情形：读写锁相互阻塞，形成隐形死锁 先来看一看代码： func main() { var rmw09 sync.RWMutex ch := make(chan int,0) ​ go func() { rmw09.Lock() ch <- 123 rmw09.Unlock() }() ​ go func() { rmw09.RLock() x := <- ch fmt.Println("读到",x) rmw09.RUnlock() }() ​ for { runtime.GC() } } 这两条协程，如果第一条协程先抢到了只写锁，另一条协程就不能抢只读锁了，那么因为另外一条协程没有读，所以第一条协程就写不进。 如果第二条协程先抢到了只读锁，另一条协程就不能抢只写锁了，那么因为另外一条协程没有写，所以第二条协程就读不到。 到此这篇关于详解Golang并发操作中常见的死锁情形的文章就介绍到这了,更多相关Golang 并发死锁内容请搜索M135模板网以前的文章或继续浏览下面的相关文章希望大家以后多多支持M135模板网！ ......查看全文