golang-数组,切片,map是否线程安全?

1.数组

非线程安全

示例:

package main

import (
	"fmt"
	"sync"
	"time"
)

var (
	array = new([10]int32)
	slice = make([]string, 0)
	mm    = make(map[string]interface{})
)

func main() {

	array[0] = 1
	array[1] = 2
	array[2] = 3

	fmt.Println("array = ", array)
	wg := sync.WaitGroup{}
	wg.Add(4)
	go func() {
		defer wg.Done()
		array[0] = 10
		fmt.Println("go1", array)
	}()

	go func() {
		defer wg.Done()
		array[0] = 222
		fmt.Println("go2", array)
	}()

	go func() {
		defer wg.Done()
		array[0] = 333
		fmt.Println("go3", array)
	}()

	go func() {
		defer wg.Done()
		wg.Wait()
	}()

	time.Sleep(time.Second * 5)
}


array =  &[1 2 3 0 0 0 0 0 0 0]
go3 &[222 2 3 0 0 0 0 0 0 0]
go1 &[10 2 3 0 0 0 0 0 0 0]
go2 &[10 2 3 0 0 0 0 0 0 0]

2.切片

非线程安全的

package main

import (
	"fmt"
	"sync"
	"time"
)

var (
	array = new([10]int32)
	slice = make([]int, 0)
	mm    = make(map[string]interface{})
)

func main() {

	wg := sync.WaitGroup{}
	// rw := sync.Mutex{}

	for i := 0; i < 10000; i++ {
		wg.Add(1)
		go func() {
			defer wg.Done()
			// rw.Lock()
			slice = append(slice, 88)
			// rw.Unlock()
		}()
	}

	wg.Add(1)
	go func() {
		defer wg.Done()
		wg.Wait()
	}()

	time.Sleep(time.Second * 5)
	fmt.Println("slice = ", len(slice),cap(slice))
}

如上代码,每次执行结果都不一样,说明是非线程安全的。


2.切片指定索引
package main

import (
	"fmt"
	"sync"
)

func main() {
	// 指定索引存储
	sl := make([]int, 100)
	wg := sync.WaitGroup{}
	for index := 0; index < 100; index++ {
		k := index
		wg.Add(1)
		go func(num int) {
			sl[num] = num
			wg.Done()
		}(k)
	}
	wg.Wait()
	fmt.Printf("final len(sl)=%d cap(sl)=%d\n", len(sl), cap(sl))
}

结果是每次都一样,表明切片都是支持并发的,但是存在读写数据覆盖情况,实际使用,不能达到预期效果。


《***》综上结论:当指定索引使用切片时,切片是支持并发读写索引区的数据的,但是索引区的数据在并发时会被覆盖的;当不指定索引切片时,并且切片动态扩容时,并发场景下扩容会被覆盖,所以切片是不支持并发的。
《+++》实际使用的时,可以枷锁,channel,或者sync.map替代,总是确保数据能达到预期结果即可。

3.map

非线程安全的

package main

import (
	"fmt"
	"sync"
	"time"
)

var (
	array = new([10]int32)
	slice = make([]int, 0)
	mm    = make(map[int]int, 0)
)

func main() {

	wg := sync.WaitGroup{}
	rw := sync.Mutex{}

	for i := 0; i < 10000; i++ {
		wg.Add(1)
		go func() {
			defer wg.Done()
			rw.Lock()
			mm[666] = i
			rw.Unlock()

		}()
	}

	wg.Add(1)
	go func() {
		defer wg.Done()
		wg.Wait()
	}()

	time.Sleep(time.Second * 5)

	fmt.Println("mm[666] = ", mm[666])
}

//不枷锁会报错。

4.切片作为参数传递

     a.官方给的文档说明,go中的所有传递都是值传递,但是实际中,在基础类型的切片作为参数传递是,使用的是深拷贝,如下代码:

func modify(s []string) {
	s[0] = "hello"
}

func main() {
	var tl []string
	tl = make([]string, 4)
	tl[0] = "foo"
	modify(tl)
	fmt.Println(tl[0])
}
输出结果:
hello

 如上代码,说明原来切片的内容被修改了,足以说明,切片基础类型使用的是深拷贝处理的。

   b.但是在切片追加元素的时候,如果超出容量,会触发扩容机制,内部会重新生成一个更大的切片将原来的数据拷贝过来。这样就会造成在发生扩容的时候原切片跟扩容后生成的切片就没有了任何关联了。如下:

func modify(s []string) {
	s = append(s, "world") // 触发扩容机制
}

func main() {
	var tl []string
	tl = make([]string, 1)
	tl[0] = "foo"
	modify(tl)
	fmt.Println(tl[0]) // 该处输出原来切片的内容
}

输出结果:
foo

使用切片是,一定要小心注意此等问题,不然会出现不可预期的错误。

  • 2
    点赞
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Golang数组切片是两种不同的数据类型,用于存储相同数据类型的容器。数组的长度是固定的,而切片的长度是可变的。在日常应用中,切片的使用更为普遍。 数组在声明时需要指定长度,并且在初始化时必须提供相同长度的元素。例如,`a := int{1, 2, 3}`就是一个长度为3的整数数组数组的长度一旦确定后就不能更改。 切片是基于数组的引用类型。它不需要指定固定的长度,并且可以根据需要动态扩展或缩小。切片包装着底层数组,通过指定起始索引和结束索引来指定子集。例如,`b := a[:]`就是一个切片,它包含了数组a的所有元素。 数组适用于需要固定长度的场景,而切片适用于长度可变的情况。在实际应用中,切片更常用,因为它提供了更大的灵活性和便利性。 总结: - 数组是长度固定的容器,切片是长度可变的容器; - 数组在声明时需要指定长度,切片则不需要; - 数组的长度一旦确定后就不能更改,而切片可以根据需要动态扩展或缩小; - 切片是基于数组的引用类型,可以通过指定起始索引和结束索引来指定子集。 参考资料: Golang中的「数组」和「切片」都是存储同一数据类型的容器,只不过Golang中的数组长度是固定的,而切片的长度是可变化的。 切片是引用类型,切片包装的数组称为该切片的底层数组。我们来看一段代码://a是一个数组,注意数组是一个固定长度的,初始化时候必须要指定长度,不指定长度的话就是切片了 a := int{1, 2, 3} //b是数组,是a...。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值