C# 并发编程

C# 并发编程

前言

对于现在很多编程语言来说,多线程已经得到了很好的支持,

以至于我们写多线程程序简单,但是一旦遇到并发产生的问题就会各种尝试。

因为不是明白为什么会产生并发问题,并发问题的根本原因是什么。

接下来就让我们来走近一点并发产生的那些问题。

猜猜是多少?

 public class ThreadTest_V0
    {
        public int count = 0;
        public void Add1()
        {
            int index = 0;
            while (index++ < 1000000)//100万次
            {
                ++count;
            }
        }

        public void Add2()
        {
            int index = 0;
            while (index++ < 1000000)//100万次
            {
                count++;
            }
        }
    }

结果是多少?

static void V0()
        {
            ThreadTest_V0 testV0 = new ThreadTest_V0();
            Thread th1 = new Thread(testV0.Add1);
            Thread th2 = new Thread(testV0.Add2);

            th1.Start();
            th2.Start();
            th1.Join();
            th2.Join();

            Console.WriteLine($"V0:count = {testV0.count}");
        }

答案:100万 到 200万之间的随机数。

为什么?

接下来我们去深入了解一下为什么会这样?

一、可见性

首先我们来到 “可见性” 这个陌生的词汇身边。

通过一番交谈了解到:

对可见性进行一下总结就是我改的东西你能同时看到。

1.1 背景

解读一下呢,就像下面这样:

CPU 内存 硬盘 ,处理速度上存在很大的差距,为了弥补这种差距,也是为了利用CPU强大计算能力。

CPU 和内存之前加入了缓存,就是我们经常听说的 寄存器缓存、L1、2、3级缓存。

应该的处理流程是这样的:读取内存数据,缓存到CPU缓存中,CPU进行计算后,从CPU缓存中写回内存。

1.2 线程切换

还有一点 我们都知道多线程其实是通过切换时间片来达到 “同时” 处理问题的假象。

线程切换
C# 并发编程_第1张图片

1.3 单核时代

你也发现了,对于单核来说,程序其实还是串行开发的。
C# 并发编程_第2张图片

单核CPU

就像是 “一个人” ,东干点,西干点,如果切换频率上再快点速度,比我们的眨眼时间还短呢?那…… 接下来,我们进入了多核时代。

1.4多核时代

顾名思义,多个CPU,也就是每个CPU核心都有自己的缓存体系,但是内存只有一份。

比如CPU就是我么们的本地缓存,而内存相当于数据库。

我们每个人的本地缓存极有可能是不一样的,如果我们拿着这些缓存直接做一些业务计算,

结果可想而知,多核时代,多线程并发也会有这样的问题 — CPU缓存的数据不一样咋办?
C# 并发编程_第3张图片

多核CPU

1.5 volatile

这是CLR 为我们提出的解决方案,就是在遇到可见性引发的并发问题时,使用 volatile 关键字。

就是告诉 CPU,我不想用你的缓存,所有的请求都直接读写内存。

一句话,就是禁用缓存。

看上去这样就能解决并发问题了吧?也不全是,还有下面这种枪情况。

二、有序性

字面意义就是有顺序,那么是什么有顺序呢?-- 代码

代码其实并不是我们所写的那样一五一十地执行,以C# 为例:

代码 --> IL --> Jit --> cpu 指令

代码 通过编译器的优化生成了IL

CPU也会根据自己的优化重新排列指令顺序

至少两个点会有存在调整 代码顺序/指令顺序的可能。

2.1 猜猜 Debug和Release 运行结果各是多少

public class VolatileTest
    {
        public int falg = 0;
    }
static void VolatileTest()
        {
            VolatileTest volatiler = new VolatileTest();

            new Thread(
               p =>
               {
                   Thread.Sleep(1000);
                   volatiler.falg = 255;
               }).Start();

            while (true)
            {
                if (volatiler.falg == 255)
                {
                    break;
                }
            };

            Console.WriteLine("OK");
        }

主线程一直自旋,直到子线程将值改变就退出,显示 “OK”

  • Debug 版本,执行结果:

C# 并发编程_第4张图片

Debug

  • Release 版本,执行结果:

C# 并发编程_第5张图片

Release

为什么会这样,因为我们的代码会经过编译器优化,CPU指令优化,

语句的顺序会发生改变,但是这样也是这种离奇bug产生的一种方式。

怎么避免它?

2.2 volatile

没错,依然是它,不仅仅是禁用cpu缓存,而且还能禁止指令和编译优化。

至少上面的那个例子我们可以再试试:

public class VolatileTest
    {
        public volatile int falg = 0;
    }

volatile 发布版
C# 并发编程_第6张图片

到这里应该就可以了吧,volatile 真好用,一个关键字就搞定。

正如你所想,依然没有结束。

三、原子性

我们平时经常遇到要给一段代码区域加上锁,比如这样:

lock (lockObj)
                {
                    count++;
                }

我么们为什么要加锁呢?你说为了线程同步,为什么加锁就能保证线程同步而不是其他方式?

3.1count++

说到这里,我们需要再了解一个问题:count++

我们经常写这样的代码,那么count++ 最终转换成cpu指令会是什么样子呢?

指令1: 从内存中读取 count

指令2:将 count +1

指令3:将新计算的count值,写回内存

我们将这个count++ 操作和线程切换进行结合

count++ 线程切换

这里才是真正解答了最开始为什么是 100万到200之间的随机数。

解决 原子性问题的方法有很多,比如锁
C# 并发编程_第7张图片

3.2 lock

加锁这个代码我就暂且忽略,因为lock我们并不陌生。

但是需要明白一点,lock() 是微软提供给我们的语法糖,其实最终使用的是 Monitor,并且做了异常和资源处理。
C# 并发编程_第8张图片

lock

CLR 锁原理

C# 并发编程_第9张图片

多个线程访问同一个实例下的共享变量,同时将同步块索引从 -1 改成CLR维护的同步块数组,

用完就会将实例的同步快变成-1

3.3 Monitor

上面提到了隐姓埋名的Monitor,其实我们也可以抛头露面地使用Monitor

这里也不具体细说。具体使用可以参照上面图片。

3.4 System.Threading.Interlocked

官方定义:原子性的简单操作,累加值,改变值等

区区 count++ 使用lock 有点浪费,我们使用更加轻量级的 Interlocked,

为我们的 count ++ 保驾护航。

public class ThreadTest_V3
    {
        public volatile int count = 0;
        public void Add1()
        {
            int index = 0;
            while (index++ < 1000000)//100万次
            {
                Interlocked.Add(ref count, 1);
            }
        }

        public void Add2()
        {
            int index = 0;
            while (index++ < 1000000)//100万次
            {
                Interlocked.Add(ref count, 1);
            }
        }
    }

结果不多说,依然稳稳的 200万。

3.5 System.Threading.SpinLock结构

自旋锁结构,可以这样理解。

多线程访问共享资源时,只有一个线程可以拿到锁,其他线程都在原地等待,

直到这个锁被释放,原地等待的资源又一次进行抢占,以此类推。

在具体使用 System.Threading.SpinLock结构 之前,我们根据刚刚讲过的 System.Threading.Interlocked,进行一下改造:

public struct Spin
    {
        private int m_lock;//0=unlock ,1=lock
        public void Enter()
        {
            while (System.Threading.Interlocked.Exchange(ref m_lock, 1) != 0)
            {
                //可以限制自旋次数和时间,自动断开退出
            }
        }

        public void Exit()
        {
            System.Threading.Interlocked.Exchange(ref m_lock, 0);
        }
    }
public class ThreadTest_V4
    {
        private Spin spin = new Spin();
        public volatile int count = 0;
        public void Add1()
        {
            int index = 0;
            while (index++ < 1000000)//100万次
            {
                spin.Enter();
                count++;
                spin.Exit();
            }
        }

        public void Add2()
        {
            int index = 0;
            while (index++ < 1000000)//100万次
            {
                spin.Enter();
                count++;
                spin.Exit();
            }
        }
    }

Enter() , m_lock 从0到1,就是加锁;

锁的是共享资源 count;

其他线程原地自旋等待(循环)

Exit(),m_lock 从1到0,就是解锁;

System.Threading.SpinLock 结构和以上实现思想类似。

后面的内容就简单提一下定义和应用场景,有必要的就可以单独细查。

3.6 System.Threading.SpinWait结构

提供了基于自旋等待支援。
在线程必须等待发出事件信号或满足条件时方可使用.

3.7 System.Threading.ReaderWriterLockSlim类

授予独占访问共享资源的写作,
并允许多个线程同时访问资源进行读取。

3.8 CAS

cas 核心思想:
将 count 从内存读取出来并赋值给一个局部变量,叫做 originalData;

然后这个局部变量 +1 并赋值给新值,叫做 newData;

再次从内存中将count读取出来,如果originalData ==count,

说明没有线程修改内存中count值,可以将新值存储到内存中。

反之则可以选择自旋或者其他策略。

当然还有进程之间的同步,这里就不一一展开说了。
总结一下:
并发三要素 可见性、有序性、原子性

几种锁原理和CAS操作

你可能感兴趣的:(C#,多线程,c#,java,spring)