C++: thread

개요

• 단일 실행 스레드
• 생성자의 인자로 전달된 함수를 객체 생성 즉시 실행
• spurious wakeup에 유의
• 멤버 함수
  • observers
    • joinable()
      • 조인 가능 여부 반환
    • get_id()
      • 스레드 아이디 반환
    • native_handle()
      • 스레드 핸들을 반환
    • hardware_concurrency()
      • 지원하는 동시 스레드 수 반환
  • operations
    • join()
      • 스레드가 실행을 완료할 때까지 대기
    • detach()
      • 스레드가 스레드 핸들과 독립적으로 실행되도록 허용
    • swap()
      • 두 개의 스레드 객체를 교환

예제

• 코드

    #include <atomic>
    #include <chrono>
    #include <condition_variable>
    #include <iostream>
    #include <map>
    #include <mutex>
    #include <queue>
    #include <string>
    #include <thread>
    #include <vector>

    using namespace std;

    atomic<bool> condition;
    mutex m;
    mutex mCV;
    condition_variable cv;
    queue<string> q;

    void producer(const string &content) {
    	if (condition == false) {
    		return;
    	}

    	{
    		lock_guard<mutex> lock(m);
    		q.push(content);
    		cout << "push : " << this_thread::get_id() << " : " << content << endl;
    	}

    	cv.notify_one();

    	this_thread::sleep_for(chrono::seconds(1));
    }

    void consumer() {
    	while (condition) {
    		{
    			unique_lock<mutex> lock(mCV);
    			cv.wait(lock, [&]() { return q.size() || condition == false; });
    			if (q.empty() && condition == false) {
    				break;
    			}

    			{
    				lock_guard<mutex> lock(m);
    				cout << "front : " << this_thread::get_id() << " : "
    					 << q.front() << endl;
    				q.pop();
    			}
    		}
    	}
    }

    void run() {
    	cout << "thread::hardware_concurrency() : "
    		 << thread::hardware_concurrency() << endl;

    	thread t([]() {
    		cout << "this_thread::get_id() : " << this_thread::get_id() << endl;
    	});

    	cout << "t.get_id() : " << t.get_id() << endl;

    	cout << "t.joinable() : " << t.joinable() << endl;
    	t.join();
    	cout << "t.joinable() : " << t.joinable() << endl;

    	cout << endl << "------" << endl << endl;

    	condition.store(true);

    	vector<thread> v1;
    	v1.clear();

    	map<int, thread> m1;
    	m1.clear();
    	for (int i = 0; i < 3; ++i) {
    		//		m1[i] = thread(producer, to_string(i));
    		v1.push_back(thread(producer, to_string(i)));
    	}

    	vector<thread> v2;
    	v2.clear();

    	map<int, thread> m2;
    	m2.clear();
    	for (int i = 0; i < 3; ++i) {
    		//		m2[i] = thread(consumer);

    		v2.push_back(thread(consumer));
    	}

    	for (auto &iter : v1) {
    		iter.join();
    	}

    	condition.store(false);
    	cv.notify_all();

    	for (auto &iter : v2) {
    		//		cout << iter.get_id() << " : joinable 1 - " << iter.joinable()
    		//<< endl;
    		iter.join();
    		//		cout << iter.get_id() << " : joinable 2 - " << iter.joinable()
    		//<< endl;
    	}
    }

    int main() {
    	run();

    	return 0;
    }

• 실행 결과

    thread::hardware_concurrency() : 2
    t.get_id() : 140429792114240
    t.joinable() : 1
    this_thread::get_id() : 140429792114240
    t.joinable() : 0

    ------

    push : 140429792114240 : 0
    push : 140429783721536 : 1
    push : 140429775328832 : 2
    front : 140429766936128 : 0
    front : 140429766936128 : 1
    front : 140429766936128 : 2