8. Threads and Concurrency

#include <stdio.h>
#include <pthread.h>

__thread int threadID = 0;

void* printThreadID(void* arg) {
    threadID = (int)(long)arg;
    printf("Thread ID: %d\n", threadID);
    return NULL;
}

int main() {
    pthread_t t1, t2, t3;

    pthread_create(&t1, NULL, printThreadID, (void*)(long)1);
    pthread_create(&t2, NULL, printThreadID, (void*)(long)2);
    pthread_create(&t3, NULL, printThreadID, (void*)(long)3);
    
    pthread_join(t1, NULL);
    pthread_join(t2, NULL);
    pthread_join(t3, NULL);

    return 0;
}

#include <iostream>
#include <thread>

thread_local int threadID = 0;

void printThreadID(int id) {
    threadID = id;
    std::cout << "Thread ID: " << threadID << std::endl;
}

int main() {
    std::thread t1(printThreadID, 1);
    std::thread t2(printThreadID, 2);
    std::thread t3(printThreadID, 3);

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

    return 0;
}

int pthread_create(pthread_t *thread, const pthread_attr_t *attr, void *(*start_routine) (void *), void *arg);
/* 
Parameters:
	1. thread: Pointer to a pthread_t variable that will hold the thread ID.
	2. attr: Pointer to a pthread_attr_t structure that specifies thread attributes (can be NULL for default attributes).
	3. start_routine: Function pointer to the function to be executed by the thread.
	4. arg: Argument to be passed to the start_routine function.

Return value: Returns 0 on success, non-zero on failure.
*/

int pthread_join(pthread_t thread, void **retval);
/* 
Parameters:
	1. thread: Thread ID of the thread to wait for.
	2. retval: Pointer to a location where the thread's return value will be stored (can be NULL if not needed).

Return value: Returns 0 on success, non-zero on failure.
*/

void pthread_exit(void *retval);
/* 
Parameters:
	1. retval: Pointer to the return value of the thread.

This function does not return.
*/

#include <pthread.h>
#include <stdio.h>

// Function to be executed by the thread
void* thread_function(void* arg) {
    int *ret_val = (int*)malloc(sizeof(int));
    *ret_val = 42; // Set the return value to 42
    pthread_exit((void*)ret_val); // Exit the thread and return the value
}

int main() {
    pthread_t thread;
    int result;
    void *retval;

    // Create a new thread
    result = pthread_create(&thread, NULL, thread_function, NULL);
    if (result != 0) {
        // Handle error
        return -1;
    }

    // Wait for the specific thread to exit and get the return value
    result = pthread_join(thread, &retval);
    if (result != 0) {
        // Handle error
        return -1;
    }

    // Print the return value
    printf("Thread returned value: %d\n", *(int*)retval);

    // Free the allocated memory
    free(retval);

    return 0;
}

int pthread_detach(pthread_t thread);
/* 
Parameters:
	1. thread: Thread ID of the thread to detach.

Return value: Returns 0 on success, non-zero on failure.
*/

int pthread_yield(void);
/* Explanation:
This function yields the processor to another thread.

Return value: Returns 0 on success, non-zero on failure.
*/

typedef struct {
    int detachstate;          // Thread detach state (PTHREAD_CREATE_JOINABLE or PTHREAD_CREATE_DETACHED)
    int scope;                // Contention scope (PTHREAD_SCOPE_SYSTEM or PTHREAD_SCOPE_PROCESS)
    size_t stacksize;         // Thread stack size
    void *stackaddr;          // Thread stack address
    
    struct sched_param schedparam; // Scheduling parameters (priority, etc.)
    // Other fields specific to the implementation
} pthread_attr_t;

#include <pthread.h>
#include <stdio.h>

// Thread start routine
void* startRoutine(void* arg) {
    // Thread work here
    return NULL;
}

int main() {
    pthread_attr_t attr;
    pthread_t thread;
    int result;

    // Initialize the thread attributes object
    pthread_attr_init(&attr);

    // Specific settings for thread attributes
    // Example: set the detach state
    pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);

    // Create a thread with the specified attributes
    result = pthread_create(&thread, &attr, startRoutine, NULL);
    if (result != 0) {
        perror("Failed to create thread");
        return 1;
    }

    /*
    Do something here
    */

    // Wait for the thread to terminate
    result = pthread_join(thread, NULL);
    if (result != 0) {
        perror("Failed to join thread");
        return 1;
    }
    // Destroy the thread attributes object
    pthread_attr_destroy(&attr);

    return 0;
}

int pthread_attr_init(pthread_attr_t *attr);
/* 
Parameters:
	1. attr: Pointer to a pthread_attr_t structure to be initialized.

Return value: Returns 0 on success, non-zero on failure.
*/

Thread attributes: 
	- Detach state = PTHREAD_CREATE_JOINABLE 
	- Scope = PTHREAD_SCOPE_SYSTEM 
	- Inherit scheduler = PTHREAD_INHERIT_SCHED 
	- Scheduling policy = SCHED_OTHER 
	- Scheduling priority = 0 
	- Guard size = 4096 bytes 
	- Stack address = 0x40196000 
	- Stack size = 0x201000 bytes

int pthread_attr_destroy(pthread_attr_t *attr);
/* 
Parameters:
	1. attr: Pointer to a pthread_attr_t structure to be destroyed.

Return value: Returns 0 on success, non-zero on failure.
*/

#include <pthread.h>

int pthread_attr_setdetachstate(pthread_attr_t *attr, int detachstate);
/* 
Parameters:
	1. attr: Pointer to the thread attributes object.
	2. detachstate: Detach state to be set (PTHREAD_CREATE_JOINABLE or PTHREAD_CREATE_DETACHED).

Return value: Returns 0 on success, non-zero on failure.
*/

int pthread_attr_getdetachstate(const pthread_attr_t *attr, int *detachstate);
/* 
Parameters:
	1. attr: Pointer to the thread attributes object.
	2. detachstate: Pointer to an integer where the detach state will be stored.

Return value: Returns 0 on success, non-zero on failure.
*/

int pthread_attr_setstacksize(pthread_attr_t *attr, size_t stacksize);
/* 
Parameters:
	1. attr: Pointer to the thread attributes object.
	2. stacksize: Stack size to be set.

Return value: Returns 0 on success, non-zero on failure.
*/

int pthread_attr_getstacksize(const pthread_attr_t *attr, size_t *stacksize);
/* 
Parameters:
	1. attr: Pointer to the thread attributes object.
	2. stacksize: Pointer to a size_t where the stack size will be stored.

Return value: Returns 0 on success, non-zero on failure.
*/

int pthread_attr_setstackaddr(pthread_attr_t *attr, void *stackaddr);
/* 
Parameters:
	1. attr: Pointer to the thread attributes object.
	2. stackaddr: Stack address to be set.

Return value: Returns 0 on success, non-zero on failure.
*/

int pthread_attr_getstackaddr(const pthread_attr_t *attr, void **stackaddr);
/* 
Parameters:
	1. attr: Pointer to the thread attributes object.
	2. stackaddr: Pointer to a void* where the stack address will be stored.

Return value: Returns 0 on success, non-zero on failure.
*/

int pthread_attr_setscope(pthread_attr_t *attr, int scope);
/* 
Parameters:
	1. attr: Pointer to the thread attributes object.
	2. scope: Contention scope to be set (PTHREAD_SCOPE_SYSTEM or PTHREAD_SCOPE_PROCESS).

Return value: Returns 0 on success, non-zero on failure.
*/

int pthread_attr_getscope(const pthread_attr_t *attr, int *scope);
/* 
Parameters:
	1. attr: Pointer to the thread attributes object.
	2. scope: Pointer to an integer where the contention scope will be stored.

Return value: Returns 0 on success, non-zero on failure.
*/

int pthread_setcanceltype(int type, int *oldtype);
/* 
Parameters:
	1. type: Specifies the new cancelability type for the thread. It can be one of the following:
	   - PTHREAD_CANCEL_DEFERRED: The thread will respond to cancellation requests at cancellation points (default).
	   - PTHREAD_CANCEL_ASYNCHRONOUS: The thread will respond to cancellation requests immediately.
	2. oldtype: Pointer to an integer where the previous cancelability type will be stored. Can be NULL if the previous type is not needed.

Return value: Returns 0 on success, non-zero on failure.
*/

int pthread_cancel(pthread_t thread);
/* 
Parameters:
	1. thread: Thread ID of the thread to be canceled.

Return value: Returns 0 on success, non-zero on failure.
*/

void pthread_testcancel(void);
/* 
Explanation: This function creates a cancellation point in the calling thread. If a cancellation request is pending, the thread will be canceled.

This function does not return a value.
*/

#include <stdio.h>
#include <pthread.h>

void* startRoutine(void* arg) {
    while (1) {
        printf("Thread running\n");
        pthread_testcancel(); // Set a cancellation point, check for cancel request
        sleep(1);
    }
    pthread_exit(NULL);
}

int main() {
    pthread_t thread;

    pthread_create(&thread, NULL, startRoutine, NULL);
    sleep(3); // Blocking for 3s before send cancellation.
    pthread_cancel(thread); // Send cancellation.
    pthread_join(thread, NULL);
    printf("Main thread ends\n");
    return 0;
}

#include <pthread.h>

// Register cleanup handler with argument.
void pthread_cleanup_push(void (*routine)(void*), void *argument);
/*
1. routine: Pointer to the cleanup handler function.
2. argument: Argument to be passed to the cleanup handler function.
*/

// Run if execute is non-zero.
void pthread_cleanup_pop(int execute);
/*
1. execute: If non-zero, the cleanup handler is executed.
*/

#include <thread>
#include <iostream>

void m_Func(){
}

int main(){
    std::size_t stack_size = 1024*1024; // 1MB
    std::thread t(std::thread(func), std::move(stack_size));
    t.join();
    return 0;
}

#include <iostream>
#include <thread>
static int i = 0;
void hello() {
	i++;
	std::cout << "Hello there! I am No." << i << std::endl;
}
int main() {

	std::thread thread_1(hello);
	std::thread thread_2(hello);
	std::thread thread_3(hello);
	std::thread thread_4(hello);
	std::thread thread_5(hello);
	std::thread thread_6(hello);
	std::thread thread_7(hello);
	std::thread thread_8(hello);
	std::thread thread_9(hello);
	std::thread thread_10(hello);

	return 0;
}

du@DVM:~/Desktop$ ./thread 
Hello there! I am No.5
Hello there! I am No.5
Hello there! I am No.6
terminate called without an active exception
Hello there! I am No.7
Aborted (core dumped)

Hello there! I am No.2
Hello there! I am No.5
Hello there! I am No.5
Hello there! I am No.5
Hello there! I am No.5
Main thread say byebye!

struct co_return {
    struct promise_type {
        co_return get_return_object() { return {}; }
        std::suspend_never initial_suspend() { return {}; }
        std::suspend_never final_suspend() noexcept { return {}; }
        void return_void() {}
        void unhandled_exception() { std::terminate(); }
    };
};

#include <iostream>
#include <coroutine>

struct co_return {
    struct promise_type {
        co_return get_return_object() { return {}; }
        std::suspend_never initial_suspend() { return {}; }
        std::suspend_never final_suspend() noexcept { return {}; }
        void return_void() {}
        void unhandled_exception() { std::terminate(); }
    };
};

co_return coroutine_foo() {
    std::cout << "Hello ";
    co_await std::suspend_always{};
    std::cout << "world!" << std::endl;
}

int main() {
	co_return cofoo = coroutine_foo();
	cofoo();
    return 0;
}

#include <iostream>
#include <coroutine>

struct co_return {
    struct promise_type {
        co_return get_return_object() { return co_return{std::coroutine_handle<promise_type>::form_promise(*this)}; }
        std::suspend_never initial_suspend() { return {}; }
        std::suspend_never final_suspend() noexcept { return {}; }
        void return_void() {}
        void unhandled_exception() { std::terminate(); }
    };
    std::coroutine_handle<> handle;
    co_return(std::coroutine_handle<> handle_): handle{handle_}{ }
    operator std::coroutine_handle<promise_type>() const {return handle_}
};

co_return coroutine_foo() {
    std::cout << "1. Hello! \n";
    co_await std::suspend_always{};
    std::cout << "2. Again! \n";
    co_awiat std::suspend_always{};
    std::cout << "3. Another Hello! \n";
    co_awiat std::suspend_always{};
    std::cout << "4. Another another Hello! \n";
}

int main() {
	co_return cofoo = coroutine_foo();
	cofoo.handle.resume();
	cofoo.handle(); // Calls std::coroutine_handle<>::operator();
	std::cout << std::boolalpha << cofoo.handle.done() << std::endl; // Check if coroutine is executed.
	cofoo();
    return 0;
}