《快学 Go 语言》第 14 课 —— 魔术变性指针-低调大师

《快学 Go 语言》第 14 课 —— 魔术变性指针

2018-12-18 582

本节我们要学习一些 Go 语言的魔法功能，通过内置的 unsafe 包提供的功能，直接操纵指定内存地址的内存。有了 unsafe 包，我们就可以洞悉 Go 语言内置数据结构的内部细节。

unsafe.Pointer
Pointer 代表着变量的内存地址，可以将任意变量的地址转换成 Pointer 类型，也可以将 Pointer 类型转换成任意的指针类型，它是不同指针类型之间互转的中间类型。Pointer 本身也是一个整型的值。

type Pointer int

在 Go 语言里不同类型之间的转换是要受限的。普通的基础变量转换成不同的类型需要进行内存浅拷贝，而指针变量类型之间是禁止直接转换的。要打破这个限制，unsafe.Pointer 就可以派上用场，它允许任意指针类型的互转。

指针的加减运算
Pointer 虽然是整型的，但是编译器禁止它直接进行加减运算。如果要进行运算，需要将 Pointer 类型转换 uintptr 类型进行加减，然后再将 uintptr 转换成 Pointer 类型。uintptr 其实也是一个整型。

type uintptr int

下面让我们就来尝试一下刚刚学到的魔法

package main

import "fmt"
import "unsafe"

type Rect struct {
    Width int
    Height int
}

func main() {
    var r = Rect {50, 50}
    // *Rect => Pointer => *int => int
    var width = *(*int)(unsafe.Pointer(&r))
    // *Rect => Pointer => uintptr => Pointer => *int => int
    var height = *(*int)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + uintptr(8)))
    fmt.Println(width, height)
}

------
50 50

上面的代码是用 unsafe 包来读取结构体的内容，形式上比较繁琐，注意看代码中的注释，读者需要稍微转一转脑袋来理解一下上面的代码。接下来我们再尝试修改结构体的值

package main

import "fmt"
import "unsafe"

type Rect struct {
    Width int
    Height int
}

func main() {
    var r = Rect {50, 50}
    // var pw *int
    var pw = (*int)(unsafe.Pointer(&r))
    // var ph *int
    var ph = (*int)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + uintptr(8)))
    *pw = 100
    *ph = 100
    fmt.Println(r.Width, r.Height)
}

--------
100 100

代码中的 uintptr(8) 很不优雅，可以使用 unsafe 提供了 Offsetof 方法来替换它，它可以直接得到字段在结构体内的偏移量

var ph = (*int)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + unsafe.Offsetof(r.Height))

你也许会抱怨为啥指针操作这么繁琐，不能简单一点么？Go 语言的设计者故意这样设计的，因为指针操作非常的不安全，所以它要给用户设置障碍。

探索切片内部结构
在切片小节，我们知道了切片分为切片头和内部数组两部分，下面我们使用 unsafe 包来验证一下切片的内部数据结构，看看它和我们预期的是否一样。

package main

import "fmt"
import "unsafe"

func main() {
    // head = {address, 10, 10}
    // body = [1,2,3,4,5,6,7,8,9,10]
    var s = []int{1,2,3,4,5,6,7,8,9,10}
    var address = (**[10]int)(unsafe.Pointer(&s))
    var len = (*int)(unsafe.Pointer(uintptr(unsafe.Pointer(&s)) + uintptr(8)))
    var cap = (*int)(unsafe.Pointer(uintptr(unsafe.Pointer(&s)) + uintptr(16)))
    fmt.Println(address, *len, *cap)
    var body = **address
    for i:=0; i< len(body); i++ {
        fmt.Printf("%d ", body[i])
    }
}

------------------
0xc42000a080 10 10
1 2 3 4 5 6 7 8 9 10

输出的结果正是我们锁期望的，不过读者需要仔细思考一下 address 为什么是二级指针变量。

字符串与字节切片的高效转换
在字符串小节我们提到字节切片和字符串之间的转换需要复制内存，如果字符串或者字节切片的长度较大，转换起来会有较高的成本。下面我们通过 unsafe 包提供另一种高效的转换方法，让转换前后的字符串和字节切片共享内部存储。

字符串和字节切片的不同点在于头部，字符串的头部 2 个 int 字节，切片的头部 3 个 int 字节

package main

import "fmt"
import "unsafe"

func main() {
    fmt.Println(bytes2str(str2bytes("hello")))
}

func str2bytes(s string) []byte {
    var strhead = *(*[2]int)(unsafe.Pointer(&s))
    var slicehead [3]int
    slicehead[0] = strhead[0]
    slicehead[1] = strhead[1]
    slicehead[2] = strhead[1]
    return *(*[]byte)(unsafe.Pointer(&slicehead))
}

func bytes2str(bs []byte) string {
    return *(*string)(unsafe.Pointer(&bs))
}

-----
hello

切记通过这种形式转换而成的字节切片千万不可以修改，因为它的底层字节数组是共享的，修改会破坏字符串的只读规则。其次使用这种形式得到的字符串或者切片只可以用作临时的局部变量，因为被共享的字节数组随时可能会被回收，原字符串或者字节切片的内存由于不再被引用，让垃圾回收器解决掉了。

深入接口变量的赋值
在接口变量的小节，有一个问题还悬而未决，那就是接口变量在赋值时发生了什么？

通过 unsafe 包，我们就可以看清里面的细节，下面我们将一个结构体变量赋值给接口变量，看看修改结构体的内存会不会影响到接口变量的数据内存

package main

import "fmt"
import "unsafe"

type Rect struct {
    Width int
    Height int
}

func main() {
    var r = Rect{50, 50}
    // {typeptr, dataptr}
    var s interface{} = r

    var sptrs = *(*[2]*Rect)(unsafe.Pointer(&s))
    // var dataptr *Rect
    var sdataptr = sptrs[1]
    fmt.Println(sdataptr.Width, sdataptr.Height)

    // 修改原对象，看看接口指向的对象是否受到影响
    r.Width = 100
    fmt.Println(sdataptr.Width, sdataptr.Height)
}

-------
50 50
50 50

从输出中可以得出结论，将结构体变量赋值给接口变量，结构体内存会被复制。那如果是两个接口变量之间的赋值呢，会不会同样也需要复制指向的数据呢？

package main

import "fmt"
import "unsafe"

type Rect struct {
    Width int
    Height int
}

func main() {
    // {typeptr, dataptr}
    var s interface{} = Rect{50, 50}
    var r = s

    var rptrs = *(*[2]*Rect)(unsafe.Pointer(&r))
    var rdataptr = rptrs[1]
    var sptrs = *(*[2]*Rect)(unsafe.Pointer(&s))
    var sdataptr = sptrs[1]

    fmt.Println(sdataptr.Width, sdataptr.Height)
    fmt.Println(rdataptr.Width, rdataptr.Height)

    // 修改原对象
    sdataptr.Width = 100
    // 再对比一下原对象和目标对象
    fmt.Println(sdataptr.Width, sdataptr.Height)
    fmt.Println(rdataptr.Width, rdataptr.Height)
}

-----------
50 50
50 50
100 50
100 50

从输出中可以发现赋值前后两个接口变量共享了数据内存，没有发生数据的复制。接下来我们再引入第 3 个问题，不同类型的接口变量赋值会不会发生复制？

package main

import "fmt"
import "unsafe"

type Areable interface {
    Area() int
}

type Rect struct {
    Width int
    Height int
}

func (r Rect) Area() int {
    return r.Width * r.Height
}

func main() {
    // {typeptr, dataptr}
    var s Areable = Rect{50, 50}
    var r interface{} = s

    var rptrs = *(*[2]*Rect)(unsafe.Pointer(&r))
    var rdataptr = rptrs[1]
    var sptrs = *(*[2]*Rect)(unsafe.Pointer(&s))
    var sdataptr = sptrs[1]

    fmt.Println(sdataptr.Width, sdataptr.Height)
    fmt.Println(rdataptr.Width, rdataptr.Height)

    // 修改原对象
    sdataptr.Width = 100
    // 再对比一下原对象和目标对象
    fmt.Println(sdataptr.Width, sdataptr.Height)
    fmt.Println(rdataptr.Width, rdataptr.Height)
}

------
50 50
50 50
100 50
100 50

结果是不同类型接口之间赋值指向的数据对象还是共享的。接下来我们再引入第 4 个问题，接口类型之间在造型时是否会发生内存的复制。

package main

import "fmt"
import "unsafe"

type Areable interface {
    Area() int
}

type Rect struct {
    Width int
    Height int
}

func (r Rect) Area() int {
    return r.Width * r.Height
}

func main() {
    // {typeptr, dataptr}
    var s interface{} = Rect{50, 50}
    var r Areable = s.(Areable)

    var rptrs = *(*[2]*Rect)(unsafe.Pointer(&r))
    var rdataptr = rptrs[1]
    var sptrs = *(*[2]*Rect)(unsafe.Pointer(&s))
    var sdataptr = sptrs[1]

    fmt.Println(sdataptr.Width, sdataptr.Height)
    fmt.Println(rdataptr.Width, rdataptr.Height)

    // 修改原对象
    sdataptr.Width = 100
    // 再对比一下原对象和目标对象
    fmt.Println(sdataptr.Width, sdataptr.Height)
    fmt.Println(rdataptr.Width, rdataptr.Height)
}

------
50 50
50 50
100 50
100 50

答案是不同接口类型之间造型数据还是共享的。最后再提一个问题，将接口类型造型成结构体类型，是否会发生内存复制？

package main

import "fmt"
import "unsafe"

type Areable interface {
    Area() int
}

type Rect struct {
    Width int
    Height int
}

func (r Rect) Area() int {
    return r.Width * r.Height
}

func main() {
    // {typeptr, dataptr}
    var s interface{} = Rect{50, 50}
    var r Rect = s.(Rect)

    var sptrs = *(*[2]*Rect)(unsafe.Pointer(&s))
    var sdataptr = sptrs[1]

    // 修改原对象
    sdataptr.Width = 100
    // 再对比一下原对象和目标对象
    fmt.Println(sdataptr.Width, sdataptr.Height)
    fmt.Println(r.Width, r.Height)
}

答案是将接口造型成结构体类型，内存会发生复制，它们之间的数据不会共享。

从上面 5 个问题，我们可以得出结论，接口类型和结构体类型似乎是两个不同的世界。只有接口类型之间的赋值和转换会共享数据，其它情况都会复制数据，其它情况包括结构体之间的赋值，结构体转接口，接口转结构体。不同接口变量之间的转换本质上只是调整了接口变量内部的类型指针，数据指针并不会发生改变。

通过 unsafe 包我们还可以分析很多细节，在高级内容部分，我们将会频繁使用这个工具。

原文发布时间为：2018-12-19
本文作者：老钱
本文来自云栖社区合作伙伴“码洞”，了解相关信息可以关注“codehole”微信公众号

微信关注我们

原文链接：https://yq.aliyun.com/articles/680640

转载内容版权归作者及来源网站所有！

低调大师中文资讯倾力打造互联网数据资讯、行业资源、电子商务、移动互联网、网络营销平台。持续更新报道IT业界、互联网、市场资讯、驱动更新,是最及时权威的产业资讯及硬件资讯报道平台。

插入排序和Shell排序

本文为自己的学习笔记,如果有语义错误请及时指正谢谢, 插入排序插入排序是对未排序数据在有序数据中找位置插入的过程,如下图排序流程首先对前两个数据进行比较大小,然后确定这两个元素的顺序然后将未排序的第三个元素与之前的两个数据对比,在排好序的两个数据中找到正确位置插入然后就是将第四个数据与之前的排好序的三个数据对比,寻找正确位置插入依照规律完成即可代码分析首先肯定是要有一个循环来代表整体的数据后移然后还需要一个循环是需要判断未排序元素在已经排好序的数据序列中的正确位置 java实现代码 private static void cr(int[] arrs) { int j; for (int i = 1; i < arrs.length; i++) { j = i; while (j > 0 && arrs[j] < arrs[j-1]){ //一直判断,寻找在有序序列中的正确位置 swap(arrs,j,j-1); //数据位置互相交换的内置方法,可以利用tmp变量代替 j--; } } System.out.println(Arrays...

2018-12-18

638

应用场景前两天我们已经介绍了两种Spring Cloud Stream对消息失败的处理策略：自动重试：对于一些因环境原因（如：网络抖动等不稳定因素）引发的问题可以起到比较好的作用，提高消息处理的成功率。自定义错误处理逻辑：如果业务上，消息处理失败之后有明确的降级逻辑可以弥补的，可以采用这种方式，但是2.0.x版本有Bug，2.1.x版本修复。那么如果代码本身存在逻辑错误，无论重试多少次都不可能成功，也没有具体的降级业务逻辑，之前在深入思考中讨论过，可以通过日志，或者降级逻辑记录的方式把错误消息保存下来，然后事后分析、修复Bug再重新处理。但是很显然，这样做非常原始，并且太过笨拙，处理复杂度过高。所以，本文将介绍利用中间件特性来便捷地处理该问题的方案：使用RabbitMQ的DLQ队列。动手试试准备一个会消费失败的例子，可以直接沿用前文的工程。也可以新建一个，然后创建如下代码的逻辑： @EnableBinding ( TestApplication . TestTopic . class ) @SpringBootApplication public class TestAppli...

2018-12-18

590

资源下载

更多资源

Nacos

Nacos /nɑ:kəʊs/ 是 Dynamic Naming and Configuration Service 的首字母简称，一个易于构建 AI Agent 应用的动态服务发现、配置管理和AI智能体管理平台。Nacos 致力于帮助您发现、配置和管理微服务及AI智能体应用。Nacos 提供了一组简单易用的特性集，帮助您快速实现动态服务发现、服务配置、服务元数据、流量管理。Nacos 帮助您更敏捷和容易地构建、交付和管理微服务平台。

Rocky Linux

Rocky Linux（中文名：洛基）是由Gregory Kurtzer于2020年12月发起的企业级Linux发行版，作为CentOS稳定版停止维护后与RHEL（Red Hat Enterprise Linux）完全兼容的开源替代方案，由社区拥有并管理，支持x86_64、aarch64等架构。其通过重新编译RHEL源代码提供长期稳定性，采用模块化包装和SELinux安全架构，默认包含GNOME桌面环境及XFS文件系统，支持十年生命周期更新。

Sublime Text

Sublime Text具有漂亮的用户界面和强大的功能，例如代码缩略图，Python的插件，代码段等。还可自定义键绑定，菜单和工具栏。Sublime Text 的主要功能包括：拼写检查，书签，完整的 Python API ， Goto 功能，即时项目切换，多选择，多窗口等等。Sublime Text 是一个跨平台的编辑器，同时支持Windows、Linux、Mac OS X等操作系统。

WebStorm

WebStorm 是jetbrains公司旗下一款JavaScript 开发工具。目前已经被广大中国JS开发者誉为“Web前端开发神器”、“最强大的HTML5编辑器”、“最智能的JavaScript IDE”等。与IntelliJ IDEA同源，继承了IntelliJ IDEA强大的JS部分的功能。