第四章(同步并发操作)

原创 2015年07月10日 09:03:12

1、条件变量

线程1完成后,通知其它线程它执行完成了。通过条件变量实现

void CTestThreadCondition::Preparation_Thread()
{
    while (true)
    {
        long ldata = clock();
        std::lock_guard<std::mutex> guard(dataMutex_);
        if (ldata >= lEndMark - 5000)
        {
            vsData_.push(ldata);
            data_cond_.notify_one();
            break;
        }
        std::this_thread::sleep_for(chrono::milliseconds(1000));
    }
}


void CTestThreadCondition::TestCondition()
{
    lEndMark = clock() + 15000;
    thread thread2(&CTestThreadCondition::Preparation_Thread, this);
    thread2.detach();

    while (true)
    {
        std::unique_lock<std::mutex> lk(dataMutex_);
        data_cond_.wait(lk, [this]{return !vsData_.empty(); }); // 匿名函数,等待vsData值是否不为空了

        long lPop = vsData_.front();
        vsData_.pop();
        lk.unlock();

        cout << lPop<<endl;

        if (lPop >= lEndMark)
        {
            break;
        }
    }
}


此处需要使用unique_lock,因为它里面支持unlock,lock接口,而条件变量正是利用这两个接口来实现通知等待的

wait接口需要传入函数指针,用来判断接受到信号后事继续wait还是往下执行,部分wait源码。收到notify_one后,wait(_Lck)就会往下执行

然后判断!_Pred(),如果此时该函数还是返回false,那就需要等待下一次的notify_one了。

template<class _Predicate>
  void wait(unique_lock<mutex>& _Lck, _Predicate _Pred)
  { // wait for signal and test predicate
  while (!_Pred())
   wait(_Lck);
  }

wait(_Lck)中会先将lk执行unlock。wait成功接受会,再将其lock。此时如果有其它线程(比如notify_one后它的lk未执行unlock)占用这把锁,也是无法继续往下执行的

条件变量时和信号量一起使用的,需要注意它对信号量的一些操作和改变,它依赖于信号量

notify_all是通知所有等待该信号的wait方法,notify_one是通知某一个,尽量一个信号一个等待。notify_all后信号量还是只能一个锁定


2、future

接受到线程的返回值

int Accumute(int i)
{
    Sleep(3000);
    return i;
}

void CTestThreadCondition::TestFutureGet()
{
    // async的构造函数接受的是一个右值引用&&
    // 第一个参数可以不传,不传与传入async目前看来是一样的,都表示在一个新的线程中立刻运行Accumute
    std::future<int> the_answer1 = std::async(std::launch::async, Accumute, 10);
    the_answer1.wait();  // wait会堵塞,直到the_answer1的线程执行返回结果
    int iRet1 = the_answer1.get(); // wait堵塞完后,get中存储的该值。如果不适用wait直接用get也是一样的会堵塞直到返回值

    std::future<int> the_answer2 = std::async(Accumute, 20); // 与上面一样
    Sleep(4000);
    the_answer2.wait();
    int iRet2 = the_answer2.get();

    // 传入deferred,表示不立刻运行,等到future调用wait或则get时才开始运行
    // wait表示等待线程运行完成,get是获取结果,也可以不调用wait,直接调用get也会进行等待线程执行完成的
    std::future<int> the_answer3 = std::async(std::launch::deferred, Accumute, 30);
    Sleep(4000);
    the_answer3.wait();
    int iRet3 = the_answer3.get();
}


3、packaged_task

将任务打包


void CTestThreadCondition::gui_thread()
{
    while (true)
    {
        packaged_task<int(int)> task; // 当前待处理的任务
        {
            lock_guard<mutex> lock(taskMutex_);
            if (Tasks_.empty())
            {
                Sleep(10);
                continue;
            }
            task = std::move(Tasks_.front());
            Tasks_.pop_front();
        }
        task(10); // 参数如何传递???
    }
}


void CTestThreadCondition::TestFuturePackaged()
{
    thread thread1(&CTestThreadCondition::gui_thread, this);
    // 将任务放到一个队列中,然后线程不断从队列中取值进行执行
    packaged_task<int(int)> task(Accumute); // 将函数指针放到一个packaged_task中,支持通过task转换成future,也可以直接执行task
    future<int> res = task.get_future();

    // task(1); // 也可以直接调用,然后res去get,此时会堵塞。task就是直接调用函数了
    {
        lock_guard<mutex> lock(taskMutex_);
        Tasks_.push_back(std::move(task)); // 放到队列中,在其它线程取值
    }

    int iRet = res.get();
   
    thread1.join();
}


4、Promise

void CTestThreadCondition::TestFuturePromise()
{
    std::promise<int> PromiseTask;

    PromiseTask.set_value(Accumute(10)); // setvalue就开始执行Accumute了?

    future<int> futureTask = PromiseTask.get_future();

    int aa = futureTask.get();

    // 多次get会崩溃
    //int aa2 = futureTask.get();
}


5、shared_future

多个线程等待future的值

void CTestThreadCondition::TestSharedFuture()
{
    // future只能等待一个future。如果多个线程都想要得到future的值,多次get会崩溃。这是故意这样设计的。为了统一异步结果的所有权
    // 此时需要使用shared_future
    promise<int> p1;
    future<int> f(p1.get_future());
    assert(f.valid());

    shared_future<int> sf(std::move(f));
    // 也可以直接通过future的shared接口直接转移所有权
    //shared_future<int> sf = f.share();

    assert(!f.valid());
    assert(sf.valid());
}


6、时钟

chrono标准库中部分接口,代替windows中sleep接口的方法:this_thread::sleep_for

sleep_for表示等待多少时间,sleep_unit表示等待到某个时间点。其它接口_for,_unit也是一样的。

void CTestThreadCondition::TestTime()
{
    chrono::system_clock::time_point tmNow = chrono::system_clock::now();

    future<int> f = async(Accumute, 10);
    if (f.wait_for(std::chrono::microseconds(4*1000*1000)) == future_status::ready) // microseconds是微秒
    {
        cout<< "f.get()"<<f.get()<<endl;
    }

    future<int> f2 = async(Accumute, 10);
    if (f2.wait_until(chrono::steady_clock::now() + chrono::milliseconds(4000)) == future_status::ready) // milliseconds是毫秒
    {
        cout << "f2.get()" << f2.get() << endl;
    }
}


this_thread::sleep_for/sleep_until

conditon_variable::wait_for/wait_until

conditon_variable_any::wait_for/wait_until

time_mutex::try_lock_for/try_lock_until

recursive_time_mutex::try_lock_for/try_lock_unitl

unique_lock<timeLockable>::unique_lock/unique_lock(lockable,time_point/duration)

future<valuetype>::wait_for/wait_until

shared_future<valuetype>::wait_for/wait_until





C#实现多线程同步并发操作

  • 2011年07月28日 10:23
  • 2KB
  • 下载

第四章 线程同步

转载:http://blog.sina.com.cn/s/blog_6cf994a301019won.html 第四章      线程同步 应用程序里面多个线程的存在引发了多个执行...

同步并发操作之等待一个事件或条件

在看《Cplusplus Concurrency in Action Practical Multithreading》。记录一下学习过程,这是第四章,关于条件变量的使用,后面有一个线程安全的队列。...

Cpp Concurrency In Action(读书笔记3)——同步并发操作

等待一个事件或其他条件 第一,它可以持续的检查共享数据标志(用于做保护工作的互斥量),直到另一线程完成工作时对这个标志进行重设。 第二个选择是在等待线程在检查间隙,使用 std::this_thr...
  • BestZem
  • BestZem
  • 2016年10月31日 10:52
  • 1957

第四章 DreamweaverCs3的基本操作

  • 2013年04月14日 21:49
  • 260KB
  • 下载

第四章 数据库操作

  • 2012年02月24日 11:30
  • 393KB
  • 下载

《C++ Concurrency in Action》读书笔记三 同步并发操作

本章要点 *等待事件 *使用futures等待一次性事件(waiting for one-off events with futures) *等待时间限制 *使用同步操作来简化代码 这章主要描述了如何...
  • sesiria
  • sesiria
  • 2016年05月23日 10:35
  • 747

多线程编程---同步并发操作

线程同步, 简单的说,就是在第一个线程完成前,需要等待另一个线程执行完成。通常情况下,线程会等待一个特定事件发生,或者等待某一条件达成(true).等待一个事件或者其他条件 假设你在旅游,而且正在一...

《C++ Concurrency In Action》part5 同步并发操作(下)

《C++ Concurrency In Action》part4 同步并发操作(下)4.2 使用期望等待一次性事件...

并发操作: Windows Vista 新增的同步原语

本文转自:http://msdn.microsoft.com/zh-cn/magazine/cc163405.aspx   并发操作 Windows Vista 新增的同步原语 Robert ...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:第四章(同步并发操作)
举报原因:
原因补充:

(最多只允许输入30个字)