.NET 4并行编程之共享数据问题和解决概述

开发 后端
本文介绍的是.NET 4并行编程中应该会遇到的一些问题,包括共享数据之间的竞争,以及数据不变的解决方案。

之前的文章介绍了了并行编程的一些基础的知识,从本篇开始,将会讲述并行编程中实际遇到一些问题,接下来的几篇将会讲述数据共享问题。

[[12166]]498)this.style.width=498;">

本篇的议题如下:      

1.数据竞争

2.解决方案提出

3.顺序的执行解决方案

4.数据不变解决方案

在开始之前,首先,我们来看一个很有趣的例子:

  1. class BankAccount  
  2. {  
  3.     public int Balance  
  4.     {  
  5.         get;  
  6.         set;  
  7.     }  
  8. }  
  9. class App  
  10. {  
  11.     static void Main(string[] args)  
  12.     {  
  13.         // create the bank account instance  
  14.         BankAccount account = new BankAccount();  
  15.         // create an array of tasks  
  16.         Task[] tasks = new Task[10];  
  17.         for (int i = 0; i < 10; i++)  
  18.         {  
  19.             // create a new task  
  20.             tasks[i] = new Task(() =>  
  21.             {  
  22.                 // enter a loop for 1000 balance updates  
  23.                 for (int j = 0; j < 1000; j++)  
  24.                 {  
  25.                     // update the balance  
  26.                     account.Balance = account.Balance + 1;  
  27.                 }  
  28.             });  
  29.             // start the new task  
  30.             tasks[i].Start();  
  31.         }  
  32.  
  33.         // wait for all of the tasks to complete  
  34.         Task.WaitAll(tasks);  
  35.  
  36.         // write out the counter value  
  37.         Console.WriteLine("Expected value {0}, Counter value: {1}",  
  38.         10000, account.Balance);  
  39.  
  40.         // wait for input before exiting  
  41.         Console.WriteLine("Press enter to finish");  
  42.         Console.ReadLine();  
  43.     }  

10个task,每个task都是把BankAccount.Balance自增1000次。之后代码就等到10个task执行完毕,然后打印出Balance的值。大家猜想一下,上次的代码执行完成之后,打印出来的Balance的结果是多少?

J结果确实和大家猜想的一样:结果不等于10000。每次执行一次上面的代码,都会得到不同的结果,而且这些结果值都在10000左右,如果运气好,可能看到有那么一两次结果为10000.为什么会这样?

下面就是本篇和接下来的几篇文章要讲述的内容。

1.数据竞争

如果大家对多线程编程比较熟悉,就知道上面情况的产生是因为 “共享数据竞争”导致的(对多线程不熟悉不清楚的朋友也不用担心)。当有两个或者更多的task在运行并且操作同一个共享公共数据的时候,就存在潜在的竞争。如果不合理的处理竞争问题,就会出现上面意想不到的情况。

下面就来分析一下:上面代码的情况是怎么产生的。

当在把account对象的Balance进行自增的时候,一般执行下面的三个步骤:

  1. 读取现在account对象的Balance属性的值。
  2. 计算,创建一个临时的新变量,并且把Balance属性的值赋值给新的变量,而且把新变量的值增加1
  3. 把新变量的值再次赋给account的Balance属性

在理论上面,上面的三个步骤是代码的执行步骤,但是实际中,由于编译器,.NET 运行时对自增操作的优化操作,和操作系统等的因素,在执行上面代码的时候,并不一定是按照我们设想的那样运行的,但是为了分析的方便,我们还是假设代码是按照上面的三个步骤运行的。

之前的代码每次执行一次,执行代码的计算机就每次处于不同的状态:CPU的忙碌状况不同,内存的剩余多少不同,等等,所以每次代码的运行,计算机不可能处于完全一样的环境中。

在下面的图中,显示了两个task之间是如何发生竞争的。当两个task启动了之后(虽然说是并行运算,但是不管这样,两个的task的执行时间不可能完全一样,也就是说,不可能恰好就是同时开始执行的,起码在开始执行的时间上是有一点点的差异的)。

架构差异

1.    首先Task1读取到当前的balance的值为0。

2.    然后,task2运行了,并且也读取到当前的balance值为0。

3.    两个task都把balance的值加1

4.    Task1把balance的值加1后,把新的值保存到了balance中

5.    Task2 也把新的保存到了balance中

所以,结果就是:虽然两个task 都为balance加1,但是balance的值还是1。

通过这个例子,相信大家应该清楚,为什么上面的10个task执行1000,而执行后的结果不是10000了。 

2.  解决方案提出

数据竞争就好比一个生日party。其中,每一个task都是参加party的人,当生日蛋糕出来之后,每个人都兴奋了。如果此时,所有的人都一起冲过去拿属于他们自己的那块蛋糕,此时party就一团糟了,没有如何顺序。

在之前的图示例讲解中,balance那个属性就好比蛋糕,因为task1,task2都要得到它,然后进行运算。当我们来让多个task共享一个数据时就可能出现问题。下面列出了四种解决方案:

1.    顺序执行:也就是让第一个task执行完成之后,再执行第二个。

2.    数据不变:我们让task不能修改数据。

3.    隔离:我们不共享数据,让每个task都有一份自己的数据拷贝。

4.    同步:通过调整task的执行,有序的执行task。

注意:同步和以前多线程中的同步,或者数据库操作时的同步概念不一样

3.顺序的执行的解决方案

顺序的执行解决了通过每次只有一个task访问共享数据的方式解决了数据竞争的问题,其实在本质上,这种解决方案又回到了之前的单线程编程模型。如果拿之前的party分蛋糕的例子,那么现在就是一次只能允许一个人去拿蛋糕。

4.数据不变解决方案

数据不变的解决方案就是通过让数据不能被修改的方式来解决共享数据竞争。如果拿之前的蛋糕为例子,那么此时的情况就是:现在蛋糕只能看,不能吃。

在C#中,可以同关键字 readonly 和 const来声明一个字段不能被修改:

public const int AccountNumber=123456;

被声明为const的字段只能通过类型来访问:如,上面的AccountNumber是在Blank类中声明的,那么访问的方式就是Blank. AccountNumber

readonly的字段可以在实例的构造函数中修改。

如下代码:

  1. using System;  
  2.  
  3. class ImmutableBankAccount  
  4. {  
  5.     public const int AccountNumber = 123456;  
  6.     public readonly int Balance;  
  7.     public ImmutableBankAccount(int InitialBalance)  
  8.     {  
  9.         Balance = InitialBalance;  
  10.     }  
  11.     public ImmutableBankAccount()  
  12.     {  
  13.         Balance = 0;  
  14.     }  
  15. }  
  16.  
  17. class App  
  18. {  
  19.     static void Main(string[] args)  
  20.     {  
  21.         // create a bank account with the default balance  
  22.         ImmutableBankAccount bankAccount1 = new ImmutableBankAccount();  
  23.         Console.WriteLine("Account Number: {0}, Account Balance: {1}",  
  24.  
  25.         ImmutableBankAccount.AccountNumber, bankAccount1.Balance);  
  26.  
  27.         // create a bank account with a starting balance  
  28.         ImmutableBankAccount bankAccount2 = new ImmutableBankAccount(200);  
  29.         Console.WriteLine("Account Number: {0}, Account Balance: {1}",  
  30.         ImmutableBankAccount.AccountNumber, bankAccount2.Balance);  
  31.  
  32.         // wait for input before exiting  
  33.         Console.WriteLine("Press enter to finish");  
  34.         Console.ReadLine();  
  35.     }  

数据不变的解决方案不是很常用,因为它对数据限制太大了。

原文标题:.NET 并行(多核)编程系列之七 共享数据问题和解决概述 

链接:http://www.cnblogs.com/yanyangtian/archive/2010/06/24/1764098.html

【编辑推荐】

  1. 微软发布新版Windows 7及.NET 4软件开发工具包
  2. 详解.NET 4.0并行计算支持历史
  3. 详读.NET 4.0环境配置
  4. 详解.NET 4.0中异常处理方面的新特性
  5. 三方面诠释.NET 4.0的新特性
责任编辑:彭凡 来源: 博客园
相关推荐

2010-06-11 09:01:02

.NET 4并行编程

2010-06-02 08:53:51

.NET 4并行编程

2010-06-04 09:11:10

.NET并行编程

2010-06-07 08:43:46

.NET 4并行编程

2010-06-08 08:41:08

.NET 4并行编程

2021-03-05 07:38:52

C++线程编程开发技术

2009-07-22 17:45:35

ASP.NET教程

2010-06-09 09:18:34

.NET 4并行编程

2020-05-09 22:54:48

物联网安全物联网IOT

2009-06-29 09:38:50

JSF标签JSF

2015-10-13 09:18:00

.Net编程教程

2020-03-11 09:57:10

数据安全网络安全网络攻击

2011-06-22 10:20:11

QT 鼠标 拖放

2011-03-31 16:45:39

Redhat配置nagios

2013-07-30 14:00:46

.NET数据类型

2018-03-09 16:27:50

数据库Oracle同步问题

2012-03-09 10:44:11

Java

2022-03-31 10:25:20

物联网工业 4.0大数据分析

2023-10-16 16:08:42

工业 4.0物联网边缘计算

2017-03-24 17:18:30

点赞
收藏

51CTO技术栈公众号