• 创建和调度线程都无须内核的干预，因此速度相当快。
• 不占用额外的内核资源，很多线程不会对系统性能造成明显影响。
• (缺点)一个进程的多个线程无法运行在不同的CPU上

• 内核调度M个内核线程，线程库调度N个用户线程
• 不会过度消耗内核资源，又可以充分利用多处理器的优势

#include <pthread.h>
int pthread_create ( pthread_t* thread, const pthread_attr_t* attr,void * (*start_routine)(void*) , void* arg);

#include <pthread.h>
void pthread_exit ( void* retval );

#include <pthread.h>
int pthread_join( pthread_t thread, void** retval );

#include <pthread.h>
int pthread_cancel ( pthread_t thread );

接收到取消请求的目标线程可以决定是否允许被取消以及如何取消。这分别由如下两个函数完成：

#include <pthread.h>
int pthread_setcancelstate( int state, int *oldstate );
int pthread_setcanceltype ( int type, int *oldtype );

#include <bits/pthreadtypes.h>
#define __SIZEOF_PTHREAD_ATTR_T 36
typedef union
{char __size[__SIZEOF_PTHREAD_ATTR_T];long int __align;
} pthread_attr_t;

#include <pthread.h>
/*初始化线程属性对象*/
int pthread_attr_init( pthread_attr_t* attr );
/*销毁线程属性对象，被销毁的线程属性对象只有再次初始化之后才能继续使用*/
int pthread_attr_destroy( pthread_attr_t* attr);
/*下面这些函数用于获取和设置线程属性对象的某个属性*/
int pthread_attr_getdetachstate( const pthread_attr_t* attr ,int* detachstate );
int pthread_attr_setdetachstate( pthread_attr_t* attr,int detachstate );
int pthread_attr_getstackaddr( const pthread_attr_t* attr,void **stackaddr );
int pthread_attr_setstackaddr( pthread_attr_t* attr,void* stackaddr );
int pthread_attr_getstacksize( const pthread_attr_t* attr,size_t* stacksize );
int pthread_attr_setstacksize( pthread_attr_t* attr,size_t stackszie );
int pthread_attr_getstack( const pthread_attr_t* attr,void** stackaddr,size_t* stacksize );
int pthread_attr_setstack( pthread_attr_t* attr,void* stackaddr,size_t stacksize );
int pthread_attr_getguardsize( const pthread_attr_t* attr,size_t* guarsize );
int pthread_attr_setguardsize( pthread_attr_t* attr,size_t guarsize );
int pthread_attr_getschedparam( const pthread_attr_t* attr,struct sched_param* param );
int pthread_attr_setschedparam( pthread_attr_t* attr,const struct sched_param* param );
int pthread_attr_getschedpolicy( const pthread_attr_t* attr,int* policy );
int pthread_attr_setschedpolicy( pthread_attr_t* attr,int policy );
int pthread_attr_getinheritsched( const pthread_attr_t* attr,int* inherit );
int pthread_attr_setinheritsched( pthread_attr_t* attr,int inherit );
int pthread_attr_getscope( const pthread_attr_t* attr,int* scope );
int pthread_attr_setscope( pthread_attr_t* attr,int scope );

#include <semaphore.h>
int sem_init ( sem_t* sem, int pshared, unsigned int value );    // 初始化一个未命名的信号量
int sem_destroy ( sem_t* sem );        // 用于销毁信号量，以释放其占用的内核资源
int sem_wait ( sem_t*sem );              // 以原子操作的方式将信号量减1，如果信号量的值为0，则阻塞，直到该值不为0.
int sem_trywait ( sem_t* sem );         // sem_wait的非阻塞版本
int sem_post ( sem_t* sem );             // 以原子操作的方式将信号量的值加1

• sem_init函数用于初始化一个未命名的信号量。pshared参数指定信号量的类型。如果其值是0，就表示这个信号量是当前进程的局部信号量，否则该信号量就可以在多个进程之间共享。value参数指定信号量的初始值。此外，初始化一个已经被初始化的信号量将导致不可预期的结果。
• sem_destroy函数用于销毁信号量，以释放其占用的内核资源。如果销毁一个正被其他线程等待的信号量，则将导致不可预期的结果。
• sem_wait函数以原子操作的方式将信号量的值减1.如果信号量的值为0，则sem_wait将被阻塞，直到这个信号量具有非0值。
• sem_trywait与sem_wait函数相似，不过它始终立即返回，而不论被操作的信号量是否具有非0值，相当于sem_wait的非阻塞版本。当信号量的值大于0值时，sem_trywait对信号量执行减1操作。当信号量的值为0时，它将返回-1，并设置errno为EAGAIN。
• sem_post函数以原子操作的方式将信号量的值加1.当信号量的值大于0时，其他正在调用sem_wait等待信号量的线程将被唤醒。

#include <pthread.h>
int pthread_mutex_init ( pthread_mutex_t* mutex, const pthread_mutexattr_t* mutexattr );
int pthread_mutex_destroy ( pthread_mutex_t* mutex );
int pthread_mutex_lock ( pthread_mutex_t* mutex );
int pthread_mutex_trylock ( pthread_mutex_t* mutex );
int pthread_mutex_unlock ( pthread_mutex_t* mutex );

pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;

#include <pthread.h>
/* 初始化互斥锁属性对象 */
int pthread_mutexattr_init ( pthread_mutexattr_t* attr );
/* 销毁互斥锁属性对象 */
int pthread_mutexattr_destroy ( pthread_mutexattr_t* attr );
/* 获取和设置互斥锁的pshared属性 */
int pthread_mutexattr_getpshared ( const pthread_mutexattr_t* attr, int * pshared );
int pthread_mutexattr_setpshared ( pthread_mutexattr_t* attr, int pthread );
/* 获取和设置互斥锁的type属性 */
int pthread_mutexattr_gettype ( const pthread_mutexattr_t* atr, int * type );
int pthread_mutexattr_settype ( pthread_mutexattr_t* attr, int type );

#include <pthread.h>
#include <unistd.h>
#include <stdio.h>int a = 0;
int b = 0;
pthread_mutex_t mutex_a;
pthread_mutex_t mutex_b;void* another( void* arg )
{pthread_mutex_lock( &mutex_b );printf( "in child thread, got mutex b, waiting for mutex a\n" );sleep( 5 );++b;pthread_mutex_lock( &mutex_a );b += a++;pthread_mutex_unlock( &mutex_a );pthread_mutex_unlock( &mutex_b );pthread_exit( NULL );
}int main()
{pthread_t id;pthread_mutex_init( &mutex_a, NULL );pthread_mutex_init( &mutex_b, NULL );pthread_create( &id, NULL, another, NULL );pthread_mutex_lock( &mutex_a );printf( "in parent thread, got mutex a, waiting for mutex b\n" );sleep( 5 );++a;pthread_mutex_lock( &mutex_b );a += b++; pthread_mutex_unlock( &mutex_b );pthread_mutex_unlock( &mutex_a );pthread_join( id, NULL );pthread_mutex_destroy( &mutex_a );pthread_mutex_destroy( &mutex_b );return 0;
}

#include <pthread.h>
int pthread_cond_init (pthread_cond_t* cond, const pthread_condattr_t* cond_attr);
int pthread_cond_destroy ( pthread_cond_t* cond );
int pthread_cond_broadcast ( pthread_cond_t* cond );        //以广播的形式唤醒一个等待目标条件变量的线程
int pthread_cond_signal ( pthread_cond_t* cond );              //唤醒一个等待目标条件变量的线程
int pthread_cond_wait ( pthread_cond_t* cond,  pthread_mutex_t* mutex );    // 等待目标条件变量，mutex参数保证对条件变量及其等待队列的操作原子性。

pthread_cond_t cond = PTHREAD_COND_INITIALIZER;

#ifndef LOCKER_H
#define LOCKER_H#include <exception>
#include <pthread.h>
#include <semaphore.h>class sem
{
public:sem(){if( sem_init( &m_sem, 0, 0 ) != 0 ){throw std::exception();}}~sem(){sem_destroy( &m_sem );}bool wait(){return sem_wait( &m_sem ) == 0;}bool post(){return sem_post( &m_sem ) == 0;}private:sem_t m_sem;
};class locker
{
public:locker(){if( pthread_mutex_init( &m_mutex, NULL ) != 0 ){throw std::exception();}}~locker(){pthread_mutex_destroy( &m_mutex );}bool lock(){return pthread_mutex_lock( &m_mutex ) == 0;}bool unlock(){return pthread_mutex_unlock( &m_mutex ) == 0;}private:pthread_mutex_t m_mutex;
};class cond
{
public:cond(){if( pthread_mutex_init( &m_mutex, NULL ) != 0 ){throw std::exception();}if ( pthread_cond_init( &m_cond, NULL ) != 0 ){pthread_mutex_destroy( &m_mutex );throw std::exception();}}~cond(){pthread_mutex_destroy( &m_mutex );pthread_cond_destroy( &m_cond );}bool wait(){int ret = 0;pthread_mutex_lock( &m_mutex );ret = pthread_cond_wait( &m_cond, &m_mutex );pthread_mutex_unlock( &m_mutex );return ret == 0;}bool signal(){return pthread_cond_signal( &m_cond ) == 0;}private:pthread_mutex_t m_mutex;pthread_cond_t m_cond;
};#endif

#include <pthread.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <wait.h>pthread_mutex_t mutex;/*子线程运行的函数。它首先获得互斥锁mutex，然后暂停5s ，再释放该互斥锁*/
void* another( void* arg )
{printf( "in child thread, lock the mutex\n" );pthread_mutex_lock( &mutex );sleep( 5 );pthread_mutex_unlock( &mutex );
}void prepare()
{pthread_mutex_lock( &mutex );
}void infork()
{pthread_mutex_unlock( &mutex );
}int main()
{pthread_mutex_init( &mutex, NULL );pthread_t id;pthread_create( &id, NULL, another, NULL );//pthread_atfork( prepare, infork, infork );/*父进程中的主线程暂停1s，以确保在执行fork操作之前，子线程已经开始运行并获得了互斥变量mutex*/sleep( 1 );int pid = fork();if( pid < 0 ){pthread_join( id, NULL );pthread_mutex_destroy( &mutex );return 1;}else if( pid == 0 ){printf( "I anm in the child, want to get the lock\n" );/*子进程从父进程继承了互斥锁mutex的状态，该互斥锁处于锁住的状态，这是由父进程中的子线程执行pthread_mutex_lock引起的，因此，下面这句加锁操作会一直阻塞，尽管从逻辑上来说它是不应该阻塞的*/pthread_mutex_lock( &mutex );printf( "I can not run to here, oop...\n" );pthread_mutex_unlock( &mutex );exit( 0 );}else{pthread_mutex_unlock( &mutex );wait( NULL );}pthread_join( id, NULL );pthread_mutex_destroy( &mutex );return 0;
}

#include <pthread.h>
int pthread_atfork( void (*prepare)(void), void (*parent)(void),void (*child)(void) );

void prepare()
{pthread_mutex_lock( &mutex );
}void infork()
{pthread_mutex_unlock( &mutex );
}pthread_atfork( prepare, infork, infork );

#include <pthread.h>
include <signal.h>
int pthread_sigmask( int how, const sigset_t* newmask, sigset_t* oldmask );

#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <signal.h>
#include <errno.h>/* Simple error handling functions */#define handle_error_en(en, msg) \do { errno = en; perror(msg); exit(EXIT_FAILURE); } while (0)static void *sig_thread(void *arg)
{printf( "yyyyy, thread id is: %ld\n", pthread_self() );sigset_t *set = (sigset_t *) arg;int s, sig;for (;;) {/*第二步骤，调用sigwait等待信号*/s = sigwait(set, &sig);if (s != 0)handle_error_en(s, "sigwait");printf("Signal handling thread got signal %d\n", sig);}
}int main(int argc, char *argv[])
{pthread_t thread;sigset_t set;int s;/*第一步骤，在主线程中设置信号掩码*/sigemptyset(&set);sigaddset(&set, SIGQUIT);sigaddset(&set, SIGUSR1);s = pthread_sigmask(SIG_BLOCK, &set, NULL);if (s != 0)handle_error_en(s, "pthread_sigmask");s = pthread_create(&thread, NULL, &sig_thread, (void *) &set);if (s != 0)handle_error_en(s, "pthread_create");printf( "sub thread with id: %ld\n", thread );pause();            /* Dummy pause so we can test program */
}

#include <signal.h>
int pthread_kill( pthread_t thread, int sig );