boost::thread

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

void hello()
{
	std::cout << "this is thread" << std::endl;
}

void name(const std::string& name)
{
	std::cout << "this name is:" << name << std::endl;
}

int main(void)
{
	boost::thread thrd1(&hello);
	boost::thread thrd2(boost::bind(name, "jone"));
	thrd1.join();
	thrd2.join();

	system("pause");
}

 
-------------------------------------------------------------
#include <boost/thread.hpp>
#include <boost/bind.hpp>
#include <iostream>
#include <windows.h>

boost::mutex io_mutex;
static int g_count = 0;

void count1()
{
	for (int i=0; i<10; i++)
	{
		boost::mutex::scoped_lock lock(io_mutex);
		std::cout << boost::this_thread::get_id() << ":" << ++g_count << std::endl;
		::Sleep(10); // for test
	}
}

void count2()
{
	for (int i=0; i<10; i++)
	{
		boost::mutex::scoped_lock lock(io_mutex);
		std::cout << boost::this_thread::get_id() << ":" << ++g_count << std::endl;
		::Sleep(11); // for test
	}
}

int main(void)
{
	boost::thread thrd1(&count1);
	boost::thread thrd2(&count2);
	thrd1.join();
	thrd2.join();

	system("pause");
}

-----------------------------------------------------------
#include <boost/thread.hpp>
#include <boost/bind.hpp>
#include <iostream>
#include <windows.h>

boost::mutex io_mutex;
static int g_count = 0;

void count(int num)
{
	for (int i=0; i<num; i++)
	{
		boost::mutex::scoped_lock lock(io_mutex);
		std::cout << boost::this_thread::get_id() << ":" << ++g_count << std::endl;
		::Sleep(100); // for test
	}
}

int main(void)
{
	boost::thread thrd1(boost::bind(count, 10));
	boost::thread thrd2(boost::bind(count, 20));
	thrd1.join();
	thrd2.join();

	system("pause");
}

 
-----------------------------------------------------------
#include <boost/circular_buffer.hpp>
#include <boost/thread/mutex.hpp>
#include <boost/thread/condition.hpp>
#include <boost/thread/thread.hpp>
#include <boost/progress.hpp>
#include <boost/bind.hpp>

template<class T>
class bounded_buffer
{
public:
	typedef boost::circular_buffer<T> container_type;
	typedef typename container_type::size_type size_type;
	typedef typename container_type::value_type value_type;
	
	explicit bounded_buffer(size_type capacity)
		: unread_(0), container_(capacity)
	{}

	void push_front(const value_type& item)
	{
		boost::mutex::scoped_lock lock(mutex_);
		// is_not_full ， 
		not_full_.wait(lock, boost::bind(&bounded_buffer<value_type>::is_not_full, this));
		container_.push_front(item);
		++unread_;
		lock.unlock();
		not_empty_.notify_one(); //  notify_one 
	}

	void pop_back(value_type* pItem)
	{
		boost::mutex::scoped_lock lock(mutex_);
		not_empty_.wait(lock, boost::bind(&bounded_buffer<value_type>::is_not_empty, this));
		*pItem = container_[--unread_];
		lock.unlock();
		not_full_.notify_one();
	}

private:
	bounded_buffer(const bounded_buffer&);
	bounded_buffer& operator=(const bounded_buffer&);

	bool is_not_empty() const
	{
		return unread_ > 0;
	}

	bool is_not_full() const
	{
		return unread_ < container_.capacity();
	}

	size_type unread_;
	container_type container_;
	boost::mutex mutex_;
	boost::condition not_empty_;
	boost::condition not_full_;
};

int main(void)
{
	bounded_buffer<int> buffer(3);
	buffer.push_front(1);
	buffer.push_front(2);
	buffer.push_front(3);

	int item;
	buffer.pop_back(&item);
	std::cout << item << std::endl;

	system("pause");
}

#include <iostream>
#include <boost/thread/thread.hpp>
#include <boost/thread/mutex.hpp>
#include <boost/thread/condition.hpp>
#include <boost/thread/xtime.hpp>
#include <boost/bind.hpp>
#include <ctime>
#include <windows.h>
#include <vector>

boost::mutex mut;
boost::condition cond;
bool data_ready;

bool is_data_ready()
{
	return (data_ready == true);
}

void prepare_data()
{
	std::cout << "prepare data" << std::endl;
}

void process_data()
{
	std::cout << "process data" << std::endl;
}

void wait_for_data_to_process()
{
	boost::mutex::scoped_lock lock(mut);
	cond.wait(lock, boost::bind(is_data_ready)); //  
	//while (!data_ready)
	//{
	//	cond.wait(lock);
	//}
	process_data();
}

void prepare_data_for_processing()
{
	prepare_data();
	{
		boost::lock_guard<boost::mutex> lock(mut);
		data_ready = true;
	}
	cond.notify_one();
}

int main()
{
	boost::thread th1(wait_for_data_to_process);
	boost::thread th2(prepare_data_for_processing);

	th1.join();
	th2.join();

	system("pause");
	return 0;
}


-------------------------------------------------------

#include <boost/circular_buffer.hpp>
#include <boost/thread/mutex.hpp>
#include <boost/thread/condition.hpp>
#include <boost/thread/thread.hpp>
#include <boost/progress.hpp>
#include <boost/bind.hpp>

template<class T>
class bounded_buffer
{
public:
	typedef boost::circular_buffer<T> container_type;
	typedef typename container_type::size_type size_type;
	typedef typename container_type::value_type value_type;
	
	explicit bounded_buffer(size_type capacity)
		: unread_(0), container_(capacity)
	{}

	void push_front(const value_type& item)
	{
		boost::mutex::scoped_lock lock(mutex_);
		// is_not_full ， 
		not_full_.wait(lock, boost::bind(&bounded_buffer<value_type>::is_not_full, this));
		container_.push_front(item);
		++unread_;
		lock.unlock();
		not_empty_.notify_one(); //  notify_one 
	}

	void pop_back(value_type* pItem)
	{
		boost::mutex::scoped_lock lock(mutex_);
		not_empty_.wait(lock, boost::bind(&bounded_buffer<value_type>::is_not_empty, this));
		*pItem = container_[--unread_];
		lock.unlock();
		not_full_.notify_one();
	}

private:
	bounded_buffer(const bounded_buffer&);
	bounded_buffer& operator=(const bounded_buffer&);

	bool is_not_empty() const
	{
		return unread_ > 0;
	}

	bool is_not_full() const
	{
		return unread_ < container_.capacity();
	}

	size_type unread_;
	container_type container_;
	boost::mutex mutex_;
	boost::condition not_empty_;
	boost::condition not_full_;
};

int main(void)
{
	bounded_buffer<int> buffer(3);
	buffer.push_front(1);
	buffer.push_front(2);
	buffer.push_front(3);

	int item;
	buffer.pop_back(&item);
	std::cout << item << std::endl;

	system("pause");
}