Boost 线程学习笔记

#include <iostream>
#include <boost/thread/thread.hpp>
#include <boost/thread/xtime.hpp>

struct MyThreadFunc 
{
    void operator( )() 
    {
        // Do something long-running...
    }
} threadFun;

int main() 
{

    boost::thread myThread(threadFun); // Create a thread that starts running threadFun
    boost::thread::yield();           // Give up the main thread's timeslice，so the child thread can get some work done.

    // Go do some other work...

    myThread.join();                  // The current (i.e., main) thread will wait for myThread to finish before it returns

}

boost::thread_group grp;
boost::thread *p = new boost::thread(threadFun);
grp.add_thread(p);
//do something...
grp.remove_thread(p);
 
grp.create_thread(threadFun);
grp.create_thread(threadFun);   //Now there are two threads in grp
 
grp.join_all();                 //Wait for all threads to finish

#include <iostream>
#include <boost/thread/thread.hpp>
#include <string>

// A simple queue class; don't do this, use std::queue
template<typename T>
class Queue 
{
public:
    Queue() {}
    ~Queue() {}

    void enqueue(const T& x)
    {
        // Lock the mutex for this queue
        boost::mutex::scoped_lock lock(mutex_);
        list_.push_back(x);
        // A scoped_lock is automatically destroyed (and thus unlocked)
        // when it goes out of scope
    }

    T dequeue() 
    {
        boost::mutex::scoped_lock lock(mutex_);

        if (list_.empty())
            throw "empty!";     // This leaves the current scope, so the
        T tmp = list_.front(); // lock is released
        list_.pop_front();
        return(tmp);
    } // Again: when scope ends, mutex_ is unlocked

private:
    std::list<T> list_;
    boost::mutex mutex_;
};

Queue<std::string> queueOfStrings;

void sendSomething() 
{
    std::string s;
    for (int i = 0; i < 10; ++i) 
    {
        queueOfStrings.enqueue("Cyrus");
    }
}

void recvSomething() {
    std::string s;

    for (int i = 0; i < 10; ++i) 
    {
        try 
        {
            s = queueOfStrings.dequeue();
        }
        catch (...) {}
    }
}

int main() 
{
    boost::thread thr1(sendSomething);
    boost::thread thr2(recvSomething);

    thr1.join();
    thr2.join();
}

#include <iostream>
#include <boost/thread/thread.hpp>
#include <boost/thread/read_write_mutex.hpp>
#include <string>

template<typename T>
class Queue 
{
public:
    Queue() :  // Use a read/write mutex and give writers priority
        rwMutex_(boost::read_write_scheduling_policy::writer_priority){}
    ~Queue() {}

    void enqueue(const T& x) 
    {
        // Use a r/w lock since enqueue updates the state
        boost::read_write_mutex::scoped_write_lock writeLock(rwMutex_);
        list_.push_back(x);
    }

    T dequeue() 
    {
        // Again, use a write lock
        boost::read_write_mutex::scoped_write_lock writeLock(rwMutex_);

        if (list_.empty())
            throw "empty!";
        T tmp = list_.front();
        list_.pop_front();
        return(tmp);
    }

    T getFront() {
        // This is a read-only operation, so you only need a read lock
        boost::read_write_mutex::scoped_read_lock readLock(rwMutex_);
        if (list_.empty())
            throw "empty!";
        return(list_.front());
    }

private:
    std::list<T> list_;
    boost::read_write_mutex rwMutex_;
};

Queue<std::string> queueOfStrings;

void sendSomething() 
{
    std::string s;

    for (int i = 0; i < 10; ++i) 
    {
        queueOfStrings.enqueue("Cyrus");
    }
}

void checkTheFront() 
{
    std::string s;

    for (int i = 0; i < 10; ++i) 
    {
        try 
        { 
            s = queueOfStrings.getFront(); 
        }
        catch (...) {}
    }
}

int main() 
{

    boost::thread thr1(sendSomething);
    boost::thread_group grp;

    grp.create_thread(checkTheFront);
    grp.create_thread(checkTheFront);
    grp.create_thread(checkTheFront);
    grp.create_thread(checkTheFront);

    thr1.join();
    grp.join_all();
}

1）reader_priority：等待读锁的线程优先于等待写锁的线程
2）writer_priority：等待写锁的线程优先于等待读锁的线程
3）alternating_single_read：在读锁和写锁之间交替
4）alternating_many_reads：在读锁和写锁之间交替，这个策略将在两个写锁之间使得所有的在这个queue上挂起的读锁都被允许。

bool dequeue(T& x)
{
    boost::try_mutex::scope_try_lock lock(tryMutex_);
    if(!lock.locked())
        return false;
    else{
        if (list_.empty())
            throw "empty!";
        x = list_.front();
        list_.pop_front();
        return true;
    }
}
private:
    boost::try_mutex tryMutex_;

if(q.getFront() == "Cyrus")
{
   str = q.dequeue();
   //....
}

#include <iostream>
#include <boost/thread/thread.hpp>
#include <boost/thread/condition.hpp>
#include <boost/thread/mutex.hpp>
#include <list>
#include <string>

class Request { /*...*/ };

// A simple job queue class; don't do this, use std::queue
template<typename T>
class JobQueue 
{
public:
    JobQueue() {}
    ~JobQueue() {}

    void submitJob(const T& x)
    {
        boost::mutex::scoped_lock lock(mutex_);
        list_.push_back(x);
        workToBeDone_.notify_one();
    }

    T getJob() 
    {
        boost::mutex::scoped_lock lock(mutex_);

        workToBeDone_.wait(lock); // Wait until this condition is
        // satisfied, then lock the mutex
        T tmp = list_.front();
        list_.pop_front();
        return(tmp);
    }

private:
    std::list<T> list_;
    boost::mutex mutex_;
    boost::condition workToBeDone_;
};

JobQueue<Request> myJobQueue;

void boss() 
{
    for (;;) 
    {
        // Get the request from somewhere
        Request req;
        myJobQueue.submitJob(req);
    }
}

void worker()
{
    for (;;) 
    {
        Request r(myJobQueue.getJob());
        // Do something with the job...
    }
}

int main() 
{
    boost::thread thr1(boss);
    boost::thread thr2(worker);
    boost::thread thr3(worker);

    thr1.join();
    thr2.join();
    thr3.join();
}

#include <iostream>
#include <boost/thread/thread.hpp>
#include <boost/thread/once.hpp>

// Some sort of connection class that should only be initialized once
struct Conn 
{
    static void init() { ++i_; }
    static boost::once_flag init_;
    static int i_;
    // ...
};

int Conn::i_ = 0;
boost::once_flag Conn::init_ = BOOST_ONCE_INIT;

void worker() 
{
    boost::call_once(Conn::init, Conn::init_);
    // Do the real work...
}

Conn c;  // You probably don't want to use a global, so see the
// next Recipe

int main() 
{

    boost::thread_group grp;

    for (int i = 0; i < 100; ++i)
        grp.create_thread(worker);

    grp.join_all();

    std::cout << c.i_ << '
'; // c.i_ = 1
}

#include <iostream>
#include <string>
#include <functional>
#include <boost/thread/thread.hpp>

// A typedef to make the declarations below easier to read
typedef void(*WorkerFunPtr)(const std::string&);

template<typename FunT,   // The type of the function being called
    typename ParamT> // The type of its parameter
struct Adapter 
{
    Adapter(FunT f, ParamT& p) : // Construct this adapter and set the
        f_(f), p_(&p) {}          // members to the function and its arg

    void operator( )() { // This just calls the function with its arg
        f_(*p_);
    }
private:
    FunT    f_;
    ParamT* p_;  // Use the parameter's address to avoid extra copying
};

void worker(const std::string& s) 
{
    std::cout << s << '
';
}

int main() {

    std::string s1 = "This is the first thread!";
    std::string s2 = "This is the second thread!";

    boost::thread thr1(Adapter<WorkerFunPtr, std::string>(worker, s1));
    boost::thread thr2(Adapter<WorkerFunPtr, std::string>(worker, s2));

    thr1.join();
    thr2.join();
}

#include <boost/thread/thread.hpp>
#include <boost/thread/mutex.hpp>
#include <boost/thread/tss.hpp>
#include <iostream>

boost::mutex io_mutex;
boost::thread_specific_ptr<int> ptr;

struct count
{
    count(int id) : id(id) { }

    void operator()()
    {
        if (ptr.get() == 0)
            ptr.reset(new int(0));

        for (int i = 0; i < 10; ++i)
        {
            (*ptr)++;
            boost::mutex::scoped_lock
                lock(io_mutex);
            std::cout << id << ": "
                << *ptr << std::endl;
        }
    }

    int id;
};
int main(int argc, char* argv[])
{
    boost::thread thrd1(count(1));
    boost::thread thrd2(count(2));
    thrd1.join();
    thrd2.join();

    getchar();
    return 0;
}