github.com/qiuhoude/go-web@v0.0.0-20220223060959-ab545e78f20d/prepare/01_base/unsafe/unsafe_test.go (about)

     1  package unsafe
     2  
     3  import (
     4  	"fmt"
     5  	"testing"
     6  	"time"
     7  	"unsafe"
     8  )
     9  
    10  func TestSizeOf(t *testing.T) {
    11  	//Sizeof 函数可以返回一个类型所占用的内存大小，这个大小只有类型有关，.
    12  	// 和类型对应的变量存储的内容大小无关，比如bool型占用一个字节、int8也占用一个字节
    13  	t.Log(unsafe.Sizeof(true))
    14  	t.Log(unsafe.Sizeof(int8(0)))
    15  	t.Log(unsafe.Sizeof(int16(10)))
    16  	t.Log(unsafe.Sizeof(int32(10000000)))
    17  	t.Log(unsafe.Sizeof(int64(10000000000000)))
    18  	t.Log(unsafe.Sizeof(int(10000000000000000)))
    19  }
    20  
    21  func TestAlignof(t *testing.T) {
    22  	//var b bool
    23  	//var i8 int8
    24  	//var i16 int16
    25  	//var i32 int32
    26  	//var i64 int64
    27  	//
    28  	//var f32 float32
    29  	//
    30  	//var s string
    31  	//
    32  	//var m map[string]string
    33  	//
    34  	//var p *int32
    35  	////Alignof 返回一个类型的对齐值，也可以叫做对齐系数或者对齐倍数。
    36  	//// 对齐值是一个和内存对齐有关的值，合理的内存对齐可以提高内存读写的性能
    37  	//// unsafe.Alignof(x) 等价于 reflect.TypeOf(x).Align()
    38  	//fmt.Printf("%T %v\n", b, unsafe.Alignof(b))
    39  	//fmt.Printf("%T %v\n", i8, unsafe.Alignof(i8))
    40  	//fmt.Printf("%T %v\n", i16, unsafe.Alignof(i16))
    41  	//fmt.Printf("%T %v\n", i32, unsafe.Alignof(i32))
    42  	//fmt.Printf("%T %v\n", i64, unsafe.Alignof(i64))
    43  	//fmt.Printf("%T %v\n", f32, unsafe.Alignof(f32))
    44  	//fmt.Printf("%T %v\n", s, unsafe.Alignof(s))
    45  	//fmt.Printf("%T %v\n", m, unsafe.Alignof(m))
    46  	//fmt.Printf("%T %v\n", p, unsafe.Alignof(p))
    47  	//fmt.Printf("%T %v\n", p, reflect.TypeOf(p).Align())
    48  	//fmt.Printf("%T %v\n", p, unsafe.Alignof(p))
    49  
    50  	ti, _ := time.ParseInLocation("2006-01-02 15:04:05", "2016-06-13 15:34:39", time.Local)
    51  	// 整点（向下取整）
    52  	fmt.Println(ti.Truncate(1 * time.Hour))
    53  	// 整点（最接近）
    54  	fmt.Println(ti.Round(1 * time.Hour))
    55  
    56  	// 整分（向下取整）
    57  	fmt.Println(ti.Truncate(1 * time.Minute))
    58  	// 整分（最接近）
    59  	fmt.Println(ti.Round(1 * time.Minute))
    60  
    61  	t2, _ := time.ParseInLocation("2006-01-02 15:04:05", ti.Format("2006-01-02 15:00:00"), time.Local)
    62  	fmt.Println(t2)
    63  	timer := time.NewTimer(5 * time.Second)
    64  	<-timer.C
    65  	ticker := time.NewTicker(5 * time.Second)
    66  	<-ticker.C
    67  
    68  }
    69  
    70  type user1 struct {
    71  	b byte
    72  	i int32
    73  	j int64
    74  }
    75  
    76  type user2 struct {
    77  	b byte
    78  	j int64
    79  	i int32
    80  }
    81  
    82  type user3 struct {
    83  	i int32
    84  	b byte
    85  	j int64
    86  }
    87  
    88  type user4 struct {
    89  	i int32
    90  	j int64
    91  	b byte
    92  }
    93  
    94  type user5 struct {
    95  	j int64
    96  	b byte
    97  	i int32
    98  }
    99  
   100  type user6 struct {
   101  	j int64
   102  	i int32
   103  	b byte
   104  }
   105  
   106  func TestOffsetof(t *testing.T) {
   107  	// Offsetof函数只适用于struct结构体中的字段相对于结构体的内存位置偏移量。结构体的第一个字段的偏移量都是0.
   108  	// unsafe.Offsetof(u1.i)等价于reflect.TypeOf(u1).Field(i).Offset
   109  	var u1 user2
   110  
   111  	fmt.Println(unsafe.Offsetof(u1.b))
   112  	fmt.Println(unsafe.Offsetof(u1.i))
   113  	fmt.Println(unsafe.Offsetof(u1.j))
   114  }
   115  
   116  func TestSzieofStruct(t *testing.T) {
   117  	// 因为有对其方式,每个结构体的大小就不同
   118  	var u1 user1
   119  	var u2 user2
   120  	var u3 user3
   121  	var u4 user4
   122  	var u5 user5
   123  	var u6 user6
   124  
   125  	fmt.Println("u1 size is ", unsafe.Sizeof(u1))
   126  	fmt.Println("u2 size is ", unsafe.Sizeof(u2))
   127  	fmt.Println("u3 size is ", unsafe.Sizeof(u3))
   128  	fmt.Println("u4 size is ", unsafe.Sizeof(u4))
   129  	fmt.Println("u5 size is ", unsafe.Sizeof(u5))
   130  	fmt.Println("u6 size is ", unsafe.Sizeof(u6))
   131  
   132  }