一、线程安全介绍

1.1 现实例子

A. 多个goroutine同时操作一个资源,这个资源又叫临界区

B. 现实生活中的十字路口,通过红路灯实现线程安全

C. 火车上的厕所(进去之后先加锁,在上厕所,不加锁两个人都进去就出问题了,出来后在解锁,别人就可以使用了),通过互斥锁来实现线程安全

D、在程序中,同一个变量多个goroutine去修改的时候,肯定是不允许同时修改的,同时修改肯定会出问题,所以当一个goroutine在修改之前需要加锁,修改结束在解锁,这样别的goroutine就可以去修改了。

1.2 实际例子

x = x +1

A. 先从内存中取出x的值

B. CPU进行计算, x+1

C. 然后把x+1的结果存储在内存中

解释:

就是两个goroutine同时去操作x(共享资源),最后的结果x并不是2,由于线程安全的问题,导致最后的结果还是等于1;

详情也如下图所示:

下面来看一个实际例子:

test1和test2函数都是在自增到1000000(对同一个变量count进行修改)

1)当test1函数和test2函数跑在同一个线程时:

package main

import (
"fmt"
) var count int func test1() {
for i := ; i < ; i++ {
count++
}
} func test2() {
for i := ; i < ; i++ {
count++
}
} func main() {
test1()
test2()
fmt.Printf("count=%d\n", count)
}

执行结果如下:

因为是串行执行,所以最终结果肯定是2000000

2)当test1函数和test2函数独自起goroutine运行时:

package main

import (
"fmt"
"time"
) var count int func test1() {
for i := ; i < ; i++ {
count++
}
} func test2() {
for i := ; i < ; i++ {
count++
}
} func main() {
go test1()
go test2() time.Sleep(time.Second)
fmt.Printf("count=%d\n", count)
}

执行结果如下:

解释:

可以看到当test1和test2同时运行对count(共享资源)进行修改时,就会出现冲突,最终结果也就不是2000000了

1.3 如何解决?

那么如何解决上述线程安全问题呢,就是我们接下来要学习的互斥锁。

第2章 互斥锁

2.1 互斥锁介绍

A. 同时有且只有一个线程进入临界区,其他的线程则在等待锁;

B. 当互斥锁释放之后,等待锁的线程才可以获取锁进入临界区;

C. 多个线程同时等待同一个锁,唤醒的策略是随机的;

2.2 互斥锁使用实例

package main

import (
"fmt"
"sync" //互斥锁需要使用这个包。 "time"
) var count int
var mutex sync.Mutex //定义一个锁的变量(互斥锁的关键字是Mutex,其是一个结构体,传参一定要传地址,否则就不对了)
func test1() {
for i := ; i < ; i++ {
mutex.Lock() //对共享变量操作之前先加锁
count++
mutex.Unlock() //对共享变量操作完毕在解锁,这样就保护了共享的资源
}
} func test2() {
for i := ; i < ; i++ {
mutex.Lock()
count++
mutex.Unlock()
}
} func main() {
go test1()
go test2() time.Sleep(time.Second)
fmt.Printf("count=%d\n", count)
}

执行结果如下:

解释:

加锁(互斥锁)之后其实是相当于串行(对共享变量进行操作时)执行了,就算是goroutine也不例外。

2.3 互斥锁高阶实例

1)未加互斥锁代码(有问题)

package main

import (
"fmt"
"sync"
) var x = func increment(wg *sync.WaitGroup) {
x = x +
wg.Done()
}
func main() {
var w sync.WaitGroup
for i := ; i < ; i++ {
w.Add()
go increment(&w)
}
w.Wait()
fmt.Println("final value of x", x)
}

执行结果:

2)添加互斥锁代码

package main

import (
"fmt"
"sync"
) var x = func increment(wg *sync.WaitGroup, m *sync.Mutex) {
m.Lock()
x = x +
m.Unlock()
wg.Done()
}
func main() {
var w sync.WaitGroup
var m sync.Mutex
for i := ; i < ; i++ {
w.Add()
go increment(&w, &m)
}
w.Wait()
fmt.Println("final value of x", x)
}

执行结果:

三、读写锁

3.1 使用场景

A. 读多写少的场景;

B. 分为两种角色,读锁和写锁;

C. 当一个goroutine获取写锁之后,其他的goroutine获取写锁或读锁都会等待;

D. 当一个goroutine获取读锁之后,其他的goroutine获取写锁都会等待, 但其他

goroutine获取读锁时,都会继续获得锁.;

3.2 读写锁案例演示

package main

import (
"sync"
"time"
) var rwlock sync.RWMutex //定义一个锁的变量(读写锁的关键字是RWMutex,其是一个结构体,传参一定要传地址,否则就不对了)
var wg sync.WaitGroup
var count int func writer() { //写的线程
for i := ; i < ; i++ {
// 加写锁
rwlock.Lock() //加锁写锁之后,其他goroutine就不能针对该共享变量加读锁或写锁(读取或写入)了
count++
time.Sleep( * time.Millisecond) //模拟写操作需要10ms
// 释放写锁
rwlock.Unlock()
}
wg.Done()
} func reader() { //读的线程
for i := ; i < ; i++ {
// 加读锁
rwlock.RLock() //对于读锁来说,其他goroutine依然可以对该共享变量进行读取(读锁)依然可以,但是写入不行,获取写锁需要等待。
_ = count
//fmt.Printf("count=%d\n", count)
time.Sleep( * time.Millisecond) //模拟读操作场景需要1ms
// 释放读锁
rwlock.RUnlock()
}
wg.Done()
} func main() {
wg.Add()
go writer()
for i := ; i < ; i++ {
wg.Add()
go reader() //读锁是并发的,这里加了for循环主要是为了模拟只要有1个goroutine能够读取到共享资源,其他的goroutine也可以获取到。
}
wg.Wait()
}

执行结果:

3.3 读写锁和互斥锁性能比较

针对同一个程序,我们通过比较互斥锁和读写锁的耗时来进行直观展示:

首先计算读写锁性能:

代码示例如下:

package main

import (
"fmt"
"sync"
"time"
) var rwlock sync.RWMutex //定义一个锁的变量(读写锁的关键字是RWMutex,其是一个结构体,传参一定要传地址,否则就不对了)
var wg sync.WaitGroup
var count int func writer() { //写的线程
for i := ; i < ; i++ {
// 加写锁
rwlock.Lock() //加锁写锁之后,其他goroutine就不能针对该共享变量加读锁或写锁(读取或写入)了
count++
time.Sleep( * time.Millisecond) //模拟写操作需要10ms
// 释放写锁
rwlock.Unlock()
}
wg.Done()
} func reader() { //读的线程
for i := ; i < ; i++ {
// 加读锁
rwlock.RLock() //对于读锁来说,其他goroutine依然可以对该共享变量进行读取(读锁)依然可以,但是写入不行,获取写锁需要等待。
_ = count
//fmt.Printf("count=%d\n", count)
time.Sleep( * time.Millisecond) //模拟读操作场景需要1ms
// 释放读锁
rwlock.RUnlock()
}
wg.Done()
} func main() { start := time.Now().UnixNano() //开始时间
wg.Add()
go writer()
for i := ; i < ; i++ {
wg.Add()
go reader() //读锁是并发的,这里加了for循环主要是为了模拟只要有1个goroutine能够读取到共享资源,其他的goroutine也可以获取到。
}
wg.Wait()
end := time.Now().UnixNano() //结束时间
cost := (end - start) / / /
fmt.Printf("cost %d s\n", cost) }

执行结果如下:

互斥锁性能:

见如下实例:

package main

import (
"fmt"
"sync"
"time"
) var mlock sync.Mutex //声明互斥锁变量
var wg sync.WaitGroup
var count int func writer_mutex() { //写的线程
for i := ; i < ; i++ {
mlock.Lock()
count++
time.Sleep( * time.Millisecond) //模拟写操作需要10ms
mlock.Unlock()
}
wg.Done()
} func reader_mutex() { //读的线程
for i := ; i < ; i++ {
mlock.Lock() //对于多个goroutine来说,互斥锁也是只有1个goroutine可以读,并不像读写锁一样,所有goroutine都可以读
_ = count
//fmt.Printf("count=%d\n", count)
time.Sleep( * time.Millisecond) //模拟读操作场景需要1ms
mlock.Unlock()
}
wg.Done()
} func main() { start := time.Now().UnixNano() //开始时间
wg.Add()
go writer_mutex()
for i := ; i < ; i++ {
wg.Add()
go reader_mutex()
}
wg.Wait()
end := time.Now().UnixNano() //结束时间
cost := (end - start) / / /
fmt.Printf("cost %d s\n", cost) }

执行结果如下:

总结:

可以看到最终的结果是同一个程序互斥锁比读写锁耗时多了9秒,主要原因是在读的时候,读写锁可以多个读线程去读,而互斥锁依然只能是一个线程去读,1比10的比例,就造成了最终这个结果。

葵花宝典

读多写少用读写锁,读写差不多用互斥锁。

Go语言基础之13--线程安全及互斥锁和读写锁的更多相关文章

  1. UNIX环境高级编程——线程同步之互斥锁、读写锁和条件变量(小结)

    一.使用互斥锁 1.初始化互斥量 pthread_mutex_t mutex =PTHREAD_MUTEX_INITIALIZER;//静态初始化互斥量 int pthread_mutex_init( ...

  2. 四十、Linux 线程——互斥锁和读写锁

    40.1 互斥锁 40.1.1 介绍 互斥锁(mutex)是一种简单的加锁的方法来控制对共享资源的访问. 在同一时刻只能有一个线程掌握某个互斥锁,拥有上锁状态的线程能够对共享资源进行访问. 若其他线程 ...

  3. Go语言中的互斥锁和读写锁(Mutex和RWMutex)

    目录 一.Mutex(互斥锁) 不加锁示例 加锁示例 二.RWMutex(读写锁) 并发读示例 并发读写示例 三.死锁场景 1.Lock/Unlock不是成对出现 2.锁被拷贝使用 3.循环等待 虽然 ...

  4. Python进阶----线程基础,开启线程的方式(类和函数),线程VS进程,线程的方法,守护线程,详解互斥锁,递归锁,信号量

    Python进阶----线程基础,开启线程的方式(类和函数),线程VS进程,线程的方法,守护线程,详解互斥锁,递归锁,信号量 一丶线程的理论知识 什么是线程:    1.线程是一堆指令,是操作系统调度 ...

  5. APUE学习笔记——11 线程同步、互斥锁、自旋锁、条件变量

    线程同步     同属于一个进程的不同线程是共享内存的,因而在执行过程中需要考虑数据的一致性.     假设:进程有一变量i=0,线程A执行i++,线程B执行i++,那么最终i的取值是多少呢?似乎一定 ...

  6. 线程同步 - POSIX互斥锁

    线程同步 - POSIX互斥锁 概括 本文讲解POSIX中互斥量的基本用法,从而能达到简单的线程同步.互斥量是一种特殊的变量,它有两种状态:锁定以及解锁.如果互斥量是锁定的,就有一个特定的线程持有或者 ...

  7. 二、多线程基础-乐观锁_悲观锁_重入锁_读写锁_CAS无锁机制_自旋锁

    1.10乐观锁_悲观锁_重入锁_读写锁_CAS无锁机制_自旋锁1)乐观锁:就像它的名字一样,对于并发间操作产生的线程安全问题持乐观状态,乐观锁认为竞争不总是会发生,因此它不需要持有锁,将 比较-设置 ...

  8. ndk学习之c++语言基础复习----C++线程与智能指针

    线程 线程,有时被称为轻量进程,是程序执行的最小单元. C++11线程: 我们知道平常谈C++线程相关的东东基本都是基于之后要学习的posix相关的,其实在C++11有自己新式创建线程的方法,所以先来 ...

  9. node源码详解(七) —— 文件异步io、线程池【互斥锁、条件变量、管道、事件对象】

    本作品采用知识共享署名 4.0 国际许可协议进行许可.转载保留声明头部与原文链接https://luzeshu.com/blog/nodesource7 本博客同步在https://cnodejs.o ...

随机推荐

  1. 【总结整理】WMS、WMTS、WFS

    参考:http://www.cnblogs.com/naaoveGIS/p/5508882.html WMTS:WMTS是OGC制定的一种发布瓦块地图的Web服务规范,wms主要是动态地图,wmts是 ...

  2. C++中的友元

    友元函数 在类的声明中可以声明某一个函数作为该类的友元函数,然后该函数就可以访问类中的private数据成员了. demo: /* wirten by qianshou 2013/12/6 04:13 ...

  3. vray学习笔记(4)混合材质是个什么东西

    看下定义: The Blend material lets you mix two materials on a single side of the surface. Blend material材 ...

  4. 每个程序中只有一个public类,主类?

    import java.io.*; public class GameSaverTest { public static void main(String[] args){ //创建人物 GameCh ...

  5. Umbraco中获取UmbracoContext

    在Umbraco项目中,获取当前的UmbracoContext几乎是都需要用到的,我们一般通过一个静态方法来获取,代码如下 public class ContextHelpers { public s ...

  6. kaggle Titanic

    # coding: utf-8 # In[19]: # 0.78468 # In[20]: import numpy as np import pandas as pd import warnings ...

  7. Gym - 100792C Colder-Hotter(三分交互)

    Colder-Hotter Statements This is an interactive problem. Egor and Petr are playing a game called «Co ...

  8. 《Linux内核设计与实现》读书笔记(八)- 中断下半部的处理

    在前一章也提到过,之所以中断会分成上下两部分,是由于中断对时限的要求非常高,需要尽快的响应硬件. 主要内容: 中断下半部处理 实现中断下半部的机制 总结中断下半部的实现 中断实现示例 1. 中断下半部 ...

  9. jquery easyui datagrid 多选只能获取一条数据

    DataGrid属性: singleSelect ------如果为true,则只允许选择一行: idField ------- 指明哪一个字段是标识字段: 方法: 一:getSelections-- ...

  10. Java基础之对包,类,方法,变量理解(灵感)

    包,类,方法,变量 灵感乍现 感觉就如电脑上的各个大小文档一般,只不过名称不同,用法不同,功效不同,就好比你要调用网上的一个图片,这个图片可以是变量,可以是方法,可以是类.你要调用可以把他幻化成接口, ...