三个线程同步中一个纠结的问题

最新推荐文章于 2022-11-12 12:15:33 发布
原创 最新推荐文章于 2022-11-12 12:15:33 发布 · 2.5k 阅读 · 1 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

前几天一直没想明白，搜索我的记忆海，愣是没找到这种三个线程相交互的！

 

1、问题描述

目前有三个class

WriteDB他主要负责把网页的信息写到数据中(间隔5分钟)，每次更新之后都会他会相应的把DataOperation中的变量isDataUpdate_设置为true；

Search他负责处理对用户执行查询信息的操作，当有用户执行Search，他会相应的把DataOperation中的变量isUserSearch_设置为true；

DataOperation这是一个中间的类，负责做类WriteDB和类Search的同步操作，会一直检查这两个变量isDataUpdate_和isUserSearch_，当他们都为false的时候，把最新在内存中的数据库写入到对应的文件中，以便能够查询最新的信息，如果其中一个为true，他都等待。

 

2、迷糊的那段时间

也就是前几天，一直在想，怎么能实现上面的东西！一直被WriteDB这个class和isUserSearch_(bool类型)所困扰！

还写出来类似第一版的DataOperation代码：

class DataOperation
{
public:

	DataOperation()
	{
		running_flag = true;
		isDataUpdate_ = false;
		isUserSearch_ = false;
	}

	void Stop()
	{
		running_flag = false;
		{
			boost::recursive_mutex::scoped_lock lock(mtx);
			cond.notify_one();
		}
	}

	void EmitSignalThread()
	{
		while (running_flag)
		{
			if (isSearchEnd_)
			{
				break;
			}

			{
				boost::recursive_mutex::scoped_lock lock(mtx);

				if (IsReplaceDB())
				{
					// 需要替换数据库
					for (int i = 0; i <= 999; i++)
					{
						cout << "正在替换数据库" << i << endl;
					}
				}

				cond.notify_all();
			}
			boost::this_thread::sleep(boost::posix_time::millisec(1000));
		}
	}

	// 当后台有数据要更新，并且目前没有用户进行search的时候replace
	// 返回true表明正在进行，false表示还需要等待
	bool IsReplaceDB()
	{	
		return (isDataUpdate_ && isUserSearch_);
	}

	// 这个会阻塞
	void WaitReplaceDB()
	{
		boost::recursive_mutex::scoped_lock lock(mtx);
		cout << "如果程序没有动静，那么表明此刻正在更新数据库...等待几秒即可！" << endl;
		cond.wait(mtx);
		boost::this_thread::sleep(boost::posix_time::millisec(100));
	}

	void SetIsDataUpdate(bool isDataUpdate = true)
	{
		isDataUpdate_ = isDataUpdate;
	}

	void SetIsUserSearch(bool isUserSearch = true)
	{
		isUserSearch_ = isUserSearch;
	}

	void SetIsSearchEnd(bool isSearchEnd = false)
	{
		isSearchEnd_ = isSearchEnd;
	}

	bool GetIsSearchEnd()
	{
		return isSearchEnd_;
	}

private:
	bool running_flag;		// 数据助手是否需要存活
	bool isDataUpdate_;		// 数据是否有更新
	bool isUserSearch_;		// 当前是否有用户正在查询
	bool isSearchEnd_;		// 程序是否已经退出
	boost::recursive_mutex mtx;
	boost::condition_variable_any cond;
};

3、困扰的原因

我一直在想，以前的生产者和消费者是怎么做的？有没有想过还带有条件变量的？

 

4、能不能更简单

比如我就想过，只在DataOperation类中检测这两个bool变量，如果满足则更新DB，不满足Sleep；最终发现也有漏洞，毕竟这么做了Search中也要对应检测DB当前是否在更新，更新就Sleep----举一个极端的例子，但是是很可能发生：当前DataOperation发现没有用户在执行查询，那么DataOperation去设置标记(表面将要去更新数据库)，当在设置标记的时候，用户更好输入了查询，发现数据库没在更新，那么就会造成同时出现DataOperation正在更新数据库、用户正在查询的情况！那么此时系统就会崩溃了。

 

5、所以说

条件变量、互斥量是确实有存在的意义的！

 

6、再来看一下整体的设计

从作用来看WriteDB只是自己做自己的，并不和多线程的同步有关，他仅仅是每次都设置isDataUpdate_为true就行；剩下的同步仅在于Search和Dataoperation中，bool isUserSearch_;和bool isSearchEnd_;都没有实际的存在价值；只需要把isUserSearch_设置为条件变量就行。这样前面的两个bool变量的功能就被取代了(同时提一下，原来的条件变量，在这里才真正的用起来)

 

7、最终的测试代码

#include "iostream"
#include "boost/thread.hpp"
#include "boost/bind.hpp"
using namespace std;
#include "windows.h"
#include "fstream"


namespace MyNamespace
{
	ofstream cout("log.txt");
}

//#define WRITEFILE_NAMESPACE

#ifdef WRITEFILE_NAMESPACE
ofstream out("log.txt");
#endif // 0


class DataOperation
{
public:

	DataOperation()
	{
		running_flag_  = true;
		isDataUpdate_  = false;
	}

	void Stop()
	{
		running_flag_ = false;
	}

	void EmitSignalThread()
	{
		while (running_flag_)
		{
			boost::recursive_mutex::scoped_lock lock(mtx);
			bool flag = GetDataUpdate();

			// 如果有更新 那些就替换数据库
			if (GetDataUpdate())
			{
				// 需要替换数据库
				for (int i = 0; i <= 999; i++)
				{
					if (i == 1)
					{
#ifdef WRITEFILE_NAMESPACE
						out << "正在替换数据库" << i << endl;
#else
						cout << "正在替换数据库" << i << endl;
#endif // WRITEFILE_NAMESPACE
						
					}
					if (i == 999)
					{
#ifdef WRITEFILE_NAMESPACE
						out << "替换完毕" << i << endl;
#else
						cout << "替换完毕" << i << endl;
#endif // WRITEFILE_NAMESPACE
					}
				}
				isDataUpdate_ = false;
			}
			isUserSearch_.notify_all();
			// 等待10秒钟，所以结束的时候可能会在这里阻塞
	//		boost::this_thread::sleep(boost::posix_time::millisec(10000));
		}
	}

	// 这个会阻塞
	void WaitReplaceDB()
	{
		boost::recursive_mutex::scoped_lock lock(mtx);
#ifdef WRITEFILE_NAMESPACE
		out << "如果程序没有动静，那么表明此刻正在更新数据库...等待几秒即可！" << endl;
#else
		cout << "如果程序没有动静，那么表明此刻正在更新数据库...等待几秒即可！" << endl;
#endif // WRITEFILE_NAMESPACE
		isUserSearch_.wait(mtx);
		boost::this_thread::sleep(boost::posix_time::millisec(100));
	}

	void SetDataUpdate(bool isDataUpdate = true)
	{
		isDataUpdate_ = isDataUpdate;
	}

	bool GetDataUpdate()
	{
		return isDataUpdate_;
	}

	bool GetRunningFlag()
	{
		return running_flag_;
	}

private:
	bool running_flag_;							 // 数据助手是否需要存活
	bool isDataUpdate_;		
	boost::recursive_mutex mtx;
	boost::condition_variable_any isUserSearch_; // 当前是否有用户正在查询
};


class WriteDB
{
public:
	void Start(DataOperation& dataoperation)
	{
		while (true)
		{
			// 在这里 这个线程进行数据库的更新可能需要大概好几分钟
			for (int i = 0; i <= 9999; i++)
			{
				if (i == 1)
				{
#ifdef WRITEFILE_NAMESPACE
					out << "WriteDB wait..." << i << endl;
#else
					cout << "WriteDB wait..." << i << endl;
#endif // WRITEFILE_NAMESPACE
				}
				if (i == 9999)
				{
#ifdef WRITEFILE_NAMESPACE
					out << "WriteDB wait..." << i << endl;
#else
					cout << "WriteDB wait..." << i << endl;
#endif // WRITEFILE_NAMESPACE
				}
			}

			dataoperation.SetDataUpdate();

			// 查询一下，如果程序退出了，那么线程也退出
			if (!dataoperation.GetRunningFlag())
			{
#ifdef WRITEFILE_NAMESPACE
				out << "bye-bye" << endl;
#else
				cout << "bye-bye" << endl;
#endif // WRITEFILE_NAMESPACE
				break;
			}
			Sleep(10000);
		}
	}
};


class Search
{
public:
	void Start(DataOperation& dataoperation)
	{
		string user_enter;
		while (true)
		{
			getline(cin, user_enter);
			if (user_enter == "q")
			{
				dataoperation.Stop();
				break;
			}

#ifdef WRITEFILE_NAMESPACE
			out << "当前用户输入的是：" << user_enter << endl;
#else
			cout << "当前用户输入的是：" << user_enter << endl;
#endif // WRITEFILE_NAMESPACE

			// 如果正在更新数据库，那么wait
			dataoperation.WaitReplaceDB();
		//	out << "如果程序没有动静，那么表明此刻正在更新数据库...等待几秒即可！" << endl;

			// 如果没在更新数据库，直接进行查询
			for (int i = 0; i <= 99999; i++)
			{
			//	cout << "正在为您查询数据..." << i << endl;
				//////////////////////////////////////////////////////////////////////////
				if (i == 1)
				{
#ifdef WRITEFILE_NAMESPACE
					out << "正在为您查询数据..." << i << endl;
#else
					cout << "正在为您查询数据..." << i << endl;
#endif // WRITEFILE_NAMESPACE
				}
				if (i == 99999)
				{
#ifdef WRITEFILE_NAMESPACE
					out << "查询完毕..." << i << endl;
#else
					cout << "查询完毕..." << i << endl;
#endif // WRITEFILE_NAMESPACE
				}
				//////////////////////////////////////////////////////////////////////////
			}

			// 向等待的线程发出信号，让他去更新数据库
			Sleep(100);
		}
	}
};


int main()
{
	boost::thread_group grp;
	WriteDB write_db;
	Search search;
	DataOperation data_operation;

 	grp.create_thread(boost::bind(&WriteDB::Start, &write_db, boost::ref(data_operation)));
	grp.create_thread(boost::bind(&Search::Start, &search, boost::ref(data_operation)));
 	grp.create_thread(boost::bind(&DataOperation::EmitSignalThread, boost::ref(data_operation)));

	grp.join_all();

	return 0;
}



如何封装一个线程安全、可复用的 HBase 查询模板
张彦峰的博客
05-02 4万+
本文探讨了如何封装一个线程安全、可复用的 HBase 查询模板。通过引入基于 AtomicReference 的连接懒加载机制和函数式接口封装查询执行逻辑，本文提供了一种高效的 HBase 查询解决方案。文章详细阐述了 HBase 连接池的实现、查询模板的设计与优化，以及如何在实际业务中应用这些技术。通过完整的案例演示，本文帮助开发者解决 HBase 查询中的常见问题，提高系统性能和可维护性。
C++多线程并发基础入门教程
南风fahaxiki
09-16 1209
线程：线程是操作系统能够进行CPU调度的最小单位，它被包含在进程之中，一个进程可包含单个或者多个线程。可以用多个线程去完成一个任务，也可以用多个进程去完成一个任务，它们的本质都相当于多个人去合伙完成一件事。多线程并发：多线程是实现并发(双核的真正并行或者单核机器的任务切换都叫并发）的一种手段，多线程并发即多个线程同时执行,一般而言，多线程并发就是把一个任务拆分为多个子任务，然后交由不同线程处理不同子任务,使得这多个子任务同时执行。
实现三个线程的同步
wyqwilliam的博客
07-01 756
1、线程一 package com.wyq.ticket; public class Ticket extends Thread{ @Override public void run() { for(int i = 0;i<=5;i++){ System.out.println(Thread.currentThread().getName()+"——————————&gt...
线程同步（三）
weixin_30809333的博客
05-25 108
介绍完如何创建进程以及线程了，那么我们接着来看一个实例： 　　利用多线程模拟 3 个窗口卖票 第一种方法：继承 Thread 类 　创建窗口类 TicketSell　 ? 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 2...
多线程三之线程同步
qq_44261638的博客
11-30 195
线程同步 为什么会出现线程同步这个概念呢？我们都知道线程是进程的基本运行单位，进程与进程之间是相互隔离互不影响的，拥有自己的独立空间，一个进程拥有多个线程，二线程与线程之间是共享虚拟空间和静态资源等的，这就导致当多个线程共享同一个资源的时候，会出现数据安全，资源冲突线程线程，而线程同步这个机制的出现就是为了解决这一问题的 当多线程共享统一资源不设置线程同步的时候例如下： public class ...
多线程三（线程同步）
Dream_Ryoma的博客
08-15 659
前面已经介绍过，在操作系统中，进程是资源分配的单位，线程是调度运行的单位。一个进程中可以存在多个线程，这多个线程共享进程的资源。线程具有并发性，也就是说，一个进程内的多个线程在完成任务的时候，是有可能同时使用到进程内的同一个资源，这个时候就会产生竞争，这也是多线程程序中的一个普遍问题，在java中，这种现象叫做竞争状态。 synchronized关键字 为避免竞争状态，应该防止多个线程同时进入程...
多线程（三）线程同步
chansr的博客
10-11 263
线程同步 前面说到的线程都是独立、且异步执行，而多线程编程的特点就是多个线程能够读写相同的变量或数据结构 。所以，编写多线程程序时，必须注意每个线程是否干扰了其他线程的工作。 下面首先给出一个多个线程在使用相同资源时会出现问题的例子。 示例1： public class Site implements Runnable { private int count = 10; // 剩余票...
java设计一个bank类实现银行_java定义一个类实现银行账户的概念。
weixin_39964590的博客
12-19 3184
2016-11-17 13:40黄瞩信 客户经理比如,只定义了一个抽象方法run()，而要通过系统用极短的时间。这5s内，此后这个线程就不能进入其它状态,进入消亡状态;+i++)。 2,另一方面;,它们都是程序的一个顺序执行序列,银行应先把帐本复制一遍。 另一种途径是通过一个类去继承接口runnable来实现线程的创建,一个线程是否处于运行状,将帐本看成数据段:、分配必要的资源后才能进入可运行状态...
有一个变量A，线程1循环去读此变量，线程2循环去写此变量，这种情况下需要加锁吗？
最新发布
06-10
嗯，用户再次确认了关于多线程共享变量加锁必要性的问题，看来ta正在处理实际开发中的线程同步痛点。从引用内容看，用户显然已经做了功课，甚至查阅了平台原子性和volatile等细节，但还在权衡锁的性能开销。用户可能...
c++多线程并发的原理及实现
qq_38338086的博客
12-04 6263
多线程并行处理和实现
JAVA | 线程（三）线程同步（重要）
yanerly的博客
07-23 280
一、线程安全问题（银行取钱） 问题描述： 当两个人同时对一个账户进行操作取钱的时候，可能会出现线程安全问题 //定义一个用户类 public class Account { // 银行账户 private String accountNo; //余额 private int balance; public Account(String accountNo...
Java多线程探究【三线程同步】
缘友一世的博客
11-12 1373
ReentrantLock类实现了Lock，它拥有与synchronized相同的并发性和内存请义，在实现线程安全的控制中，比较常用的ReentrantLock，可以显式加锁、释放锁。从JDK5.0开始，Java提供了更强大的线程同步机制——通过显式定义同步锁对象来实现同步。接口是控制多个线程对共享资源进行访问的工具。程序相互僵持，一直无法结束。同步锁使用Lock对象充当。
线程同步和设计模式
weixin_45277752的博客
03-23 265
线程同步 1.临界资源问题: 在同一个进程中有多个线程执行同一任务,有一个共享资源,当一个线程操作 共享资源时,还没来得及修改,另一个线程把cpu时间片抢去了,又来操作共享资源,这时就出现.临界资源问题. 2.解决临界资源问题,要用到线程同步. 3.线程同步: 让想一起执行代码绑定成一个代码块,一个线程进去执行这个代码块,其他线程就 不能进去,只能在外面等待,等待代码块中线程执行完了,让代码块共...
设计一个同步工具：该工具在同一时刻，只允许至多3个线程同时访问，超过3个线程的访问将被阻塞。
半夏_2021的博客
08-10 618
首先，确定访问模式。TrinityLock能够在同一时刻支持多个线程的访问，这显然是共享式访问，因此，需要使用同步器提供的acquireShared(int args)方法等和Shared相关的方法，这就要求TwinsLock必须重写tryAcquireShared(int args)方法和tryReleaseShared(int args)方法，这样才能保证同步器的共享式同步状态的获取与释放方法得以执行。 其次，定义资源数。TrinityLock在同一时刻允许至多三个线程的同时访问，表明同步资源数为3，这
三个多线程同步问题及其实现
https://gitcode.net/liuyuan185442111
11-22 1972
.
实现线程同步的几种方法
热门推荐
---小菜鸟---
09-27 3万+
在多线程程序中，会出现多个线程抢占一个资源的情况，这时间有可能会造成冲突，也就是一个线程可能还没来得及将更改的 资源保存，另一个线程的更改就开始了。可能造成数据不一致。因此引入多线程同步，也就是说多个线程只能一个对共享的资源进行更改，其他线程不能对数据进行修改。 如下一个两个线程对一个银行账户进行存钱的小实例，其中使用synchornized修饰方法实现线程的同步 代码如下： `import j...
JAVA多线程——实现同步
weixin_38719347的博客
07-26 1万+
转载(https://www.cnblogs.com/soundcode/p/6295910.html)加上了自己的补充和理解 为何要使用同步？ java允许多线程并发控制，当多个线程同时操作一个可共享的资源变量时（如数据的增删改查）， 将会导致数据不准确，相互之间产生冲突，因此加入同步锁以避免在该线程没有完成操作之前，被其他线程的调用， 从而保证了该变量的唯一性和准确性。 线程同步的方...
多线程——多线程同步的三种实现方法
Searchin_R的博客
12-01 1万+
当使用多线程访问同一个资源的时候，非常容易出现线程安全的问题（例如，当多个线程同时对一个数据进行修改的时候，会导致某些线程对数据的修改丢失）。 因此，需要采用同步机制来解决这种问题。而Java主要提供了三种实现同步机制的方法。今天我们就来认识一下~~ 一、synchronized关键字 在Java语言中，每个对象都有一个对象锁与之相关联，该锁表明对象在任何时候只允许被一个线程锁拥有，当一个线...
人生中怎么践行这个观点
05-30
- **物质极简主义**：定期清理冗余物品，减少购买决策中的纠结。如《庄子·逍遥游》所言：“鹪鹩巢林，不过一枝”，满足基本需求即可。 --- **4. 通过冥想与觉察训练强化内在感知** ```python # 每日觉察练习...
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值