Visual Studio 2012 Express 较好支持 C++11 新特性
前面使用 GCC 4.7, MinGW4.7 以及 boost 在 windows, Ubuntu下测试了C++11 的新特性，这次，把 Ubuntu 下的C++11测试代码直接挪到Windows 8 + Visual Stuido 2012 Express下，支持还是比较好的！测试环境：WIndows XP Host + Vmbox 4.2 +windows 8 企业试用版, visual studio 2012 Express for Windows Desktop,
顺便提一下，WIndows8 速度不错，虚拟机下 跑 VStudio 还很快的。
测试内容：
1、std::thread, 条件变量、mutex
2、lamda表达式，function, std::bind
3、nullptr类型
4、foreach (在algorithm里)
至于0x里已经有的 std::move, auto, regex, tumple等就算了。
#include "stdafx.h"
#include <iostream>
#include <thread>
#include <mutex>
#include <functional>
#include <list>
#include <atomic>
#include <vector>
#include <stdlib.h>
#include <time.h>
#include <assert.h>
#include <memory>
#include <condition_variable>
#include <algorithm>
//This class defines a class contains a thread, a task queue
class cpp11_thread
{
public:
cpp11_thread()
:m_b_is_finish(false)
,m_pthread(nullptr)
{
}
~cpp11_thread()
{
m_list_tasks.clear();
if (m_pthread!=nullptr)
delete m_pthread;
}
public:
//wait until this thread is terminated;
void join() {
terminate();
if (m_pthread!=nullptr)
m_pthread->join();
}
//wait until this thread has no tasks pending.
void wait_for_idle()
{
while(load())
std::this_thread::sleep_for(std::chrono::milliseconds(200));
}
//set the mask to termminiate
void terminate() {
m_b_is_finish = true;
m_cond_incoming_task.notify_one();
}
//return the current load of this thread
size_t load()
{
size_t sz = 0;
m_list_tasks_mutex.lock();
sz = m_list_tasks.size();
m_list_tasks_mutex.unlock();
return sz;
}
//Append a task to do
size_t append(std::function< void (void) > func)
{
if (m_pthread==nullptr)
m_pthread = new std::thread(std::bind(&cpp11_thread::run,this));
size_t sz = 0;
m_list_tasks_mutex.lock();
m_list_tasks.push_back(func);
sz = m_list_tasks.size();
//if there were no tasks before, we should notidy the thread to do next job.
if (sz==1)
m_cond_incoming_task.notify_one();
m_list_tasks_mutex.unlock();
return sz;
}
protected:
std::atomic< bool> m_b_is_finish; //atomic bool var to mark the thread the next loop will be terminated.
std::list<std::function< void (void)> > m_list_tasks; //The Task List contains function objects
std::mutex m_list_tasks_mutex; //The mutex with which we protect task list
std::thread * m_pthread; //inside the thread, a task queue will be maintained.
std::mutex m_cond_mutex; //condition mutex used by m_cond_locker
std::condition_variable m_cond_incoming_task; //condition var with which we notify the thread for incoming tasks
protected:
void run()
{
// loop wait
while (!m_b_is_finish)
{
std::function< void (void)> curr_task ;
bool bHasTasks = false;
m_list_tasks_mutex.lock();
if (m_list_tasks.empty()==false)
{
bHasTasks = true;
curr_task = *m_list_tasks.begin();
}
m_list_tasks_mutex.unlock();
//doing task
if (bHasTasks)
{
curr_task();
m_list_tasks_mutex.lock();
m_list_tasks.pop_front();
m_list_tasks_mutex.unlock();
}
if (!load())
{
std::unique_lock< std::mutex> cond_locker(m_cond_mutex); //using this lock to wait for signals;
m_cond_incoming_task.wait_for(cond_locker,std::chrono::milliseconds(500));//m_cond_incoming_task.wait(m_cond_locker);
}
}
}
};
//the thread pool class
class cpp11_thread_pool
{
public:
cpp11_thread_pool(int nThreads)
:m_n_threads(nThreads)
{
assert(nThreads>0 && nThreads<=512);
for (int i = 0; i< nThreads ;i++)
m_vec_threads.push_back(std::shared_ptr<cpp11_thread>(new cpp11_thread()));
}
~cpp11_thread_pool()
{
}
public:
//total threads;
size_t count(){return m_vec_threads.size();}
//wait until all threads is terminated;
void join()
{
std::for_each(m_vec_threads.begin(),m_vec_threads.end(),[this](std::shared_ptr<cpp11_thread> & item)
{
item->terminate();
item->join();
});
}
//wait until this thread has no tasks pending.
void wait_for_idle()
{
int n_tasks = 0;
do
{
if (n_tasks)
std::this_thread::sleep_for(std::chrono::milliseconds(200));
n_tasks = 0;
std::for_each(m_vec_threads.begin(),m_vec_threads.end(),[this,&n_tasks](std::shared_ptr<cpp11_thread> & item)
{
n_tasks += item->load();
});
}while (n_tasks);
}
//set the mask to termminiate
void terminate()
{
std::for_each(m_vec_threads.begin(),m_vec_threads.end(),[this](std::shared_ptr<cpp11_thread> & item)
{
item->terminate();
});
}
//return the current load of this thread
size_t load(unsigned int n)
{
return (n>=m_vec_threads.size())?0:m_vec_threads[n]->load();
}
//Append a task to do
void append(std::function< void (void) > func)
{
int nIdx = -1;
unsigned int nMinLoad = -1;
for ( int i=0;i<m_n_threads;i++)
{
if (nMinLoad> m_vec_threads[i]->load())
{
nMinLoad = m_vec_threads[i]->load();
nIdx = i;
}
}
assert(nIdx>=0 && nIdx<m_n_threads);
m_vec_threads[nIdx]->append(func);
}
protected:
//NO. threads
int m_n_threads;
//vector contains all the threads
std::vector<std::shared_ptr<cpp11_thread> > m_vec_threads;
};
//a function which will be executed in sub thread.
void hello()
{
//sleep for a while
std::this_thread::sleep_for(std::chrono::milliseconds(rand()%900+100));
std::cout <<
"Hello world, I'm a function runing in a thread!"
<< std::endl;
}
//a class has a method, which will be called in a thread different from the main thread.
class A
{
private:
int m_n;
public:
A(int n)
:m_n(n)
{}
~A(){}
public:
void foo (int k)
{
//sleep for a while
std::this_thread::sleep_for(std::chrono::milliseconds(rand()%900+100));
std::cout <<"n*k = "<<k*m_n<<std::endl;
m_n++;
}
};
//let's test the thread.
int main()
{
cpp11_thread_pool thread(2);
srand((unsigned int)time(0));
A a(1),b(2),c(3);
int nsleep = rand()%900+100;
//append a simple function task
thread.append(&hello);
//append lamda
thread.append
(
[&nsleep]()
{
std::this_thread::sleep_for(std::chrono::milliseconds(rand()%900+100));
std::cout<<"I'm a lamda runing in a thread"<<std::endl;
}
);
//append object method with copy-constructor(value-assignment)
thread.append(std::bind(&A::foo,a,10));
thread.append(std::bind(&A::foo,b,11));
thread.append(std::bind(&A::foo,c,12));
thread.append(std::bind(&A::foo,a,100));
//append object method with address assignment, will cause the objects' member increase.
thread.append(std::bind(&A::foo,&a,10));
thread.append(std::bind(&A::foo,&b,11));
thread.append(std::bind(&A::foo,&c,12));
thread.append(std::bind(&A::foo,&a,100));
//wait for all tasks done.
thread.wait_for_idle();
//kill
thread.terminate();
//wait for killed
thread.join();
//test function
std::function < void (void) > func1 = &hello;
std::function < void (void) > func2 = &hello;
if (func1.target<void (void) >()!=func2.target<void (void)>())
return 0;
else
return 1;
}