std::thread t([](){
    std::cout << "thread function\n";
});

D>>std::thread t([](){
D>>    std::cout << "thread function\n";
D>>});
D>>

myObjPtr = ...
std::thread t([myObjPtr](){
    myObjPtr->myMethod();
});

The contents of <semaphore> are available only with C++20 or later.

V>>myObjPtr = ...
V>>std::thread t([myObjPtr](){
V>>    myObjPtr->myMethod();
V>>});
V>>

class MyClass
{
public:
    MyClass()
    {
    }

    void run()
    {
        worker = std::thred{[this]{
            //и вызывай любые методы в этом потоке
        }};
    }

    ~MyClass()
    {
        if(worker.joinable()) worker.join();
    }
private:
    std::thread worker;
}

MyClass myObj;// теперь там внутри как бы есть работающий поток

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

struct DelayedStartThread : std::thread
{
    template <class F>
    DelayedStartThread(F&& f)
        : std::thread{}
        , _f{std::forward<F>(f)}
    {
    }

    void start()
    {
        std::thread::operator=(std::thread{move(_f)});
    }

    std::function<void()> _f;
};

int main()
{
    DelayedStartThread dst{[]{
        std::cout << "started" << std::endl;
    }};
    std::cout << "not started yet" << std::endl;
    dst.start();
    dst.join();
    return 0;
}

CC>Posix это не стандарт а говно мамонта.

POSIX (англ. Portable Operating System Interface — переносимый интерфейс операционных систем) — набор стандартов, описывающих интерфейсы между операционной системой и прикладной программой (системный API), библиотеку языка C и набор приложений и их интерфейсов. Стандарт создан для обеспечения совместимости различных UNIX-подобных операционных систем и переносимости прикладных программ на уровне исходного кода, но может быть использован и для не-Unix систем.

Серия стандартов POSIX была разработана комитетом 1003 IEEE. Международная организация по стандартизации (ISO) совместно c Международной электротехнической комиссией (IEC) приняла стандарт POSIX под названием ISO/IEC 9945[2]. Версии стандарта POSIX являются основой соответствующих версий стандарта Single UNIX Specification. Стандарт POSIX определяет интерфейс операционной системы, а соответствие стандарту Single UNIX Specification определяет реализацию интерфейса и позволяет операционным системам использовать торговую марку UNIX[3].

struct A
{
    void run(int, const std::string&) { /*do stuff*/ }
};

int main()
{
    A a;
    std::thread t{&A::run, &a, 1, ""};
    t.join();
}

/* track-fn.h */
#pragma once

enum TrackConsts { track_no_limit=-1, track_start_line=0, track_end_line=-1 };
enum TrackResultCodes { track_rc_done=0, track_rc_active=1, track_rc_int=2 };

typedef struct Track { int line,limit; } Track;

#define TRACK_RESET(v) { Track *_track=(v); _track->line=0; _track->limit=1; }
#define TRACK_SET_LIMIT(track,n) { (track)->limit=n; }

#define TRACK_BEGIN(v) { Track *_track=(v); track_begin: \
    switch(_track->line) { default: case 0: TRACK_POINT
#define TRACK_POINT { case __LINE__: _track->line=__LINE__; \
    if (_track->limit>=0 && !_track->limit--) { _track->limit=1; return 1; } }
#define TRACK_END   track_end: case -1: _track->line=-1; return 0; } \
    track_interrupt: return 2; }

#define TRACK_END_R track_end: _track->line=-1; _track->limit=1; return 0; } \
    track_interrupt: return 2; }

#define TRACK_REPEAT_LAST goto track_begin;
#define TRACK_LEAVE       goto track_end;
#define TRACK_INTERRUPT   goto track_interrupt;

#define TRACK_CALL(fn,state) { int rc; \
    for(fn##_reset(state);0!=(rc=fn(state));) { \
        if (rc==track_rc_int) { TRACK_INTERRUPT } else { TRACK_POINT } \
    }}

/* tracks.c */
#include <stdio.h>
#include "track-fn.h"

typedef struct {
    Track track[1];
    int in0;
} fn1_state;
void fn1_reset(fn1_state *self) { TRACK_RESET(self->track); }

int fn1(fn1_state *self) {
    TRACK_BEGIN(self->track)
        printf("\tfn1.1\t%d\n",self->in0);
        TRACK_POINT
        printf("\tfn1.2\t%d\n",self->in0);
    TRACK_END
}

typedef struct {
    Track track[1];
    fn1_state fn1[1]; 
    int i;
} fn2_state;
void fn2_reset(fn2_state *self) { TRACK_RESET(self->track); }

int fn2(fn2_state *self) {
    TRACK_BEGIN(self->track)
        printf("fn2.1\n");
        TRACK_POINT
        for(self->i=1;self->i<=3;self->i++) {
            self->fn1->in0=self->i; /* function input arg */
            TRACK_CALL(fn1,self->fn1)
        }
        TRACK_POINT 
        printf("fn2.2\n");
    TRACK_END
}

int main(int argc, char const *argv[]) {    
    fn2_state s[1];
    fn2_reset(s);

    s->track->limit=3; fn2(s);
    printf("--\n");
    s->track->limit=track_no_limit; fn2(s);
    return 0;
}

// g++-10 -std=c++20 -fcoroutines cpp20.cpp && ./a.out
#include <coroutine>
#include <iostream>

struct resumable {
    struct promise_type {
        using coro_handle = std::coroutine_handle<promise_type>;
        auto get_return_object() { return coro_handle::from_promise(*this); }
        auto initial_suspend() { return std::suspend_always{}; }
        auto final_suspend() noexcept { return std::suspend_always{}; }
        void return_void() {}
        void unhandled_exception() { std::terminate(); }
    };
    using coro_handle = std::coroutine_handle<promise_type>;
    resumable(coro_handle handle) : handle(handle) {}
    bool resume() { if (!handle.done()) handle.resume(); return !handle.done(); }
    ~resumable() { if (handle) handle.destroy(); }
private:
    coro_handle handle;
};

resumable fn1() {
    std::cout<<"Hello"<<std::endl;
    co_await std::suspend_always{};
    std::cout<<"World"<<std::endl;
    co_await std::suspend_always{};
    std::cout<<"!!!"<<std::endl;
}

int main(int argc, char const *argv[]) {
    auto t=fn1();
    t.resume();
    t.resume();
    t.resume();
    return 0;
}