thread -- 스레딩 #

long long spawn(fn, arg);          // fn: &static 함수 참조; 스레드 핸들을 반환
void      join(handle);
long long spawn_scoped(fn, arg);   // spawn과 같지만, 시작한 함수가 반환하기 전에 join됨

extern int printf(const char *fmt, ...);

static ?&int worker0(?&int unused) { unsafe { printf("thread 0\n"); } return null; }
static ?&int worker1(?&int unused) { unsafe { printf("thread 1\n"); } return null; }

int main() {
    long long h0 = spawn(worker0, null);
    long long h1 = spawn(worker1, null);

    join(h0);
    join(h1);

    printf("all threads done\n");
    return 0;
}

#include <std/thread.h>

// A thread that owns its argument (T: Send, R: Send). A Drop value.
generic<T, R> struct SpawnedThread {
    int  started() const;           // 0 if the thread couldn't be created
    R    join() consume;            // waits; f's result
    void drop();                    // join() and drop the result
};
generic<T: Send, R: Send> struct SpawnedThread<T, R> thread_spawn(fn R(T) f, T arg);   // arg moves in

generic<T: Send> struct Mutex {     // Sync: share it between threads
    static struct Mutex<T> new(T value);
    struct MutexGuard<T> lock() const;   // blocks; the guard is the only way to the value
    T    into_inner() consume;      // the value back
    void drop();
};
generic<T> struct MutexGuard {      // !Send: unlock on the locking thread
    &T   get();                     // valid until drop()
    void set(T value);              // replace (dropping the old value)
    void drop();                    // unlocks
};

generic<T: Send + Sync> struct RwLock {
    static struct RwLock<T> new(T value);
    struct RwReadGuard<T>  read() const;    // many at once: get() is const &T
    struct RwWriteGuard<T> write() const;   // exclusive: get() is &T
    void drop();
};

#include <std/thread.h>
#include <std/collections/vec.h>
extern int printf(const char *fmt, ...);

static struct Mutex<int> g_total;

long long sum(struct Vec<int> v) {           // owns v: nothing is shared
    long long s = 0LL;
    for (unsigned long i = 0UL; i < v.len; i = i + 1UL) s = s + (long long)*v.at(i);
    v.drop();
    return s;
}

?&int add_ten(?&int unused) {
    for (int i = 0; i < 10; i = i + 1) {
        struct MutexGuard<int> g = g_total.lock();
        *g.get() = *g.get() + 1;
        g.drop();                            // unlocks
    }
    return null;
}

int main() {
    struct Vec<int> v = Vec::new();
    for (int i = 1; i <= 100; i = i + 1) v.push(i);
    struct SpawnedThread<struct Vec<int>, long long> t = thread_spawn(sum, v);   // v moves in
    long long s = t.join();

    g_total = Mutex::new(0);
    long long h1 = spawn(add_ten, null);
    long long h2 = spawn(add_ten, null);
    join(h1);
    join(h2);
    int total = g_total.into_inner();

    struct RwLock<int> limit = RwLock::new(5);
    struct RwReadGuard<int> r = limit.read();
    int seen = *r.get();
    r.drop();
    struct RwWriteGuard<int> w = limit.write();
    *w.get() = 6;
    w.drop();
    limit.drop();

    printf("%lld %d %d\n", s, total, seen);
    return 0;
}

#include <std/thread.h>

generic<T>
int  thread_create(&unsigned long long tid, fn ?&T(?&T) func, ?&T arg);
int  thread_join(unsigned long long tid);
int  thread_detach(unsigned long long tid);
void thread_yield();
void thread_sleep_ms(unsigned long ms);
unsigned long long thread_self();

int mutex_init(&unsigned long long m);
int mutex_destroy(&unsigned long long m);
int mutex_lock(&unsigned long long m);
int mutex_trylock(&unsigned long long m);
int mutex_unlock(&unsigned long long m);

int cond_init(&unsigned long long cv);
int cond_destroy(&unsigned long long cv);
int cond_wait(&unsigned long long cv, &unsigned long long m);
int cond_timedwait_ms(&unsigned long long cv, &unsigned long long m, unsigned long ms);
int cond_signal(&unsigned long long cv);
int cond_broadcast(&unsigned long long cv);

int rwlock_init(&unsigned long long rw);
int rwlock_destroy(&unsigned long long rw);
int rwlock_rdlock(&unsigned long long rw);
int rwlock_wrlock(&unsigned long long rw);
int rwlock_tryrdlock(&unsigned long long rw);
int rwlock_trywrlock(&unsigned long long rw);
int rwlock_rdunlock(&unsigned long long rw);
int rwlock_wrunlock(&unsigned long long rw);

#include <std/thread.h>
#include <std/io.h>
#include <std/atomic.h>

static int counter = 0;
static unsigned long long mtx = 0ULL;

static ?&int worker(?&int unused) {
    int i = 0;
    while (i < 1000) {
        std::mutex_lock(&mtx);
        counter = counter + 1;
        std::mutex_unlock(&mtx);
        i = i + 1;
    }
    return null;
}

int main() {
    std::mutex_init(&mtx);

    unsigned long long t1 = 0ULL;
    unsigned long long t2 = 0ULL;
    std::thread_create(&t1, worker, null);
    std::thread_create(&t2, worker, null);

    std::thread_join(t1);
    std::thread_join(t2);

    std::print("counter = ");
    std::println_int(counter);  // 2000

    std::mutex_destroy(&mtx);
    return 0;
}

#include <std/thread.h>
#include <std/io.h>

static int buffer = 0;
static int ready  = 0;
static unsigned long long mtx = 0ULL;
static unsigned long long cv = 0ULL;

static ?&int producer(?&int unused) {
    std::mutex_lock(&mtx);
    buffer = 42;
    ready  = 1;
    std::cond_signal(&cv);
    std::mutex_unlock(&mtx);
    return null;
}

static ?&int consumer(?&int unused) {
    std::mutex_lock(&mtx);
    while (ready == 0) {
        std::cond_wait(&cv, &mtx);
    }
    std::print("received: ");
    std::println_int(buffer);  // 42
    std::mutex_unlock(&mtx);
    return null;
}

int main() {
    std::mutex_init(&mtx);
    std::cond_init(&cv);

    unsigned long long t1 = 0ULL;
    unsigned long long t2 = 0ULL;
    std::thread_create(&t1, consumer, null);
    std::thread_create(&t2, producer, null);

    std::thread_join(t1);
    std::thread_join(t2);

    std::cond_destroy(&cv);
    std::mutex_destroy(&mtx);
    return 0;
}