FairLikeSnow的博客

C++中自旋锁的实现

#include <iostream>#include <thread>using namespace std;class TyThread{public: TyThread(std::thread &t) :m_thread(t) { } ~TyThread() { if (m_thread.joinable()) { m_thread.join(); } } TyThread(const TyThread &

recursive_mutex

CRITICAL_SECTION g_cs;class CMySafeLock{public: CMySafeLock(CRITICAL_SECTION *p) { m_pCS = p; cout << "----------------lock------------------\n"; EnterCriticalSection(m_pCS); } ~CMySafeLock() { LeaveCriticalSection(m_pCS); cout &lt

原子操作，一般都是指“不可分割的操作”，也就是说这种操作状态要么是完成的，要么是没完成的，不可能出现半完成状态；std::atomic代表原子操作，是一个类模板，其实这个东西用来封装某个类型的值的。注意和互斥量的区分，互斥量的加锁一般都是针对一个代码段（几行代码），而原子操作针对的一般都是一个变量，而不是一个代码段，是无锁的。下面看一个简单的例子，就是共同写一个数字，然后最后访问。int ncount = 0;std::mutex mutex1;void testx(){ clock_t .

shared_future也是一个类模板，get的时候是克隆（复制）出一个数据，而不是直接取出，所以能多次get()，下面是例子：void testPromise(std::promise<int> &mypromise, int x){ cout << "我是第一个线程,正在处理数据\n"; int nresult = 0; nresult = x + 10; nresult += 100; nresult -= 1; std::this_thread::s

下面是主函数：

std::promise是一个类模板，能够在某个线程中给它赋值，然后我们可以再其它线程中把这个值取出来。下面是调用下面是完整的代码：void testPromise(std::promise<int> &mypromise, int x){ cout << "x:" << x << endl; int nresult = 0; nresult = x + 10; nresult += 100; nresult -= 1; std

packaged_task是个类模板，用于打包任务，把任务包装起来。它的模板参数是各种调用对象，通过std::packaged_task来把各种可调用对象包装起来，方便将来作为线程入口函数来调用。下面是一个例子：int test(int x){ cout << "Child threadID:" << std::this_thread::get_id() << endl; cout << "X:" << x << endl;

std::async()、std::future创建后台任务并返回值。希望线程返回一个结果。std::async()是个函数模板，用来启动一个异步任务，启动这个异步任务之后，它返回一个std::future对象，这个std::future包含线程入口函数返回的结果（线程返回的结果），我们可以调用future的成员函数get()来获取。int test(int x){ cout << "Child threadID:" << std::this_thread::get_id()

下面先说说为什么它不安全：class JackTang{private: JackTang() { } //不能在析构函数中析构这个静态对象，这是一种错误的做法，虽然会调用，但是一个死递归，正确做法 //是创建一个嵌套析构类(下面的B)。 /*~JackTang() { if (pInstance) { cout << "hello "; delete pInstance;//递归调用 pInstance = NULL; cout

std::mutex m_utex1;int ncount = 0;void mythread1(){ for (int i = 0; i < 100;i++) { unique_lock<std::mutex> lc(m_utex1); cout << ncount << " "; }}void mythread2(){ for (int i = 0; i < 100; i++) { unique_lock&l.

代码如下：结果：从结果看出，当拿不到锁的时候，没有在那里傻傻的等待，而是偷偷摸鱼了19次，这样计算机资源就被我们充分利用起来了。下面说说std::try_to_lock的作用：使用该关键字后，会尝试去锁定m_utex,但如果没有锁定成功，也会立即返回，并不会阻塞在那里。...

什么是死锁？死锁 (deallocks)： 是指两个或两个以上的进程（线程）在执行过程中，因争夺资源而造成的一种互相等待的现象，若无外力作用，它们都将无法推进下去。此时称系统处于死锁状态或系统产生了死锁，这些永远在互相等待的进程（线程）称为死锁进程（线程）。我们举个例子来描述，如果此时有一个线程A，按照先锁a，再锁b,而在此同时又有另外一个线程B，按照先锁b再锁a的顺序获得锁。如下图所示：就如图这种情况下，线程A在等待锁b，可是锁b被锁住了，所以此时不能往下进行，需要等待锁b释放，而线程B先是锁住了

函数无参使用一个无参函数创建线程，thread 的构造接受一个参数，即函数名。//编写一个函数作为线程的执行路径void myprint() { cout << "我的线程开始运行" << endl; cout << "我的线程开始运行" << endl; cout << "我的线程开始运行" << endl; cout << "我的线程开始运行" << endl; cout << "

先看代码：class JackTang{public: int number; mutable int x{ 101 }; JackTang(int a) :number(a) { } JackTang(const JackTang &obj) { number = obj.number; ; } ~JackTang() { }};void test1(JackTang &obj){ obj.x = 1111;}void t

坑的来源就是，主线程退出了，子线程还没有结束。然后传递的参数要不失效，要不隐式转化失败等。class JackTang{public: int number; JackTang(int a) :number(a) { cout << "这是构造函数\n"; } JackTang(const JackTang &obj) { number = obj.number; cout << "这是Copy构造函数\n"; } ~JackTang(

先看示例1：#include <iostream>#include <windows.h>#include <mutex>#include<deque>#include <thread>using namespace std;int nmax = 20;std::deque<int> m_que;std::mutex mymutex;//生产者void producterex(){ int i = 1

对于多线程的使用可以看看我以前的文章：这篇文章主要说说线程同步的条件变量和互斥锁在线程中结合的使用，先看看几个概念条件变量：是一种线程同步机制，条件变量允许线程睡眠，直到满足条件，当满足条件时，可以向该线程发信号，通知唤醒。互斥锁: 互斥锁用于控制多个线程对他们之间共享资源互斥访问的一个信号量。也就是说是为了避免多个线程在某一时刻同时操作一个共享资源。为了防止竞争，条件变量的使用总是和一个...

目录1.CreateMutex函数原型2.WaitForSingleObject的理解3.CreateMutex和WaitForSingleObject的配合使用3.1如何加锁3.2如何解锁4.使用示例5.注意1.CreateMutex函数原型HANDLE CreateMutex(　LPSECURITY_ATTRIBUTES lpMutexAttributes, // 指向安全属性的指针　BOOL bInitialOwner, // 初始化互斥对象的所有者，如果希望进程立即拥有互斥体则设为FALSE

互斥锁    在多任务操作系统中，同时运行的多个任务可能都需要使用同一种资源。这个过程有点类似于，公司部门里，我在使用着打印机打印东西的同时（还没有打印完），别人刚好也在此刻使用打印机打印东西，如果不做任何处理的话，打印出来的东西肯定是错乱的。    在线程里也有这么一把锁——互斥锁（mutex），互斥锁是一种简单的加锁的方法来控制对共享资源的访问，互斥锁只有两种状态,即上锁( lock )和解锁( unlock )。【互

    临界区（Critical Section）是一段独占对某些共享资源访问的代码，在任意时刻只允许一个线程对共享资源进行访问。如果有多个线程试图同时访问临界区，那么在有一个线程进入后其他所有试图访问此临界区的线程将被挂起，并一直持续到进入临界区的线程离开。临界区在被释放后，其他线程可以继续抢占，并以此达到用原子方式操作共享资源的目的。临界区包含两个操作原语：EnterCriticalSection（） 进入临界区LeaveCriticalSection（）

一、为什么要进行线程同步？在程序中使用多线程时，一般很少有多个线程能在其生命期内进行完全独立的操作。更多的情况是一些线程进行某些处理操作，而其他的线程必须对其处理结果进行了解。正常情况下对这种处理结果的了解应当在其处理任务完成后进行。如果不采取适当的措施，其他线程往往会在线程处理任务结束前就去访问处理结果，这就很有可能得到有关处理结果的错误了解。例如，多个线程同时访问同一个全局变量，如果都是读取操作，则不会出现问题。如果一个线程负责改变此变量的值，而其他线程负责同时读取变量内容，则不能保证读取到的数据是经

1.事件    事件(Event)是WIN32提供的最灵活的线程间同步方式，事件可以处于激发状态(signaled or true)或未激发状态(unsignal or false)。根据状态变迁方式的不同，事件可分为两类：（1）手动设置：这种对象只可能用程序手动设置，在需要该事件或者事件发生时，采用SetEvent及ResetEvent来进行设置。（2）自动恢复：一旦事件发生并被处理后，自动恢复到没有事件状态，不需要再次设置。使用”事件”机制应注意以下事项：

在多线程的环境下，有时候我们不需要某函数被调用多次或者某些变量被初始化多次，它们仅仅只需要被调用一次或者初始化一次即可。很多时候我们为了初始化某些数据会写出如下代码，这些代码在单线程中是没有任何问题的，但是在多线程中就会出现不可预知的问题。bool initialized = false; // global flagif (!initialized) { // initialize if not initialized yet initialize (); initialize