C++同時学習ノート

void do_some_work();
std::thread my_thread(do_some_work); //  do_some_work()      

class background_task
{
public:
  void operator()() const
  {
    do_something();
    do_something_else();
  }
};

background_task f;
std::thread my_thread(f);//            
std::thread my_thread2{background_task()};//  c++11            。

class background_task
{
public:
	void operator()(int times, std::string& s) {
		do_some_work_else(times, s);
	}
};
std::thread my_bt{background_task(),10,str}; //       
void f(int i, std::string const& s);
std::thread t(f, 3, "hello");  //     
//       ，  thread        ，                。       
//      ：
#include
#include
#include
#include
void do_some_work_else(int times, std::string& s )
{
	int k = times;
	s[2] = '0';
	for (int i = 0; i < k; i++)
	{
		std::cout << s << std::endl;
	}
}
class background_task
{
public:
	void operator()(int times, std::string& s) {
		do_some_work_else(times, s);
	}
};

int main()//   
{	
	background_task bt;
	std::string str_raw{ "do_in_main" };
	std::string str_thread{ std::string{"do_in_thread"} };
	//std::string &str = str_raw;
	//std::string &strt = str_thread;
	do_some_work_else(3, str_raw);
	std::thread my_bt{background_task(),10,str_thread};//         ；          。
	//std::thread my_thread(do_some_work);
	my_bt.join();
	//my_thread.detach();
	std::cout << str_raw <

//          ，  join()，       join()
int some_local_state=0;
  func my_func(some_local_state);
  std::thread t(my_func);
  try
  {
    do_something_in_current_thread();
  }
  catch(...)
  {
    t.join();  // 1
    throw;
  }
  t.join();  // 2
// join()       ,    thread_guard    ，        。 thread_guard           。    guard_lock。
//                 ，thread          ， unique_ptr，    move      ，     。
class thread_guard
{
  std::thread t;
public:
  explicit thread_guard(std::thread& t_):t(t_)//            。
  {}
  ~thread_guard()
  {
    if(t.joinable()) // join()      ，        
    {
      t.join();      // 2
    }
  }
  thread_guard(thread_guard const&)=delete;   //              。
  thread_guard& operator=(thread_guard const&)=delete;
};
struct func; //    
void f()
{
  int some_local_state=0;
  func my_func(some_local_state);
  std::thread t(my_func);
  thread_guard g(t);
  do_something_in_current_thread();//thread_guard        join()   。
}  

void some_function();
void some_other_function();
std::thread t1(some_function);		// t1     ， some_function     
std::thread t2=std::move(t1);		//  t1   ，  move()       ，      ，t1  
t1=std::thread(some_other_function);	//t1   some_other_function      。
std::thread t3;							
t3=std::move(t2);		// t2， some_function     t3			
t1=std::move(t3);    // t3， some_function     t1，  t1       。std::terminate()   ，    。
//    move  ，thread         ，           。

#include
#include
#include
#include

struct empty_stack : std::exception
{
	const char* what() const throw()
	{
		return "empty stack!";
	}
};
template
class threadsafe_stack
{
private:
	std::stack data;
	mutable std::mutex m; //                   。
						  //mutable             ，    const         。
public:
	threadsafe_stack()
		: data(std::stack()) {}//    

	threadsafe_stack(const threadsafe_stack& other) //    
	{
		std::lock_guard<:mutex> lock(other.m);//             ，                
		data = other.data;
	}

	threadsafe_stack& operator =(const threadsafe_stack&) = delete;//       

	void push(T new_value)
	{
		std::lock_guard<:mutex> lock(m);
		data.push(new_value);
	}
	//          pop
	//stl ，       top+pop     。
	//                     ，             ,    
	//           。
	//   top pop   ，             。
	//                     ，          。
	std::shared_ptr pop()
	{
		std::lock_guard<:mutex> lock(m);
		if (data.empty()) throw empty_stack();

		std::shared_ptr const res(std::make_shared(data.top()));
		data.pop();
		return res;
	}

	void pop(T& value)
	{
		std::lock_guard<:mutex> lock(m);
		if (data.empty()) throw empty_stack();

		value = data.top();
		data.pop();
	}

	bool empty() const
	{
		std::lock_guard<:mutex> lock(m);
		return data.empty();
	}

};

void swap(threadSafeStack stack1, threadSafeStack stack2)
{
	std::lock(stack1.mutex, stack2.mutex)// std::lock()           
	std::lock_guard<:mutex> lock1(stack1.mutex,  std::adopt_lock); //  stack1.mutex stack2.mutex       ，      std::adopt_lock，        。
	std::lock_guard<:mutex> lock1(stack2.mutex,  std::adopt_lock);//     lock_guard          （      ，    ）
	sssswap( stack1, stack2);//          
}

void stackTest(threadsafe_stack& stack, volatile int& count)
{
	
	while ( !stack.empty())
	{
		std::shared_ptr res = stack.pop();
		std::cout << *res << std::endl;
		count += 1;
	}
	std::cout << "safeTest end " << std::endl;
}
//
void stackTest2(std::stack& stack, volatile int& count)
{
	
	while (!stack.empty())
	{
		int res = stack.top();
		stack.pop();
		std::cout << res<< std::endl;
		count += 1;
	}
	std::cout << "Test end " << std::endl;
}
int main()
{
	threadsafe_stack safe_stack;
	std::stack stack;

	for (int i = 0; i < 100; i++)
	{
		safe_stack.push(i);
		stack.push(i);
	}
	volatile int count1 = 0;//      count     ，       。
	volatile int count2 = 0;
	std::thread t1(stackTest, std::ref(safe_stack), std::ref(count1));
	std::thread t2(stackTest, std::ref(safe_stack), std::ref(count1));

	std::thread ut1(stackTest2, std::ref(stack), std::ref(count2));
	std::thread ut2(stackTest2, std::ref(stack), std::ref(count2));
	
	t1.join();
	t2.join();
	std::cout << "safeStack : " << count1 << std::endl;
	
	ut1.join();
	ut2.join();
	std::cout << "std::Stack : " << count2 << std::endl;
}