linux 线程接口函数

 pthread_t 在头文件/usr/include/bits/pthreadtypes.h中定义

typedef unsigned long int pthread_t;

编译多线程程序时，需要 libpthread.a, 所以要使用 -lpthread 选项。

创建线程函数

       #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);

pthread_join() 函数是一个阻塞函数，调用该函数的函数会被阻塞，直到被等待的线程执行结束为止，当函数返回时，被等待的线程资源将被系统回收。

pthread_exit() 和 pthread_join() 是线程退出的2种结束方式。

线程属性

线程属性 pthread_attr_t

union pthread_attr_t                                                                                                                                       
{
  char __size[__SIZEOF_PTHREAD_ATTR_T];
  long int __align;
};
#ifndef __have_pthread_attr_t
typedef union pthread_attr_t pthread_attr_t;
# define __have_pthread_attr_t 1
#endif

线程属性的初始化和销毁函数

       #include <pthread.h>

       int pthread_attr_init(pthread_attr_t *attr);
       int pthread_attr_destroy(pthread_attr_t *attr);

线程属性不能直接设置， 要通过函数间接执行相关操作。线程的属性主要有：是否分离、是否绑定、优先级、堆栈大小、堆栈位置。默认的属性是非绑定、非分离、1M的堆栈大小与父进程相同的优先级。

互斥锁

pthread_mutex_t 类型为线程互斥锁类型

/* Initialize a mutex.  */
extern int pthread_mutex_init (pthread_mutex_t *__mutex,
                   const pthread_mutexattr_t *__mutexattr)
     __THROW __nonnull ((1));

/* Destroy a mutex.  */
extern int pthread_mutex_destroy (pthread_mutex_t *__mutex)
     __THROW __nonnull ((1));

/* Try locking a mutex.  */
extern int pthread_mutex_trylock (pthread_mutex_t *__mutex)
     __THROWNL __nonnull ((1));

/* Lock a mutex.  */
extern int pthread_mutex_lock (pthread_mutex_t *__mutex)
     __THROWNL __nonnull ((1));

/* Unlock a mutex.  */
extern int pthread_mutex_unlock (pthread_mutex_t *__mutex)
     __THROWNL __nonnull ((1));

也可以声明/设置带有属性的互斥锁，

/* Initialize mutex attribute object ATTR with default attributes
   (kind is PTHREAD_MUTEX_TIMED_NP).  */
extern int pthread_mutexattr_init (pthread_mutexattr_t *__attr);

/* Destroy mutex attribute object ATTR.  */                                                                                                                  
extern int pthread_mutexattr_destroy (pthread_mutexattr_t *__attr);

/* Set the process-shared flag of the mutex attribute ATTR.  */
extern int pthread_mutexattr_setpshared (pthread_mutexattr_t *__attr,int __pshared);

条件变量

extern int pthread_cond_init (pthread_cond_t *__restrict __cond,                                                                                             
                  const pthread_condattr_t *__restrict __cond_attr);
extern int pthread_cond_destroy (pthread_cond_t *__cond);
/* Wake up one thread waiting for condition variable COND.  */
extern int pthread_cond_signal (pthread_cond_t *__cond);

/* Wake up all threads waiting for condition variables COND.  */
extern int pthread_cond_broadcast (pthread_cond_t *__cond);

/* Wait for condition variable COND to be signaled or broadcast.
   MUTEX is assumed to be locked before. */

extern int pthread_cond_wait (pthread_cond_t *__restrict __cond,
                  pthread_mutex_t *__restrict __mutex);

/* Wait for condition variable COND to be signaled or broadcast until
   ABSTIME.  MUTEX is assumed to be locked before.  ABSTIME is an
   absolute time specification; zero is the beginning of the epoch
   (00:00:00 GMT, January 1, 1970). */

extern int pthread_cond_timedwait (pthread_cond_t *__restrict __cond,
                   pthread_mutex_t *__restrict __mutex,
                   const struct timespec *__restrict __abstime);