gcc -g -Wall -o pth_hello pth_hello.c -lpthread
// link the libaray

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

//global var, can be accessed by all the threads
int thread_count;

void* Hello(void* rank); //Function started by thread_create. Note this is the prototype, void* func_name(void* ...).

int main(int argc, char* argv[]) {
	long thread;   // use long in case of 64-bit system;
	pthread_t* thread_handles;  // the identifier of each thread, readable by system, not user
	thread_count = strtol(argv[1], NULL, 10); // convert str to long, the last argument is base
	thread_handles = malloc(thread_count*sizeof(pthread_t));
	for (thread = 0; thread < thread_count; thread++) {
		pthread_create(&thread_handles(thread), NULL, Hello, (void*) thread); // 1st arg: p of thread handle, 2nd arg: not used, 3rd arg: func to start, 4th arg: arguments of func
	}
	printf("Hello from the main thread\n");
	for (thread = 0; thread < thread_count; thread++){
		pthread_join(thread_handles[thread], NULL);  // finalize all the thread
	}
	free(thread_handles);
	return 0;
}

void* Hello(void* rank) {
	long my_rank = (long) rank;
	printf("Hello from thread %ld of %d\n", my_rank, thread_count); // thread count is global variable here
	return NULL;
}

int pthread_create(
	pthread_t* thread_p, //out, the thread handle, it will modify
	const pthread_attr_t* attr_p, //in
	void* (*start_routine)(void*) //in, the function to start
	void* args_p, //in the arguments
)

int pthread_join(
	pthread_t thread, //in
	void** ret_val_p //out, returned value from thread
)

for (i = 0; i < m; i++) {
	y[i] = 0.0;
	for (j = 0; j < n; j++) {
		y[i] += A[i][j] * x[j];
		//or
		y[i] += A[i * n + j] * x[j];
	}
}

void *Pth_mat_vect(void* rank) {
	long my_rank = (long) rank;
	int i, j;
	int local_m = m / thread_count;
	int my_first_row = my_rank * local_m;
	int my_last_row = (my_rank + 1) * local_m - 1;

	for(i = my_first_row; i <= my_last_row; i++) {
		y[i] = 0.0;
		for (j = 0; j < n; j++)
			y[i] += A[i][j] * x[j];
	}
	return NULL;
}

int pthread_mutex_init(
	pthread_mutex_t* mutex_p, /*out*/
	const pthread_mutexattr_t* attr_p, /*out*/ // not used actually
)
pthread_mutex_lock(&mutex);
//critical section
pthread_mutex_unlock(&mutex);

int sem_init(
	sem_t* semaphore_p,    // out
	int shared,            //in   to control whether the semaphore is shared among threads or processes.
	unsigned initial_val   //in
);

int sem_destroy(sem_t* semaphore_p /*in/out*/)
int sem_post(sem_t* semaphore_p /*in/out*/) //at semaphore
int sem_wait(sem_t* semaphore_p) //wait if semaphore is 0

// example of message passing
void* Send_msg(void* rank) {
	long my_rank = (long) rank;
	long dest = (my_rank + 1) % thread_count;
	char* my_msg = malloc(MSG_MAX * sizeof(char));

	sprintf(my_msg, "Hello to %ld from %ld", dest, my_rank);
	messages[dest] = my_msg;
	sem_post(&semaphores[dest]);
	sem_wait(&semaphores[my_rank]);
	printf("Thread %ld > %s\n", my_rank, message[my_rank]);
	return NULL;
}

int counter;
int thread_count;
pthread_mutex_t barrier_mutex;

void* Thread_work() {
	pthread_mutex_lock(&barrier_mutex);
	counter++:
	pthread_mutex_unlock(&barrier_mutex);
	while(counter < thread_count);  //barrier here
}

int counter;
sem_t count_sem;
sem_t barrier_sem;

void* Thread_work(...) {
	/*Barrier*/
	sem_wait(&count_sem); //request counter lock
	if (counter == thread_count - 1) {
		counter = 0;
		sem_post(&count_sem);  // lock the counter sem
		//to let all the other thread pass
		for (j = 0; j < thread_count - 1; j++) {
			sem_post(&barrier_sem);
		}
	} else { // accumulate the counter
		counter++;
		sem_post(&count_sem);
		sem_wait(&barrier_sem);
	}
}

// typical condition
lock mutex;
if condition has occurred
	signal thread(s);
else {
	unlock the mutex and block;
	/*when thread is unblocked, mutex is relocked*/
}
unlock mutex;

int pthread_cond_wait(
	pthread_cond_t* cond_var_p, //in and out
	pthread_mutex_t* mutex_p,   //in and out
)
// it's essentially this:
pthread_mutex_unlock(&mutex_p);
wait_on_signal(&cond_var_p);
pthread_mutex_lock(&mutex_p);

//barrier implemented by conditional variables 
int counter = 0;
pthread_mutex_t mutex;
pthread_cond_t cond_var;
//...
void* Thread_work(...) {
	/*barrier*/
	pthread_mutex_lock(&mutex); //usual lock
	counter++;
	if (counter == thread_count) {
		counter = 0;
		pthread_cond_broadcast(&cond_var);
	} else {
		while(pthread_cond_wait(&cond_var, &mutex) != 0); // it will unlock the mutex, and wait for signal, after signal, it will get their previous lock and continue.
	}
	pthread_mutex_unlock(&mutex);
}


int pthread_cond_init(
	pthread_cond_t* cond_p, //out
	const pthread_condattr_t* cond_attr_p, //in NULL for us
)
int pthread_cond_destroy(
	pthread_cond_t* cond_p, //in & out
)

int pthread_rwlock_rdlock(pthread_rwlock_t* rwlock_p) //in and out
int pthread_rwlock_wrlock(pthread_rwlock_t* rwlock_p) //in and out
int pthread_rwlock_unlock(pthread_rwlock_t* rwlock_p) //in and out
int pthread_rwlock_init(pthread_rwlock_t* rwlock_p, const pthread_rwlockattr_t* attr_p) 
int pthread_rwlock_destroy(pthread_rwlock_t* rwlock_p);