Linux C、C++编程之线程同步

【图书推荐】《Linux C与C++一线开发实践（第2版）》_linux c与c++一线开发实践pdf-CSDN博客



《Linux C与C++一线开发实践（第2版）（Linux技术丛书）》(朱文伟，李建英)【摘要 书评 试读】- 京东图书 (jd.com)

多个线程可能在同一时间对同一共享资源进行操作，其结果是某个线程无法获得资源，或者会导致资源的破坏。为保证共享资源的稳定性，需要采用线程同步机制来调整多个线程的执行顺序，比如可以用一把“锁”，一旦某个线程获得了锁的拥有权，即可保证只有它（拥有锁的线程）才能对共享资源进行操作。同样地，利用这个锁，其他线程可一直处于等待状态，直到锁没有被任何线程拥有为止。

异步是当一个调用或请求发给被调用者时，调用者不用等待其结果的返回而继续当前的处理。实现异步机制的方式有多线程、中断和消息等。也就是说，多线程是实现异步的一种方式。C++11对异步的支持丝毫不弱。

并发和异步机制带来了线程间资源竞争的无序性，因此需要引入同步机制来消除这种复杂度，实现线程间正确有序地共享数据，以一致的顺序执行一组操作。

线程同步是多线程编程中的重要概念。它的基本思想是同步各个线程对资源（比如全局变量、文件）的访问。如果不对资源访问进行线程同步，则会产生资源访问冲突的问题。对于多线程程序，访问冲突的问题是很普遍的，解决的办法是引入锁（比如互斥锁、读写锁等），获得锁的线程可以完成“读-修改-写”的操作，然后释放锁给其他线程，没有获得锁的线程只能等待而不能访问共享数据，这样“读-修改-写”3步操作组成一个原子操作，要么都执行，要么都不执行，不会执行到中间被打断，也不会在其他处理器上并行做这个操作。

比如，一个线程正在读取一个全局变量，虽然读取全局变量的这条语句在C/C++源码中是一条语句，但编译为机器代码后，CPU需要用多条指令来处理这个读取变量的过程。如果这一系列指令被另一个线程打断了，也就是说CPU还没执行完读取变量的所有指令而去执行另一个线程了，另一个线程却要对这个全局变量进行修改，并将修改后的全局变量返回原先的线程，这样CPU继续执行读取变量的指令时，变量的值已经改变了，如此第一个线程的执行结果就不是预料的结果了。

我们来看一个对于多线程访问共享变量造成竞争的例子，假设增量操作分为以下3个步骤：

（1）从内存单元读入寄存器。

（2）在寄存器中进行变量值的增加。

（3）把新的值写回内存单元。

那么当两个线程对同一个变量做增加操作时，就可能出现如图9-1所示的情况。

图9-1

如果两个线程在串行操作下分别对i进行了累加，那么i的值就应该是7了，但图9-1的两个线程执行后的i值是6。因为线程B并没有等线程A做完i+1后才开始执行，而是在线程A刚刚把i从内存读入寄存器后就开始执行了，所以线程B也是在i=5的时候开始执行的，这样线程A的执行结果是6，线程B的执行结果也是6。因此，在这种没有做同步的情况下，多个线程对全局变量进行累加，最终结果是小于或等于它们的串行操作结果的。请看下例。

【例9.1】不用线程同步的多线程累加

（1）打开Visual Studio Code，新建一个test.cpp文件，在test.cpp中输入代码：

#include <stdio.h>
#include <unistd.h>
#include <pthread.h>
#include <sys/time.h> 
#include <string.h>
#include <cstdlib>
 
int gcn = 0; 							// 定义一个全局变量，用于累加
  
void *thread_1(void *arg) {    			// 第一个线程
	int j;
	for (j = 0; j < 10000000; j++) {  	// 开始累加
		gcn++;
	}  
	pthread_exit((void *)0);
}

void *thread_2(void *arg) {    			// 第二个线程
	int j;
	for (j = 0; j < 10000000; j++) {  	// 开始累加
		gcn++; 
	}  
	pthread_exit((void *)0);
}
int main(void) 
{
	int j,err;
	pthread_t th1, th2;
	 
	for (j = 0; j < 10; j++)  			// 做10次
	{
		err=pthread_create(&th1, NULL, thread_1, (void *)0);// 创建第一个线程
		if (err != 0) {
			printf("create new thread error:%s\n", strerror(err));
			exit(0);
		}  
		err = pthread_create(&th2, NULL, thread_2,(void *)0);// 创建第二个线程
		if (err != 0) {
			printf("create new thread error:%s\n", strerror(err));
			exit(0);
		}  
           
		err = pthread_join(th1, NULL);  // 等待第一个线程结束
		if (err != 0) {
			printf("wait thread done error:%s\n", strerror(err));
			exit(1);
		}
		err = pthread_join(th2, NULL);  // 等待第二个线程结束
		if (err != 0) {
			printf("wait thread done error:%s\n", strerror(err));
			exit(1);
		}
		printf("gcn=%d\n", gcn);
		gcn = 0;
	}

	return 0;
}

（2）上传test.cpp到Linux，在终端下输入命令g++ -o test test.cpp -lpthread，其中pthread是线程库的名字，然后运行test，运行结果如下：

[root@localhost cpp98]# ./test
gcn=17945938
gcn=20000000
gcn=20000000
gcn=20000000
gcn=20000000
gcn=20000000
gcn=20000000
gcn=15315061
gcn=20000000
gcn=16248825

从结果中可以看到，有3次没有达到20 000 000。

上面的例子是一个语句被打断的情况，有时候还会有一个事务不能被打断。比如，一个事务需要多条语句完成，并且不可打断，如果打断的话，其他需要这个事务结果的线程则可能会得到非预料的结果。下面我们再看一个例子，有这样一个需求，伙计在卖商品时，每次卖出50元的货物就要收50元的钱，老板每隔1秒就要去清点店里的货物和金钱的总和，看总和有没有少。我们可以创建两个线程，一个线程代表伙计卖货收钱这个事务，另一个线程模拟老板验证总和的操作。抽象地讲，就是一个线程对全局变量进行写操作，另一个线程对全局变量进行读操作。

【例9.2】不用线程同步的卖货程序

（1）打开Visual Studio Code，新建一个test.cpp文件，在test.cpp中输入代码：

#include <stdio.h>
#include <unistd.h>
#include <pthread.h>
 
int a = 200; 						// 代表有价值200元的货物
int b = 100; 						// 代表现在有100元现金
 
void* ThreadA(void*) 				// 模拟伙计卖货收钱
{
	while (1)
	{
		a -= 50; 					// 卖出价值50元的货物 
		b += 50;					// 收回50元钱
	}
}
 
void* ThreadB(void*) 				// 模拟老板对账
{
	while (1)
	{
		printf("%d\n", a + b); 		// 打印当前货物和现金的总和
		sleep(1);    				// 隔1秒
	}
}
 
int main()
{
	pthread_t tida, tidb;
 
	pthread_create(&tida, NULL, ThreadA, NULL); 	// 创建伙计卖货线程
	pthread_create(&tidb, NULL, ThreadB, NULL); 	// 创建老板对账线程
	pthread_join(tida, NULL); 						// 等待线程结束
	pthread_join(tidb, NULL); 						// 等待线程结束
	return 1;
}

（2）上传test.cpp到Linux，在终端下输入命令g++ -o test test.cpp -lpthread，其中pthread是线程库的名字，然后运行test，运行结果如下：

[root@localhost cpp98]# ./test
300
250
250
300
250
300
250
^C
[root@localhost cpp98]#

按Ctrl+C快捷键后程序停止。在这个例子中，线程B每隔1秒就检查一下当前货物和现金的总和是否是300，以此来判断伙计是否私吞钱款。伙计虽然在卖力地卖货和收钱，但无奈还是出现了250，真是有口难辩啊。发生这种情况的原因是伙计在卖出货物和收货款之间被老板的对账线程打断了。下面我们用互斥锁来帮伙计证明清白。

在讲述互斥锁之前，我们首先要了解一下临界资源和临界区（Critical Section）的概念。所谓临界资源，是一次仅允许一个线程使用的共享资源。对于临界资源，各线程应该互斥地对它进行访问。每个线程中访问临界资源的那段代码称为临界区，又称临界段。因为临界资源要求每个线程互斥地对它进行访问，所以每次只准许一个线程进入临界区，进入后其他进程不允许再进入，一直要等到临界区中的线程退出。我们可以用线程同步机制来互斥地进入临界区。

一般来讲，线程进入临界区需要遵循下列原则：

（1）如果有若干线程要求进入空闲的临界区，一次仅允许一个线程进入。

（2）任何时候，处于临界区内的线程不可多于1个。若已有线程进入自己的临界区，则其他所有试图进入临界区的线程必须等待。

（3）进入临界区的线程要在有限时间内退出，以便其他线程能及时进入自己的临界区。

（4）如果进程不能进入自己的临界区，则应让出CPU（阻塞），避免进程出现“忙等”现象。