这是大学的多核程序设计课程内容，所以在这里就简单的总结一下。如果你之前有过多线程方面的编程经验，完全可以忽略本文的内容，它非常的初级。
首先说明一下，本人在Linux虚拟机上编写多线程程序，包含头文件
＃include <pthread.h>
一、线程的创建
在Linux下创建的线程的API接口是pthread_create()，它的完整定义是：
int pthread_create(pthread_t *thread, const pthread_attr_t *attr, void *(*start_routine)(void*), void *arg);
1 . 线程句柄 thread：当一个新的线程调用成功之后，就会通过这个参数将线程的句柄返回给调用者，以便对这个线程进行管理。
2 . 线程属性 attr： pthread_create()接口的第二个参数用于设置线程的属性。这个参数是可选的，当不需要修改线程的默认属性时，给它传递NULL就行。
3 . 入口函数 start_routine()： 当你的程序调用了这个接口之后，就会产生一个线程，而这个线程的入口函数就是start_routine()。如果线程创建成功，这个接口会返回0。
4 . 入口函数参数 *arg : start_routine()函数有一个参数，这个参数就是pthread_create的最后一个参数arg。这种设计可以在线程创建之前就帮它准备好一些专有数据
- 线程对象：存储线程信息，对用户不透明
- 线程对象的数据类型：pthread_t
- 创建线程：pthread_create
二、等待函数
int pthread_join( pthread_t thread, void** ret_val_ p);
pthread_join()这个接口的第一个参数就是新创建线程的句柄了，而第二个参数就会去接受线程的返回值。pthread_join()接口会阻塞主进程的执行，直到合并的线程执行结束。由于线程在结束之后会将0返回给系统，那么pthread_join()获得的线程返回值自然也就是0。
小例子（代码抄的，我解读）
#include <stdio.h>
#include <pthread.h>
void* thread( void *arg )
{
printf( "This is a thread and arg = %d.\n", *(int*)arg);
//将arg强制类型转换为指针，指向变量的值
*(int*)arg = 0;
return arg;
}
int main( int argc, char *argv[] )
{
pthread_t th;
int ret;
int arg = 10;
int *thread_ret = NULL;
ret = pthread_create( &th, NULL, thread, &arg );
//成功返回0
if( ret != 0 )
{
printf( "Create thread error!\n");
return -1;
}
printf( "This is the main process.\n" );
pthread_join( th, (void**)&thread_ret );
//二级指针强制类型转换，而后引用
printf( "thread_ret = %d.\n", *thread_ret );
return 0;
}
三、线程间的通信和同步
虽然线程本地存储可以避免线程访问共享数据，但是线程之间的大部分数据始终还是共享的。在涉及到对共享数据进行读写操作时，就必须使用同步机制，Linux提供的线程同步机制主要有互斥锁和条件变量。
临界区
临界区：当多个线程访问共享数据时，为保正数据的完整性，将共享数据保护起来
访问临界区的原则：
- 一次最多只能一个线程停留在临界区内；
- 不能让一个线程无限地停留在临界区内。
忙等待
flag = 0; 主线程初始化
………..
y = Compute(my_rank);
while (flag != my_rank);
x = x + y;
flag++;
执行临界区代码的顺序：线程0，线程1，线程2…
互斥量
互斥量：限制每次只有一个线程能进入临界区。
互斥量数据类型：pthread_mutex_t
互斥量初始化
int pthread_mutex_init(pthread_mutex_t∗ mutex_p,
const pthread_mutexattr_t∗ attr_p);
释放互斥量
int pthread_mutex_destroy(pthread_mutex_t∗ mutex_p);
加锁（阻塞和非阻塞）
int pthread_mutex_lock(pthread_mutex_t∗ mutex_p );
int pthread_mutex_trylock(pthread_mutex_t *mutex_p)
解锁
int pthread_mutex_unlock(pthread_mutex_t∗ mutex_p );
当线程数多于核数时候，忙等待效率降低。
忙等待：强调访问临界区的顺序
互斥量：访问临界区的顺序随机的
多个矩阵相乘
void∗ Thread_work(void∗ rank)
{
long my_rank = (long) rank;
matrix_t my_mat = Allocate_matrix(n);
Generate_matrix(my_mat);
pthread_mutex_lock(&mutex);
Multiply_matrix(product_mat, my_mat);
pthread_mutex_unlock(&mutex);
Free_matrix(&my_mat);
return NULL;
}
使用互斥量和忙等待来实现路障的方法；
使用一个通过互斥量保护的计数器；
当计数器表明，所有线程都进入过临界区, 线程就可以离开了。
信号量
信号量可以用于临界区，保护共享资源。
信号量的特性如下：
- 信号量有一个非负整数
- 要访问共享资源的 线程必须获取一个信号量，则信号量减1。
- 当信号量为0时，试图访问共享资源的线程将处于等待状态。
- 离开共享资源的 线程释放信号量，则信号量加1。
信号量可以认为是一种特殊类型的 unsigned int 无符号整型变量，可以赋值为 0，1，2，3 等，一般只赋0（对应上锁的互斥量）/1（未上锁的互斥量）。要把一个二元互斥量用作互斥量时候=，需要把信号量的值初始化为
1，即开锁状态。在要保护的临界区前调用函数 sem_wait，线程执行到 sem_wait 函数时，如果信号量为 0，线程就会被阻塞，否则减1 后进去临界区。执行完临界区的操作后，再调用 sem_post 对信号量的值加 1，使得在 sem_wait中阻塞的其他线程能够继续运行。
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])；
//信号量为 0，线程就会被阻塞，否则减1 后进去临界区。
sem_wait(&semaphores[my_rank]);
printf("Thread %ld > %s n", my_rank, messages[my_rank]); return NULL;
}
不同信号量的语法
int sem_init(sem_t∗ semaphore_p, int shared, unsigned initial_val );
int sem_destroy(sem_t∗ semaphore_p);
int sem_post(sem_t∗ semaphore_p);
int sem_wait(sem_t∗ semaphore_p);
注意：信号量不是 Pthreads 线程库的一部分，所以在使用信号量的程序开头加头文件
#include <semaphore.h>
路障
作用
使线程之间同步，并保证它们运行到了同一个位置。没有线程可以越过设置的路障，直到所有线程都抵达这里。
使用忙等待和互斥量实现路障
#include <stdio.h>
#include <pthread.h>
#pragma comment(lib, "pthreadVC2.lib")
const int thread = 8;
int count;
pthread_mutex_t pmt;
void* work(void* rank)
{
const long long localRank = (long long)rank, dest = (localRank + 1) % thread;
pthread_mutex_lock(&pmt); // 进入读写区，上锁，计数器加一，解锁
printf("Thread %2d reached the barrier.\n", localRank); fflush(stdout);
count++;
pthread_mutex_unlock(&pmt);
while (count < thread); // 使用忙等待来等所有的线程都达到栅栏
printf("Thread %2d passed the barrier.\n", localRank); fflush(stdout);
return ;
}
int main()
{
pthread_t pth[thread];
int i;
long long list[thread];
pthread_mutex_init(&pmt, NULL);
for (i = count = 0; i < thread; i++)
{
list[i] = i;
pthread_create(&pth[i], NULL, work, (void *)list[i]);
}
for (i = 0; i < thread; i++)
pthread_join(pth[i], NULL);
pthread_mutex_destroy(&pmt);
printf("\nfinish.\n");
getchar();
return 0;
}
条件变量
一个条件变量允许停止一个线程，直到某个事件发生；当条件被满足时，另一个线程可以激活这个线程；
条件变量总是和互斥量绑在一起。
条件变量数据类型：pthread_cond_t
条件变量初始化
int pthread_cond_init(pthread_cond_t* cond_var_p, const pthread_condattr_t* attr)
释放条件变量
int pthread_cond_destroy (pthread_cond_t* cond_var_p)
解锁一个阻塞的线程
int pthread_cond_signal(pthread_cond_t∗ cond_var_p);
解锁所有被阻塞的线程
int pthread_cond_broadcast(pthread_cond_t∗ cond_var_p);
通过互斥量阻塞线程
int pthread_cond_wait(pthread_cond_t∗ cond_var_p,pthread_mutex_t∗ mutex_p);
使用条件变量来实现路障
#include <stdio.h>
#include <pthread.h>
#include <semaphore.h>
#pragma comment(lib, "pthreadVC2.lib")
const int thread = 8;
int count;
pthread_mutex_t mutex;
pthread_cond_t cond;
void* work(void* rank)
{
const long long localRank = (long long)rank, dest = (localRank + 1) % thread;
printf("Thread %2d reached the barrier.\n", localRank); fflush(stdout);
pthread_mutex_lock(&mutex); // 上锁
count++;
if (count == thread) // 最后一个进入的线程
{
count = 0; // 计数器清零
pthread_cond_broadcast(&cond); // 广播所有线程继续向下执行
}
else
for (; pthread_cond_wait(&cond, &mutex) != 0;);// 等待其他线程
pthread_mutex_unlock(&mutex); // 条件变量阻塞解除后会自动将互斥量上锁，需要手工解除
printf("Thread %2d passed the barrier.\n", localRank); fflush(stdout);
return ;
}
int main()
{
pthread_t pth[thread];
int i;
long long list[thread];
pthread_mutex_init(&mutex, NULL);
pthread_cond_init(&cond, NULL);
for (i = count = 0; i < thread; i++)
{
list[i] = i;
pthread_create(&pth[i], NULL, work, (void *)list[i]);
}
for (i = 0; i < thread; i++)
pthread_join(pth[i], NULL);
pthread_mutex_destroy(&mutex);
pthread_cond_destroy(&cond);
printf("\nfinish.\n");
getchar();
return 0;
}
四、读写锁
读写锁有点像互斥量，但提供两个方法。
第 1 个用来对读上锁，而第 2 个用来对写上锁；
很多线程都可以获得读锁，但只有一个线程可以获得写锁。
如果有线程获得了读锁，那么其他线程无法获得写锁。
初始化
int pthread_rwlock_init(pthread_rwlock_t∗ rwlock_p,
const pthread_rwlockattr_t∗ attr_p );
读加锁
int pthread_rwlock_rdlock(pthread_rwlock_t∗ rwlock_p);
写加锁
int pthread_rwlock_wrlock(pthread_rwlock_t∗ rwlock_p);
解锁
int pthread_rwlock_unlock(pthread_rwlock_t∗ rwlock_p);
销毁
int pthread_rwlock_destroy(pthread_rwlock_t∗ rwlock_p );