多线程

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的参数

#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：线程退出的返回值的指针

#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）。

#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就是不执行。

#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。