二进制与 Go 的原子操做
二进制与 Go 的原子操做
前置阅读：html
二进制相关基础概念
有符号二进制整数有正数和负数。在 x86 处理器中，MSB 表示的是符号位：0 表示正数，1 表示负数。下图展现了 8 位的正数和负数：编程
概念总结：segmentfault
- 反码、补码是二进制的一种表现形式；
- 在计算机内全部数值底层都用补码表示，不管正负数（十进制）；
- 若是一串二进制值须要视为数值则须要将其视为补码；
- 反码是十进制转二进制计算的一个过程即对一个十进制取补码的过程，通常用在负数转换规则上；
- 反码能够经过二进制值按位取反获得（全部二进制位都取反）；
- 正数（十进制）的补码是其二进制自己，负数（十进制）的补码是十进制负数的绝对值求补码后取反码加一；
表示正数的补码能够直接转成十进制，表示负数的补码想要转回十进制步骤以下：安全
- 对表示负数的补码取反码加一获得负数的十进制绝对值补码；
- 再将负数的十进制绝对值补码转成十进制获得负数的十进制绝对值；
- 最后加上符号位；
- 不管是正数加正数（十进制加法）仍是正数/负数加负数（十进制减法）均可以用补码加补码表示；
- 一个值的正数的补码与其负数的补码相加等于 0；
反码
反码能够经过二进制值按位取反获得（全部二进制位都取反）
正数的反码示例：并发
| 十进制数值 | 补码 | 反码 |
|---|---|---|
| 0 | 0000 0000 | 1111 1111 |
| 1 | 0000 0001 | 1111 1110 |
| 2 | 0000 0010 | 1111 1101 |
| 3 | 0000 0011 | 1111 1100 |
| 4 | 0000 0100 | 1111 1011 |
负数的反码示例：函数
| 十进制数值 | 补码 | 反码 |
|---|---|---|
| -0 | 0000 0000 | 1111 1111 |
| -1 | 1111 1111 | 0000 0000 |
| -2 | 1111 1110 | 0000 0001 |
| -3 | 1111 1101 | 0000 0010 |
补码（十进制转二进制）
在计算机内全部数值底层都用补码表示，不管正负数（十进制）
| 十进制数值 | 补码 |
|---|---|
| 0 | 0000 0000 |
| 1 | 0000 0001 |
| 2 | 0000 0010 |
| 3 | 0000 0011 |
| -0 | 0000 0000 |
| -1 | 1111 1111 |
| -2 | 1111 1110 |
| -3 | 1111 1101 |
负数补码计算过程示例：ui
| 十进制数值 | 绝对值 | 绝对值补码 | 绝对值补码取反 | 绝对值补码取反加一 | 正确补码 | 十进制数值 |
|---|---|---|---|---|---|---|
| -0 | 0 | 0000 0000 | 1111 1111 | 1111 1111 + 1 ————— 1,0000 0000 |
0000 0000 | -0 |
| -1 | 1 | 0000 0001 | 1111 1110 | 1111 1110 + 1 ————— 1111 1111 |
1111 1111 | -1 |
| -2 | 2 | 0000 0010 | 1111 1101 | 1111 1101 + 1 ————— 1111 1110 |
1111 1110 | -2 |
| -3 | 3 | 0000 0011 | 1111 1100 | 1111 1100 + 1 ————— 1111 1101 |
1111 1101 | -3 |
| -4 | 4 | 0000 0100 | 1111 1011 | 1111 1011 + 1 ————— 1111 1100 |
1111 1100 | -4 |
| -5 | 5 | 0000 0101 | 1111 1010 | 1111 1010 + 1 ————— 1111 1011 |
1111 1011 | -5 |
补码（二进制转十进制）
表示正数的补码能够直接转成十进制，表示负数的补码想要转回十进制步骤以下：atom
- 对表示负数的补码取反码加一获得负数的十进制绝对值补码；
- 再将负数的十进制绝对值补码转成十进制获得负数的十进制绝对值；
- 最后加上符号位；
| MSB | 补码 | 十进制数值 |
|---|---|---|
| 0 | 0000 0000 | 0 |
| 0 | 0000 0001 | 1 |
| 0 | 0000 0010 | 2 |
| 0 | 0000 0011 | 3 |
| 0 | 0000 0100 | 4 |
| 0 | 0000 0101 | 5 |
| 1 | 1111 1111 | -1 |
| 1 | 1111 1110 | -2 |
| 1 | 1111 1101 | -3 |
| 1 | 1111 1100 | -4 |
| 1 | 1111 1011 | -5 |
负数转换示例：spa
| MSB | 补码 | 补码取反 | 补码取反加一 | 补码取反加一后所表明十进制值 | 符号 | 十进制结果 | 补码 |
|---|---|---|---|---|---|---|---|
| 1 | 1111 1111 | 0000 0000 | 0000 0001 | 1 | - | -1 | 1111 1111 |
| 1 | 1111 1110 | 0000 0001 | 0000 0010 | 2 | - | -2 | 1111 1110 |
| 1 | 1111 1101 | 0000 0010 | 0000 0011 | 3 | - | -3 | 1111 1101 |
| 1 | 1111 1100 | 0000 0011 | 0000 0100 | 4 | - | -4 | 1111 1100 |
| 1 | 1111 1011 | 0000 0100 | 0000 0101 | 5 | - | -5 | 1111 1011 |
补码相加
不管是正数加正数（十进制加法）仍是正数/负数加负数（十进制减法）均可以用补码加补码表示
正数加正数的补码计算过程示例：.net
| 表达式 | 补码相加 | 二进制结果 | 十进制结果 |
|---|---|---|---|
| 0+0 | 0000 0000 + 0000 0000 —————— 0000 0000 |
0000 0000 | 0 |
| 0+1 | 0000 0000 + 0000 0001 —————— 0000 0001 |
0000 0001 | 1 |
| 1+1 | 0000 0001 + 0000 0001 —————— 0000 0010 |
0000 0010 | 2 |
| 2+1 | 0000 0010 + 0000 0001 —————— 0000 0011 |
0000 0011 | 3 |
正数加负数的补码计算过程示例：
| 表达式 | 补码相加 | 二进制结果 | 十进制结果 |
|---|---|---|---|
| 0+(-0) | 0000 0000 + 0000 0000 —————— 0000 0000 |
0000 0000 | 0 |
| 0+(-1) | 0000 0000 + 1111 1111 —————— 1111 1111 |
1111 1111 | -1 |
| 1+(-1) | 0000 0001 + 1111 1111 —————— 1,0000 0000 |
0000 0000 | 0 |
| 1+(-2) | 0000 0001 + 1111 1110 —————— 1111 1111 |
1111 1111 | -1 |
| 2+(-2) | 0000 0010 + 1111 1110 —————— 1,0000 0000 |
0000 0000 | 0 |
| 2+(-1) | 0000 0010 + 1111 1111 —————— 1,0000 0001 |
0000 0001 | 1 |
负数加负数的补码计算过程示例：
| 表达式 | 补码相加 | 二进制结果 | 十进制结果 |
|---|---|---|---|
| (-0)+(-0) | 0000 0000 + 0000 0000 —————— 0000 0000 |
0000 0000 | 0 |
| (-1)+(-1) | 1111 1111 + 1111 1111 —————— 1,1111 1110 |
1111 1110 | -2 |
| (-1)+(-2) | 1111 1111 + 1111 1110 —————— 1,1111,1101 |
1111 1101 | -3 |
二进制、反码、补码
一样的一串二进制数字，便可以是反码也能够是补码，若是是补码则其能够经过上述规则转成对应的十进制数值，若是是反码则表明其为计算过程当中间值，若是想知道反码在十进制中所表示的数值，能够将其视为补码再经过上述规则转成十进制便可。
正数示例：
| 十进制数值 x | x 取补码 fn1(x)=a | x 取反码 fn2(x)=b | b 的十进制形式 y |
|---|---|---|---|
| 0 | 0000 0000 | 1111 1111 | -1 |
| 1 | 0000 0001 | 1111 1110 | -2 |
| 2 | 0000 0010 | 1111 1101 | -3 |
| 3 | 0000 0011 | 1111 1100 | -4 |
| 4 | 0000 0100 | 1111 1011 | -5 |
负数示例：
| 十进制数值 x | x 取补码 fn1(x)=a | x 取反码 fn2(x)=b | b 的十进制形式 y |
|---|---|---|---|
| -0 | 0000 0000 | 1111 1111 | -1 |
| -1 | 1111 1111 | 0000 0000 | 0 |
| -2 | 1111 1110 | 0000 0001 | 1 |
| -3 | 1111 1101 | 0000 0010 | 2 |
示例汇总：
| 十进制数值 x | x 取补码 fn1(x)=a | x 取反码 fn2(x)=b | b 的十进制形式 y | y + 1 | 十进制数值 x |
|---|---|---|---|---|---|
| 0 | 0000 0000 | 1111 1111 | -1 | 0 | 0 |
| 1 | 0000 0001 | 1111 1110 | -2 | -1 | 1 |
| 2 | 0000 0010 | 1111 1101 | -3 | -2 | 2 |
| 3 | 0000 0011 | 1111 1100 | -4 | -3 | 3 |
| -0 | 0000 0000 | 1111 1111 | -1 | 0 | -0 |
| -1 | 1111 1111 | 0000 0000 | 0 | 1 | -1 |
| -2 | 1111 1110 | 0000 0001 | 1 | 2 | -2 |
| -3 | 1111 1101 | 0000 0010 | 2 | 3 | -3 |
经过该表格示例能够得出如下两个规律：
规律 一
反码所表示的数值与原数值之间规律以下（y 表明反码以后的十进制值）：
- fn2(x) = -x-1
- fn2(x) + 1 = -x
- y = -x-1
- y +1 = -x
即若是想获得一个十进制正数值的负数形式（1 => -1）或则获得一个十进制负数值的正数形式能够经过对原值取反码加一获得：
| 十进制数值 x | 十进制取反 -x | 过程 |
|---|---|---|
| 0 | 0 | 取反码(0)+1 = -1+1 |
| 1 | -1 | 取反码(1)+1 = -2+1 |
| 2 | -2 | 取反码(2)+1 = -3+1 |
| 3 | -3 | 取反码(3)+1 = -4+1 |
| -1 | 1 | 取反码(-1)+1 = 0+1 |
| -2 | 2 | 取反码(-2)+1 = 1+1 |
| -3 | 3 | 取反码(-3)+1 = 2+1 |
规律 二
将示例汇总表格再进一步简化：
| 十进制数值 x | x 的反码十进制表示形式 y | 翻译 -1 | 翻译 -2 |
|---|---|---|---|
| 0 | -1 | 0 的反码是 -1 | -1 是 0 的反码 |
| 1 | -2 | 1 的反码是 -2 | -2 是 1 的反码 |
| 2 | -3 | 2 的反码是 -3 | -3 是 2 的反码 |
| 3 | -4 | 3 的反码是 -4 | -4 是 3 的反码 |
| -0 | -1 | -0 的反码是 -1 | -1 是 -0 的反码 |
| -1 | 0 | -1 的反码是 0 | 0 是 -1 的反码 |
| -2 | 1 | -2 的反码是 1 | 1 是 -2 的反码 |
| -3 | 2 | -3 的反码是 2 | 2 是 -3 的反码 |
能够看出在十进制格式下，原数值与反码的关系：
- 若是我须要 -1 我能够用 0 的反码代替；
- 若是我须要 -4 我能够用 3 的反码代替；
规律：
- x = |y| -1
- x + y = -1
Go 的表现
二进制的输出格式
在 Go 语言中，一个数值是正数或负数，不管是何种打印方式，输出的都会待上正负号：
fmt.Printf("1 的十进制 ： %v\n",1)
fmt.Printf("-1 的十进制 ： %v\n",-1)
fmt.Printf("-1 的二进制(简化版)： %v\n",strconv.FormatInt(-1,2))
fmt.Printf("1 的二进制 ： %064b\n",1) // 占 64 位宽，不足补 0
fmt.Printf("-1 的二进制 ： %064b\n",-1) // 占 64 位宽，不足补 0
fmt.Printf("4 的十进制 ： %v\n",4)
fmt.Printf("-4 的十进制 ： %v\n",-4)
fmt.Printf("-4 的二进制(简化版)： %v\n",strconv.FormatInt(-4,2))
fmt.Printf("4 的二进制 ： %064b\n",4) // 占 64 位宽，不足补 0
fmt.Printf("-4 的二进制 ： %064b\n",-4) // 占 64 位宽，不足补 0
// 输出
// 1 的十进制 ： 1
// -1 的十进制 ： -1
// -1 的二进制(简化版)： -1
// 1 的二进制 ： 0000000000000000000000000000000000000000000000000000000000000001
// -1 的二进制 ： -000000000000000000000000000000000000000000000000000000000000001
// 4 的十进制 ： 4
// -4 的十进制 ： -4
// -4 的二进制(简化版)： -100
// 4 的二进制 ： 0000000000000000000000000000000000000000000000000000000000000100
// -4 的二进制 ： -000000000000000000000000000000000000000000000000000000000000100
- 能够看出输出二进制时 Go 的输出与十进制同样一样将符号位具象化，而非输出对应的 0 或 1；
- 输出二进制时数值部分则取其绝对值的补码；
若是咱们想要看到正确的负数的补码形式则须要经过无符号数值类型间接实现：
- 无符号数值类型如何表示一个数的负数形式，答案是补码取反码加一；
- 譬如如何用无符号数值类型表示 -1:
^uint8(1) + 1； - ^ 符号在二元运算中表明亦或符；在一元运算中表明取反码符；
fmt.Printf("int8(1) : %08b \n", int8(1)) // 占 8 位宽，不足补 0
fmt.Printf("^int8(1) : %08b \n", ^int8(1)) // 占 8 位宽，不足补 0
fmt.Printf("^int8(1)+1 : %08b \n", ^int8(1)+1) // 占 8 位宽，不足补 0
fmt.Printf("uint8(1) : %08b \n", uint8(1)) // 占 8 位宽，不足补 0
fmt.Printf("^uint8(1) : %08b \n", ^uint8(1)) // 占 8 位宽，不足补 0
fmt.Printf("^uint8(1)+1 : %08b \n", ^uint8(1)+1)// 占 8 位宽，不足补 0
// 输出
// int8(1) : 00000001
// ^int8(1) : -0000010
// ^int8(1)+1 : -0000001
// uint8(1) : 00000001
// ^uint8(1) : 11111110
// ^uint8(1)+1 : 11111111
- 能够看到经过使用无符号数值类型对 1 取反后获得的是 -2 的补码形式
1111 1110，接着对反码后加一获得原值 1 的负数形式 -1 的补码1111 1111；
Go 的原子操做
不管是有符号数值类型仍是无符号数值类型，只要转成补码后进行的计算过程不须要考虑符号位的问题。
A - B = A + ( -B )
A - B = 补码( A ) + 补码( -B )
原子操做便是进行过程当中不能被中断的操做。也就是说，针对某个值的原子操做在被进行的过程中，CPU 毫不会再去进行其它的针对该值的操做。不管这些其它的操做是否为原子操做都会是这样。为了实现这样的严谨性，原子操做仅会由一个独立的 CPU 指令表明和完成。只有这样才可以在并发环境下保证原子操做的绝对安全。
Go 语言提供的原子操做都是非侵入式的。它们由标准库代码包 sync/atomic 中的众多函数表明。咱们能够经过调用这些函数对几种简单的类型的值进行原子操做。这些类型包括 int3二、int6四、uint3二、uint6四、uintptr 和 unsafe.Pointer 类型，共 6 个。这些函数提供的原子操做共有 5 种，即：增或减、比较并交换、载入、存储和交换。
原子操做 - 增或减
相关文档如图所示：
这里主要须要注意的是 Uint 类型的原子操做，以 AddUint32 函数为例
原子性的增长数值：
value := uint32(1)
atomic.AddUint32(&value, 1)
fmt.Printf("after call atomic.AddUint32(&value, 1) value is: %v\n", value)
atomic.AddUint32(&value, 2)
fmt.Printf("after call atomic.AddUint32(&value, 2) value is: %v\n", value)
atomic.AddUint32(&value, 3)
fmt.Printf("after call atomic.AddUint32(&value, 3) value is: %v\n", value)
// 输出
// after call atomic.AddUint32(&value, 1) value is: 2
// after call atomic.AddUint32(&value, 2) value is: 4
// after call atomic.AddUint32(&value, 3) value is: 7
原子性的减小数值：
如文档所述，若是须要减去一个正数 c 须要经过 ^uint32(c-1) 计算获得 c 的补码。
const one, two, three = 1, 2, 3
value := uint32(10)
atomic.AddUint32(&value, ^uint32(one - 1)) // 减一
fmt.Printf("after callatomic.AddUint32(&value, ^uint32(one - 1)) value is: %v\n", value)
atomic.AddUint32(&value, ^uint32(two - 1)) // 减二
fmt.Printf("after callatomic.AddUint32(&value, ^uint32(two - 1)) value is: %v\n", value)
atomic.AddUint32(&value, ^uint32(three - 1)) // 减三
fmt.Printf("after callatomic.AddUint32(&value, ^uint32(three - 1)) value is: %v\n", value)
// 输出
// after callatomic.AddUint32(&value, ^uint32(one - 1)) value is: 9
// after callatomic.AddUint32(&value, ^uint32(two - 1)) value is: 7
// after callatomic.AddUint32(&value, ^uint32(three - 1)) value is: 4
- value -1 等价于 value + (-1) ，等价于 补码( value ) + 补码( -1 )；
- 经过前面二进制规律二 得知，求 -1 的补码至关于求 0 的反码；
- go 的反码运算符位
^； - 结合后即可实现了无符号类型数据的减法运算。
参考
相关文章
- 1. Go 原子操做
- 2. JS的二进制操做
- 3. golang 原子操做
- 4. GO(9[TCP/Redis/原子操做])
- 5. 原子操做
- 6. 原子操做(CAS)
- 7. 原子操做的实现
- 8. golang 原子操做函数
- 9. Java中的原子操做
- 10. CAS 原子操做
- 更多相关文章...
- • C# 二进制文件的读写 - C#教程
- • MySQL BIT、BINARY、VARBINARY、BLOB（二进制类型） - MySQL教程
- • Docker容器实战(六) - 容器的隔离与限制
- • 漫谈MySQL的锁机制
相关标签/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
最新文章
- 1. eclipse设置粘贴字符串自动转义
- 2. android客户端学习-启动模拟器异常Emulator: failed to initialize HAX: Invalid argument
- 3. android.view.InflateException: class com.jpardogo.listbuddies.lib.views.ListBuddiesLayout问题
- 4. MYSQL8.0数据库恢复 MYSQL8.0ibd数据恢复 MYSQL8.0恢复数据库
- 5. 你本是一个肉体，是什么驱使你前行【1】
- 6. 2018.04.30
- 7. 2018.04.30
- 8. 你本是一个肉体，是什么驱使你前行【3】
- 9. 你本是一个肉体，是什么驱使你前行【2】
- 10. 【资讯】LocalBitcoins达到每周交易比特币的7年低点
欢迎关注本站公众号,获取更多信息
相关文章
- 1. Go 原子操做
- 2. JS的二进制操做
- 3. golang 原子操做
- 4. GO(9[TCP/Redis/原子操做])
- 5. 原子操做
- 6. 原子操做(CAS)
- 7. 原子操做的实现
- 8. golang 原子操做函数
- 9. Java中的原子操做
- 10. CAS 原子操做