锋Syf

C++11 多线程：数据保护

转载 fjb2080 最后发布于2012-07-04 11:33:06 阅读数 1018 收藏

发布于2012-07-04 11:33:06

分类专栏： C/C++

收起

转自：http://www.oschina.net/question/12_59878

编写多线程程序时，多个线程同时访问某个共享资源，会导致同步的问题，这篇文章中我们将介绍 C++11 多线程编程中的数据保护。

数据丢失

让我们从一个简单的例子开始，请看如下代码：

 
         01 
         #include  
        
         02 
         #include  
        
         03 
         #include  
        
         04 
         #include  
        
         05 
           
         06 
         using std::thread; 
        
         07 
         using std::vector; 
        
         08 
         using std::cout; 
        
         09 
         using std::endl; 
        
         10 
           
         11 
         class Incrementer 
        
         12 
         { 
        
         13 
             private: 
        
         14 
                 int counter; 
        
         15 
           
         16 
             public: 
        
         17 
                 Incrementer() : counter{0} { }; 
        
         18 
           
         19 
                 void operator()() 
        
         20 
                 { 
        
         21 
                     for(int i = 0; i < 100000; i++) 
        
         22 
                     { 
        
         23 
                         this->counter++; 
        
         24 
                     } 
        
         25 
                 } 
        
         26 
           
         27 
                 int getCounter() const 
        
         28 
                 { 
        
         29 
                     return this->counter; 
        
         30 
                 }        
        
         31 
         }; 
        
         32 
           
         33 
         int main() 
        
         34 
         { 
        
         35 
             // Create the threads which will each do some counting 
        
         36 
             vector<thread> threads; 
        
         37 
           
         38 
             Incrementer counter; 
        
         39 
           
         40 
             threads.push_back(thread(std::ref(counter))); 
        
         41 
             threads.push_back(thread(std::ref(counter))); 
        
         42 
             threads.push_back(thread(std::ref(counter))); 
        
         43 
           
         44 
             for(auto &t : threads) 
        
         45 
             { 
        
         46 
                 t.join(); 
        
         47 
             } 
        
         48 
           
         49 
             cout << counter.getCounter() << endl; 
        
         50 
           
         51 
             return 0; 
        
         52 
         }

这个程序的目的就是数数，数到30万，因此创建了三个线程，使用一个共享变量 counter，每个线程负责给这个变量增加10万计数。

这段代码创建了一个名为 Incrementer 的类，该类包含一个私有变量 counter，其构造器非常简单，只是将 counter 设置为 0.

紧接着是一个操作符重载，这意味着这个类的每个实例都是被当作一个简单函数来调用的。一般我们调用类的某个方法时会这样 object.fooMethod()，但现在你实际上是直接调用了对象，如 object(). 因为我们是在操作符重载函数中将整个对象传递给了线程类。最后是一个 getCounter 方法，返回 counter 变量的值。

再下来是程序的入口函数 main()，我们创建了三个线程，不过只创建了一个 Incrementer 类的实例，然后将这个实例传递给三个线程，注意这里使用了 std::ref ，这相当于是传递了实例的引用对象，而不是对象的拷贝。

现在让我们来看看程序执行的结果，使用 GCC 4.7 或者更新版本，或者是 Clang 3.1 来进行编译，编译方法：

 
         1 
         g++ -std=c++11 -lpthread -o threading_example main.cpp

运行结果：

 
         01 
         [lucas@lucas-desktop src]$ ./threading_example  
        
         02 
         218141 
        
         03 
         [lucas@lucas-desktop src]$ ./threading_example  
        
         04 
         208079 
        
         05 
         [lucas@lucas-desktop src]$ ./threading_example  
        
         06 
         100000 
        
         07 
         [lucas@lucas-desktop src]$ ./threading_example  
        
         08 
         202426 
        
         09 
         [lucas@lucas-desktop src]$ ./threading_example  
        
         10 
         172209

但等等，不对啊，程序并没有数数到30万，有一次居然只数到10万，为什么会这样呢？好吧，加1操作对应实际的处理器指令其实包括：

 
         1 
         movl    counter(%rip), %eax 
        
         2 
         addl    $1, %eax 
        
         3 
         movl    %eax, counter(%rip)

首个指令将装载 counter 的值到 %eax 寄存器，紧接着寄存器的值增1，然后将寄存器的值移给内存中 counter 所在的地址。

我听到你在嘀咕：这不错，可为什么会导致数数错误的问题呢？嗯，还记得我们以前说过线程会共享处理器，因为只有单核。因此在某些点上，一个线程会依照指令执行完成，但在很多情况下，操作系统会对线程说：时间结束了，到后面排队再来，然后另外一个线程开始执行，当下一个线程开始执行时，它会从被暂停的那个位置开始执行。所以你猜会发生什么事，当前线程正准备执行寄存器加1操作时，系统把处理器交给另外一个线程？

我真的不知道会发生什么事，可能我们在准备加1时，另外一个线程进来了，重新将 counter 值加载到寄存器等多种情况的产生。谁也不知道到底发生了什么。

正确的做法

解决方案就是要求同一个时间内只允许一个线程访问共享变量。这个可通过 std::mutex 类来解决。当线程进入时，加锁、执行操作，然后释放锁。其他线程想要访问这个共享资源必须等待锁释放。

互斥(mutex) 是操作系统确保锁和解锁操作是不可分割的。这意味着线程在对互斥量进行锁和解锁的操作是不会被中断的。当线程对互斥量进行锁或者解锁时，该操作会在操作系统切换线程前完成。

而最好的事情是，当你试图对互斥量进行加锁操作时，其他的线程已经锁住了该互斥量，那你就必须等待直到其释放。操作系统会跟踪哪个线程正在等待哪个互斥量，被堵塞的线程会进入 "blocked on m" 状态，意味着操作系统不会给这个堵塞的线程任何处理器时间，直到互斥量解锁，因此也不会浪费 CPU 的循环。如果有多个线程处于等待状态，哪个线程最先获得资源取决于操作系统本身，一般像 Windows 和 Linux 系统使用的是 FIFO 策略，在实时操作系统中则是基于优先级的。

现在让我们对上面的代码进行改进：

 
         01 
         #include  
        
         02 
         #include  
        
         03 
         #include  
        
         04 
         #include  
        
         05 
         #include  
        
         06 
           
         07 
         using std::thread; 
        
         08 
         using std::vector; 
        
         09 
         using std::cout; 
        
         10 
         using std::endl; 
        
         11 
         using std::mutex; 
        
         12 
           
         13 
         class Incrementer 
        
         14 
         { 
        
         15 
             private: 
        
         16 
                 int counter; 
        
         17 
                 mutex m; 
        
         18 
           
         19 
             public: 
        
         20 
                 Incrementer() : counter{0} { }; 
        
         21 
           
         22 
                 void operator()() 
        
         23 
                 { 
        
         24 
                     for(int i = 0; i < 100000; i++) 
        
         25 
                     { 
        
         26 
                         this->m.lock(); 
        
         27 
                         this->counter++; 
        
         28 
                         this->m.unlock(); 
        
         29 
                     } 
        
         30 
                 } 
        
         31 
           
         32 
                 int getCounter() const 
        
         33 
                 { 
        
         34 
                     return this->counter; 
        
         35 
                 }     
        
         36 
         }; 
        
         37 
           
         38 
         int main() 
        
         39 
         { 
        
         40 
             // Create the threads which will each do some counting 
        
         41 
             vector<thread> threads; 
        
         42 
           
         43 
             Incrementer counter; 
        
         44 
           
         45 
             threads.push_back(thread(std::ref(counter))); 
        
         46 
             threads.push_back(thread(std::ref(counter))); 
        
         47 
             threads.push_back(thread(std::ref(counter))); 
        
         48 
           
         49 
             for(auto &t : threads) 
        
         50 
             { 
        
         51 
                 t.join(); 
        
         52 
             } 
        
         53 
           
         54 
             cout << counter.getCounter() << endl; 
        
         55 
           
         56 
             return 0; 
        
         57 
         }

注意代码上的变化：我们引入了 mutex 头文件，增加了一个 m 的成员，类型是 mutex，在 operator()() 中我们锁住互斥量 m 然后对 counter 进行加1操作，然后释放互斥量。

再次执行上述程序，结果如下：

 
         1 
         [lucas@lucas-desktop src]$ ./threading_example  
        
         2 
         300000 
        
         3 
         [lucas@lucas-desktop src]$ ./threading_example  
        
         4 
         300000

这下数对了。不过在计算机科学中，没有免费的午餐，使用互斥量会降低程序的性能，但这总比一个错误的程序要强吧。

防范异常

当对变量进行加1操作时，是可能会发生异常的，当然在我们这个例子中发生异常的机会微乎其微，但是在一些复杂系统中是极有可能的。上面的代码并不是异常安全的，当异常发生时，程序已经结束了，可是互斥量还是处于锁的状态。

为了确保互斥量在异常发生的情况下也能被解锁，我们需要使用如下代码：

 
         01 
         for(int i = 0; i < 100000; i++) 
        
         02 
          { 
        
         03 
          this->m.lock(); 
        
         04 
          try 
        
         05 
          { 
        
         06 
              this->counter++; 
        
         07 
              this->m.unlock(); 
        
         08 
          } 
        
         09 
          catch(...) 
        
         10 
          { 
        
         11 
              this->m.unlock(); 
        
         12 
              throw; 
        
         13 
          } 
        
         14 
          }

但是，这代码太多了，而只是为了对互斥量进行加锁和解锁。没关系，我知道你很懒，因此推荐个更简单的单行代码解决方法，就是使用 std::lock_guard 类。这个类在创建时就锁定了 mutex 对象，然后在结束时释放。

继续修改代码：

 
         01 
         void operator()() 
        
         02 
         { 
        
         03 
             for(int i = 0; i < 100000; i++) 
        
         04 
             { 
        
         05 
             lock_guard lock(this->m); 
        
         06 
           
         07 
             // The lock has been created now, and immediatly locks the mutex 
        
         08 
             this->counter++; 
        
         09 
           
         10 
             // This is the end of the for-loop scope, and the lock will be 
        
         11 
             // destroyed, and in the destructor of the lock, it will 
        
         12 
             // unlock the mutex 
        
         13 
             } 
        
         14 
         }

上面代码已然是异常安全了，因为当异常发生时，将会调用 lock 对象的析构函数，然后自动进行互斥量的解锁。

记住，请使用放下代码模板来编写：

`01`	`void` `long_function()`

02 {

`03`	`// some long code`

04

`05`	`// Just a pair of curly braces`

06 {

`07`	`// Temp scope, create lock`

`08`	`lock_guard lock(this->m);`

09

`10`	`// do some stuff`

11

`12`	`// Close the scope, so the guard will unlock the mutex`

13 }

14 }


        
            
                
                                        
                                
            
                                    fjb2080
                                        
                发布了202 篇原创文章 · 获赞 122 · 访问量 150万+
            
                            
                                        他的留言板
                    
                                                        关注

发表评论

还能输入1000个字符

		
		
			
				
					关注
山庄来客  
 224篇文章
 排名:5000+
关注
chenm91  
 7篇文章
 排名:千里之外
关注
苦逼的IT男  
 165篇文章
 排名:千里之外
关注
稚枭天卓  
 597篇文章
 排名:953


	
		
			
				
					05.多线程数据保护(安全队列2					
				01-13
			
			
					05.多线程数据保护(安全队列2				
			下载

分类专栏

CI 5篇
VC 3篇
小马技术-Vue.js入门教学 3篇
BIOS 3篇
boost 2篇
C/C++ 85篇
gcc
linux 67篇
MeeGo 3篇
QT 54篇
QT浏览器 2篇
WINDOWS 24篇
个人作品 17篇
大话人生 8篇
实战DeviceIoControl 7篇
数据恢复 20篇
计算机技术 18篇
设计模式 3篇
汇编 1篇
loki 1篇
Linux Shell 9篇
vim
C++11 30篇
WEB技术 60篇
PHP 48篇
python 1篇
js 12篇
virus 1篇

展开

C++11 多线程：数据保护

C++11 多线程：数据保护

数据丢失

正确的做法

防范异常

山庄来客

chenm91

苦逼的IT男

稚枭天卓

最新文章

分类专栏

归档

热门文章

最新评论

你可能感兴趣的:(C++,C/C++)

C++11 多线程：数据保护

C++11 多线程：数据保护

数据丢失

正确的做法

防范异常

多线程中数据的并发访问与保护

多线程编程的关键是要保护数据

thread类使用笔记

C++ push方法与push_back方法 浅析

多线程共享数据保护

C++多线程Thread的使用

线程池 将任务push_back到list中的问题

C++ 多线程的数据保护机制

C++ 多线程并发控制——互斥锁 pthread_mutex

C++应用多线程提高并发性

C++多线程编程视频教程（C++11多线程并发）

山庄来客

chenm91

苦逼的IT男

稚枭天卓

Java中实现多线程并发的几种安全机制

C++11 并发编程教程 - Part 1 : thread 初探

C++11并发编程（一）——初始C++11多线程库

C++11 并发与多线程（一）

多线程访问数据库时应该怎么进行临界区保护呢？

05.多线程数据保护(安全队列2

C++并发编程2——为保护数据加锁（一）

CVI多线程数据保护（多个线程操作同一安全变量）

最新文章

分类专栏

归档

热门文章

最新评论

你可能感兴趣的:(C++,C/C++)

C++ push方法与push_back方法浅析

线程池将任务push_back到list中的问题