// Windwos
#include <Windows.h>

DWORD WINAPI PrintMessage()
{
    // ...
}

int main() {
    DWORD myThreadID;

    HANDLE myHandle = CreateThread(0, 0, PrintMessage, NULL, 0, &myThreadID);

    WaitForSingleObject(myHandle, INFINITE);
    // thread가 종료될때 까지 기다린다.

    CloseHandle(myHandle);

    return 0;
}

// POSIX(pthread)
#include <pthread.h>

void *printMessage()
{
    // ...
}

int main() {
    pthread_t thread = 0;

    int result_code = pthread_create(&thread, NULL, printMessage, NULL);

    result_code = pthread_join(thread, NULL);

    return 0;
}

#include <iostream>
#include <string>
#include <thread>

void PrintMessage(const std::string& message)
{
    std::cout << message << std::endl;
}

int main() {
    std::thread thread(PrintMessage, "Message from a child thread");

    PrintMessage("Message from a main thread");

    return 0;
}

#include <iostream>
#include <string>
#include <thread>

void PrintMessage(const std::string& message)
{
    std::cout << message << std::endl;
}

int main() {
    std::thread thread(PrintMessage, "Message from a child thread");

    PrintMessage("Message from a main thread");

    thread.join();

    return 0;
}

#include <iostream>
#include <sstream>
#include <string>
#include <thread>

void PrintMessage(const std::string& message)
{
    std::cout << message << std::endl;
}

int main() {
    std::thread thread(PrintMessage, "Message from a child thread");

    std::thread::id childThreadOD = thread.get_id();
    std::stringstream ss;
    ss << childThreadID;
    std::string childThreadISStr = ss.str();
    
    PrintMessage("Waiting the child thread(ID : " + childThreadIDStr + ")");

    thread.join();

    return 0;
}

#include <iostream>
#include <string>
#include <thread>

void PrintMessage(const std::string& message)
{
    std::cout << message << std::endl;
}

int main() {
    std::thread thread(PrintMessage, "Message from a child thread");
    
    PrintMessage("Waiting the child thread");

    // 떼어 내기
    thread.detach();

    // 다시 붙이고 싶다면?
    if(thread.joinable())
    {
        thread.join();
    }

    return 0;
}

#include <iostream>
#include <string>
#include <thread>


int main() {
    auto PrintMessage = [](const std::string& message)
    {
        std::cout << message << std::endl;
    };

    std::thread thread(PrintMessage, "Message from a child thread");
    
    PrintMessage("Waiting the child thread");

    thread.join();

    return 0;
}

#include <iostream>
#include <string>
#include <thread>
#include <vector>

int main() {
    std::vector<int> list(100, 1);
    int result = 0;

    std::thread thread([](const std::vector<int>& v, int& result)
    {
        for( auto item : v )
        {
            result += item;
        }
    }, list, std::ref(result));

    thread.join();

    std::cout << "Result: " << result << std::endl;

    return 0;
}

#include <iostream>
#include <chrono>
#include <string>
#include <thread>

void PrintCurrentTime() {/* 현재 시간 출력 */}

void PrintMessage(const std::string& message)
{
    std::cout << "Sleep now ... ";
    PrintCurrentTime();

    std::this_thread::sleep_for(std::chrono::seconds(3));
    // thread 3초 자라

    std::cout << message << " ";
    PrintCurrentTime();
}

int main() {
    std::thread thread(PrintMessage, "Message from a child thread");
    
    PrintMessage("Waiting the child thread");

    thread.join();

    return 0;
}

auto end = std::chrono::high_resolution_clock::now() + delay;

while(std::chrono::high_resolution_clock_now() < end)
{
    std::this_thread::yield();
}

#include <iostream>
#include <mutex>
#include <string>
#include <thread>

void PrintMessage(const std::string& message)
{
    static std::mutex sMutex;
    // 물론 이런식으로 static을 쓰는건 좋지 못한 습관

    sMutex.lock();
    std::cout << message << std::endl;
    sMutex.unlock();
}

int main() {
    std::thread thread(PrintMessage, "Message from a child thread");
    
    PrintMessage("Waiting the child thread");

    thread.join();

    return 0;
}

#include <iostream>
#include <mutex>
#include <string>
#include <thread>

void PrintMessage(const std::string& message)
{
    static std::mutex sMutex;
    // 물론 이런식으로 static을 쓰는건 좋지 못한 습관

    sMutex.lock();
    std::cout << message << std::endl;
    // sMutex.unlock();
    // unlock을 안한경우
}

int main() {
    std::thread thread(PrintMessage, "Message from a child thread");
    
    PrintMessage("Waiting the child thread");

    thread.join();

    return 0;
}

void PrintMessage(const std::string& message)
{
    static std::mutex sMutex;
    // 물론 이런식으로 static을 쓰는건 좋지 못한 습관

    std::scoped_lock<std::mutex> lock(sMutex);
    std::cout << message << std::endl;
}

void PrintMessage(const std::string& message)
{
    static std::mutex sMutex;
    // 물론 이런식으로 static을 쓰는건 좋지 못한 습관

    // 다음과 같이 나눌 경우 scoped_lock을 별도로 걸 수 있다.
    {
        std::scoped_lock<std::mutex> lock(sMutex);
        std::cout << message << std::endl;    
    }

    {
        std::scoped_lock<std::mutex> lock(sMutex);
        std::cout << message << std::endl;    
    }
    
}