스레드 생성과 관리

std::thread t(실행_가능_객체, 인자1, 인자2, ...);

#include <iostream>
#include <thread> // std::thread를 위해
#include <chrono> // std::chrono::seconds를 위해
#include <string> // std::string을 위해

// 새로운 스레드에서 실행될 함수 (인자 없음)
void workerFunctionNoArgs() {
    std::cout << "Worker thread (no args) started.\n";
    std::this_thread::sleep_for(std::chrono::seconds(2)); // 2초 대기
    std::cout << "Worker thread (no args) finished.\n";
}

// 새로운 스레드에서 실행될 함수 (인자 있음)
void workerFunctionWithArgs(int id, const std::string& message) {
    std::cout << "Worker thread " << id << " received message: " << message << std::endl;
    std::this_thread::sleep_for(std::chrono::seconds(1));
    std::cout << "Worker thread " << id << " finished.\n";
}

int main() {
    std::cout << "Main thread started.\n";

    // 1. 인자 없는 함수로 스레드 생성
    std::thread t1(workerFunctionNoArgs);

    // 2. 인자 있는 함수로 스레드 생성
    // 인자는 값으로 복사되어 전달됨.
    std::thread t2(workerFunctionWithArgs, 1, "Hello from main!");

    std::cout << "Main thread doing some work...\n";
    std::this_thread::sleep_for(std::chrono::seconds(1));

    // 스레드 t1과 t2가 작업을 마칠 때까지 기다림
    // 중요: join() 또는 detach() 중 하나는 반드시 호출해야 합니다!
    t1.join(); // t1 스레드가 종료될 때까지 메인 스레드 대기
    t2.join(); // t2 스레드가 종료될 때까지 메인 스레드 대기

    std::cout << "Main thread finished. All worker threads joined.\n";
    return 0;
}

#include <chrono>
#include <iostream>
#include <thread>
#include <string>
#include <vector> // std::vector를 위해
#include <functional> // std::ref를 위해

// 참조로 int를 수정하는 함수
void modifyValue(int& value) {
    std::this_thread::sleep_for(std::chrono::milliseconds(500));
    value += 100;
    std::cout << "Inside thread: value after modification = " << value << std::endl;
}

// 참조로 벡터에 추가하는 함수
void addElementToVector(std::vector<int>& vec, int element) {
    std::this_thread::sleep_for(std::chrono::milliseconds(500));
    vec.push_back(element);
    std::cout << "Inside thread: vector size = " << vec.size() << std::endl;
}

int main() {
    std::cout << "Main thread started.\n";

    int my_int = 10;
    std::cout << "Original my_int: " << my_int << std::endl;

    // my_int를 참조로 스레드에 전달
    std::thread t1(modifyValue, std::ref(my_int)); // std::ref 사용

    std::vector<int> my_vec = {1, 2, 3};
    std::cout << "Original my_vec size: " << my_vec.size() << std::endl;

    // my_vec을 참조로 스레드에 전달
    std::thread t2(addElementToVector, std::ref(my_vec), 4); // std::ref 사용

    t1.join();
    t2.join();

    std::cout << "After t1 joined: my_int = " << my_int << std::endl; // my_int가 변경되었음을 확인
    std::cout << "After t2 joined: my_vec size = " << my_vec.size() << std::endl; // my_vec이 변경되었음을 확인

    std::cout << "Main thread finished.\n";
    return 0;
}

#include <functional>
#include <iostream>
#include <thread>

int main() {
    int n = 10;
    std::thread copied([](int value) {
        std::cout << "copy=" << value + 100 << '\n';
    }, n);
    n = 20;
    copied.join();
    std::cout << "original=" << n << '\n';

    std::thread referred([](int& value) {
        value += 100;
    }, std::ref(n));
    referred.join();
    std::cout << "after ref=" << n << '\n';
}

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

void independentWorker() {
    std::cout << "Independent worker thread started.\n";
    std::this_thread::sleep_for(std::chrono::seconds(3));
    std::cout << "Independent worker thread finished.\n";
}

void joinableWorker() {
    std::cout << "Joinable worker thread started.\n";
    std::this_thread::sleep_for(std::chrono::seconds(1));
    std::cout << "Joinable worker thread finished.\n";
}

int main() {
    std::cout << "Main thread started.\n";

    // 1. detach() 스레드
    std::thread detached_thread(independentWorker);
    detached_thread.detach(); // 스레드를 분리

    std::cout << "Main thread created detached thread.\n";

    // 2. join() 스레드
    std::thread joinable_thread(joinableWorker);
    std::cout << "Main thread created joinable thread.\n";

    std::cout << "Main thread doing brief work...\n";
    std::this_thread::sleep_for(std::chrono::milliseconds(500));

    // detach()된 스레드는 더 이상 joinable() 하지 않음
    if (detached_thread.joinable()) {
        std::cout << "Detached thread is joinable (this won't print).\n";
    } else {
        std::cout << "Detached thread is not joinable.\n"; // 출력됨
    }

    // joinable() 확인 후 join()
    if (joinable_thread.joinable()) {
        std::cout << "Main thread waiting for joinable thread to finish...\n";
        joinable_thread.join(); // joinable_thread가 끝날 때까지 대기
        std::cout << "Joinable thread joined.\n";
    } else {
        std::cout << "Joinable thread is not joinable (this won't print).\n";
    }

    // 만약 detached_thread가 main 함수보다 더 오래 실행될 경우
    // main 함수 종료 시 프로그램이 종료되면서 detached_thread도 강제 종료될 수 있음.
    // 이는 detached_thread 내에서 자원 정리 등에 문제가 될 수 있으므로,
    // detach는 매우 신중하게 사용해야 함.
    std::cout << "Main thread finished.\n";
    return 0;
}