Linux系统下的多线程遵循POSIX线程接口，称为pthread。编写Linux下的多线程程序，需要使用头文件pthread.h，链接时需要使用库libpthread.a。
1.创建线程
#include <pthread.h>
int pthread_create(pthread_t *tidp, const pthread_attr_t *attr, void *(*start_rtn)(void), void *arg)
参数说明：
tidp：线程id
attr：线程属性（通常为空）
start_rtn：线程要执行的函数
arg：start_rtn的参数
thread_create.c
#include <stdio.h>#include <pthread.h>void *myThread1(void){ int i; for (i=0; i<100; i++) { printf("This is the 1st pthread,created by zieckey.\n"); sleep(1);//Let this thread to sleep 1 second,and then continue to run }}void *myThread2(void){ int i; for (i=0; i<100; i++) { printf("This is the 2st pthread,created by zieckey.\n"); sleep(1); }}int main(){ int i=0, ret=0; pthread_t id1,id2; /*创建线程1*/ ret = pthread_create(&id1, NULL, (void*)myThread1, NULL); if (ret) { printf("Create pthread error!\n"); return 1; } /*创建线程2*/ ret = pthread_create(&id2, NULL, (void*)myThread2, NULL); if (ret) { printf("Create pthread error!\n"); return 1; } pthread_join(id1, NULL); pthread_join(id2, NULL); return 0;}
2.终止线程
如果进程中任何一个线程中调用exit或_exit，那么整个进程都会终止。线程的正常退出方式有：
线程从启动例程中返回；线程可以被另一个进程终止；线程自己调用pthread_exit函数。
#include <pthread.h>
void pthread_exit(void *rval_ptr)
rval_ptr：线程退出返回值的指针。
3.线程等待
#include <pthread.h>
int pthread_join(pthread_t tid, void **rval_ptr)
功能：阻塞调用线程，直到指定的线程终止。
tid：等待退出的线程id
rval_ptr：线程退出的返回值的指针
thread_join.c
#include <pthread.h>#include <unistd.h>#include <stdio.h>void *thread(void *str){ int i; for (i = 0; i < 10; ++i) { sleep(2); printf( "This in the thread : %d\n" , i ); } return NULL;}int main(){ pthread_t pth; int i; int ret = pthread_create(&pth, NULL, thread, (void *)(i)); pthread_join(pth, NULL); printf("123\n"); for (i = 0; i < 10; ++i) { sleep(1); printf( "This in the main : %d\n" , i ); } return 0;}
4.线程标识
#include <pthread.h>
pthread_t pthread_self(void)
功能：获取调用线程的线程标识（thread identifier）。
thread_self.c
#include <stdio.h>#include <pthread.h>#include <unistd.h> /*getpid()*/void *create(void *arg){ printf("New thread .... \n"); printf("This thread's id is %u \n", (unsigned int)pthread_self()); printf("The process pid is %d \n",getpid()); return (void *)0;} int main(int argc,char *argv[]){ pthread_t tid; int error; printf("Main thread is starting ... \n"); error = pthread_create(&tid, NULL, create, NULL); if(error) { printf("thread is not created ... \n"); return -1; } printf("The main process's pid is %d \n",getpid()); sleep(1); return 0;}
5.清除
不论是可预见的线程终止还是异常终止，都会存在资源释放的问题。
从pthread_cleanup_push的调用点到pthread_cleanup_pop之间的程序段中的终止动作（包括调用pthread_exit()和异常终止，不包括return）都将执行pthread_cleanup_push()所指定的清理函数。
#include <pthread.h>
void pthread_cleanup_push(void (*rtn)(void *), void *arg)
功能：将清除函数压入清除栈。
trn：清除函数
arg：清除函数的参数
#include <pthread.h>
void pthread_cleanup_pop(int execute)
功能：将清除函数弹出清除栈。
execute：表示执行到pthread_cleanup_pop()时是否在弹出清除函数的同时执行该函数，非0就是执行，0就是不执行。
thread_clean.c
#include <stdio.h>#include <pthread.h>#include <unistd.h>void *clean(void *arg){ printf("cleanup :%s \n",(char *)arg); return (void *)0;}void *thr_fn1(void *arg){ printf("thread 1 start \n"); pthread_cleanup_push( (void*)clean,"thread 1 first handler"); pthread_cleanup_push( (void*)clean,"thread 1 second hadler"); printf("thread 1 push complete \n"); if(arg) { return((void *)1); } pthread_cleanup_pop(0); pthread_cleanup_pop(0); return (void *)1;}void *thr_fn2(void *arg){ printf("thread 2 start \n"); pthread_cleanup_push( (void*)clean,"thread 2 first handler"); pthread_cleanup_push( (void*)clean,"thread 2 second handler"); printf("thread 2 push complete \n"); if(arg) { pthread_exit((void *)2); } pthread_cleanup_pop(0); pthread_cleanup_pop(0); pthread_exit((void *)2);}int main(void){ int err; pthread_t tid1,tid2; void *tret; err=pthread_create(&tid1,NULL,thr_fn1,(void *)1); if(err!=0) { printf("error .... \n"); return -1; } err=pthread_create(&tid2,NULL,thr_fn2,(void *)1); if(err!=0) { printf("error .... \n"); return -1; } err=pthread_join(tid1,&tret); if(err!=0) { printf("error .... \n"); return -1; } printf("thread 1 exit code %d \n",(int)tret); err=pthread_join(tid2,&tret); if(err!=0) { printf("error .... "); return -1; } printf("thread 2 exit code %d \n",(int)tret); return 1;}
6.线程同步
6.1 利用互斥量实现线程同步
互斥量从本质上说就是一把锁，提供对共享资源的保护访问。
6.1.1 创建和销毁互斥量
在Linux中，互斥量使用类型pthread_mutex_t表示。在使用前，要对它进行初始化：
对于静态分配的互斥量，可以把它设置为默认的mutex对象PTHREAD_MUTEX_INITIALIZER；
对于动态分配的互斥量，在申请内存（malloc）之后，通过pthread_mutex_init进行初始化，并且在释放内存（free）前需要调用pthread_mutex_destroy。
#include <pthread.h>
int pthread_mutex_init(pthread_mutex_t *mutex, const pthread_mutexattr_t *attr)
int pthread_mutex_destroy(pthread_mutex_t *mutex)
6.1.2 加锁互斥量
如果互斥量已经上了锁，调用线程会阻塞，直到互斥量被解锁。
int pthread_mutex_lock(pthread_mutex_t *mutex)
int pthread_mutex_trylock(pthread_mutex_t *mutex)
返回值：成功则返回0，出错则返回错误编号。
trylock是非阻塞调用模式，如果互斥量没被锁住，trylock函数将对互斥量加锁，并获得对共享资源的访问权限；如果互斥量被锁住了，trylock函数将不会阻塞等待而直接返回EBUSY，表示共享资源处于忙状态。
6.1.3 解锁互斥量
int pthread_mutex_unlock(pthread_mutex_t *mutex)
6.1.4 互斥量与信号量的区别
互斥量是一把钥匙，一个线程拿了就可以访问受保护资源，出来时把钥匙交给队列的第一个线程。信号量时一个可以容纳N个线程的空间，如果空间不满就可以进去，如果空间满了就要等待有线程退出。对于N=1的情况，称为binary semaphore。
binary semaphore与mutex的区别在于：mutex要由获得锁的线程来释放，而semaphore可以由其他线程释放；初始状态可能不一样，mutex的初始值是1，而semaphore的初始值可能是0也可能是1。
来源：https://www.cnblogs.com/mikelin/archive/2010/07/15/1778417.html