Linux线程相关API以及运用

线程与进程的区别

https://www.cnblogs.com/xiehongfeng100/p/4620852.html

API

线程
int pthread_create(pthread_t *restrict tidp, const pthread_attr_t *restrict attr, void *(*start_rtn)(void *), void *restrict arg);
int pthread_exit(void *rval_ptr);
int pthread_join(pthread_t thread, void **rval_ptr);
pthread_t pthread_self(void);//获取线程ID
互斥锁
int pthread_mutex_init(pthread_mutex_t *restrict mutex, const pthread_mutexattr_t *restrict attr);
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);
条件
int pthread_cond_init(pthread_cond_t *restrict cond, const pthread_condattr_t *restrict attr);
int pthread_cond_destroy(pthread_cond_t cond);
int pthread_cond_wait(pthread_cond_t *restrict cond, pthread_mutex_t *restrict mutex);
int pthread_cond_timedwait(pthread_cond_t *restrict cond, pthread_mutex_t *restrict mutex, cond struct timespec *restrict timeout);
int pthread_cond_broadcast(pthread_cond_t cond);
int pthread_cond_signal(pthread_cond_t cond);

• pthread_create函数其中 参数一由tidp指向的内存单元被设置为新创建线程的线程ID，由于phread_t为长整型，因此打印大时候要以ld打印，参数二attr用于定制各种不同的线程属性，暂可以把它设置为NULL，以创建默认属性的线程，新创建的线程从参数三start_rtn函数的地址开始运行，该函数只有一个无类型指针参数arg。如果需要向start_rtn函数传递的参数不止一个，那么需要把这些参数放到一个结构中，然后把这个结构的地址作为arg参数传入。
• pthread_exit函数其中的参数可以存储退出值的地址，rval_ptr是一个无类型指针，与传给启动例程的单个参数类似。进程中的其他线程可以通过调用pthread_join函数访问到这个指针。
• pthread_join函数参数一为线程ID，调用这个函数后会阻塞到线程执行pthread_exit函数，设置rval_ptr可以的到退出值，如果对退出值不感兴趣的话就设置为NULL。

新建一个线程以及等待退出

void *func1(void *arg)
{
//      static int ret = 10;

        static char *p="xiao ma ";
        printf("t1:%ld thread is create\n",(unsigned long)pthread_self());
        printf("t1:parm is %d\n",*((int *)arg));

//      pthread_exit((void *)&ret);
        pthread_exit((void *)p);
}

int main()
{
        int ret;
        int param = 100;
        pthread_t t1;
//      int *pret=NULL;
        char *pret=NULL;

        ret=pthread_create(&t1,NULL,func1,(void *)&param);
        if(ret == 0){
                printf("main:creat t1 success\n");
        }

        printf("main:%ld\n",(unsigned long)pthread_self());
        //while(1);
        pthread_join(t1,(void **)&pret);//获取线程退出的值

        printf("main: t1 quit:%s\n",pret);

        return 0;
}

使用互斥锁双线程数据同步

int g_data = 0;

pthread_mutex_t mutex;

void *func1(void *arg)
{
        pthread_mutex_lock(&mutex);
        printf("t1:%ld thread is create\n",(unsigned long)pthread_self());
        printf("t1:parm is %d\n",*((int *)arg));
        while(1){
                printf("t1:%d\n",g_data++);
                sleep(1);
                if(g_data==3){
                        pthread_mutex_unlock(&mutex);
                        printf("t1 quit -------");
                        pthread_exit(NULL);
//                      exit(0);
                }
        }
}

void *func2(void *arg)
{
        printf("t2:%ld thread is create\n",(unsigned long)pthread_self());
        printf("t2:parm is %d\n",*((int *)arg));
        while(1){
                printf("t2:%d\n",g_data);
                pthread_mutex_lock(&mutex);
                g_data++;
                pthread_mutex_unlock(&mutex);
                sleep(1);
                }
}
int main()
{
        int ret;
        int param = 100;
        pthread_t t1;
        pthread_t t2;

        pthread_mutex_init(&mutex,NULL);
        ret=pthread_create(&t1,NULL,func1,(void *)&param);
        if(ret == 0){
                printf("main:creat t1 success\n");
        }

        ret=pthread_create(&t2,NULL,func2,(void *)&param);
        if(ret == 0){
                printf("main:creat t2 success\n");
        }
        printf("main:%ld\n",(unsigned long)pthread_self());
        pthread_join(t1,NULL);
        pthread_join(t2,NULL);

        pthread_mutex_destroy(&mutex);

        return 0;
}

fun1与fun2谁先得锁不知道，但一旦fun1得锁就需要使得g_data到打3时才能解锁，退出的时候需要使用pthread_exit，线程中使用exit会使整个进程退出

线程条件加互斥锁

#include "pthread.h"
#include "stdlib.h"
#include "stdio.h"

//int pthread_create(pthread_t *restrict tidp, const pthread_attr_t *restrict attr, void *(*start_rtn)(void *), void *restrict arg);
int g_data = 0;

pthread_mutex_t mutex=PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond=PTHREAD_COND_INITIALIZER;

void *func1(void *arg)
{
        printf("t1:%ld thread is create\n",(unsigned long)pthread_self());
        printf("t1:parm is %d\n",*((int *)arg));
        static int cnt = 0;
        while(1){
                pthread_mutex_lock(&mutex);
                pthread_cond_wait(&cond,&mutex);
                printf("t1 run -------\n");

                printf("t1:%d\n",g_data);
                g_data=0;
                sleep(1);
                if(cnt++==10) exit(1);
                pthread_mutex_unlock(&mutex);
        }
}

void *func2(void *arg)
{
        printf("t2:%ld thread is create\n",(unsigned long)pthread_self());
        printf("t2:parm is %d\n",*((int *)arg));
        while(1){
                printf("t2:%d\n",g_data);
                pthread_mutex_lock(&mutex);
                g_data++;
                if(g_data==3){
                        pthread_cond_signal(&cond);
                }
                pthread_mutex_unlock(&mutex);
                sleep(1);
        }
}

int main()
{
        int ret;
        int param = 100;
        pthread_t t1;
        pthread_t t2;

//      pthread_mutex_init(&mutex,NULL);
//      pthread_cond_init(&cond,NULL);
        ret=pthread_create(&t1,NULL,func1,(void *)&param);
        if(ret == 0){
//              printf("main:creat t1 success\n");
        }

        ret=pthread_create(&t2,NULL,func2,(void *)&param);
        if(ret == 0){
//              printf("main:creat t2 success\n");
        }
//      printf("main:%ld\n",(unsigned long)pthread_self());
        pthread_join(t1,NULL);
        pthread_join(t2,NULL);

        pthread_mutex_destroy(&mutex);
        pthread_cond_destroy(&cond);
        return 0;
}

pthread_mutex_t mutex=PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond=PTHREAD_COND_INITIALIZER;
两个宏分别为互斥锁和条件初始化
对于上述深入理解pthread_cond_wait、pthread_cond_signal
例如

              pthread_mutex_lock(&mut);
              while (x <= y) {
                      pthread_cond_wait(&cond, &mut);
              }
              /* operate on x and y */
              pthread_mutex_unlock(&mut);

和：       pthread_mutex_lock(&mut);
              /* modify x and y */
              if (x > y) pthread_cond_signal(&cond);
              pthread_mutex_unlock(&mut); 

其实函数的执行过程非常简单，在第一个线程执行到pthread_cond_wait(&cond,&mut)时，此时如果X<=Y，则此函数就将mut互斥量解锁 ，再将cond条件变量加锁 ，此时第一个线程挂起 （不占用任何CPU周期）。
而在第二个线程中，本来因为mut被第一个线程锁住而阻塞，此时因为mut已经释放，所以可以获得锁mut，并且进行修改X和Y的值，在修改之后，一个IF语句判定是不是X>Y，如果是，则此时pthread_cond_signal()函数会唤醒第一个线程 ，并在下一句中释放互斥量mut。然后第一个线程开始从pthread_cond_wait()执行，首先要再次锁mut ， 如果锁成功，再进行条件的判断 （至于为什么用WHILE，即在被唤醒之后还要再判断，后面有原因分析），如果满足条件，则被唤醒 进行处理，最后释放互斥量mut 。