Linux线程API的实际操作笔记

第一节：线程的创建

（1）要包含头文件  #include<pthread.h> 

（2）声明用来存放线程ID的变量    pthread_t   ptid;

（3）设计线程处理函数 格式为 type * (funcname)(type * argv)；

（4）创建线程 -->使用函数 pthread_create(&ptid,NULL(使用默认线程属性), (void *) &funcname,(void *)argv )  成功返回0

（5）编译时要连接线程库    -lpthread

第二节：线程的退出

（1）创建线程---》步骤如第一节

（2）在线程处理函数中使用pthread_exit(void * reval)函数退出线程

ps:

#include <stdio.h>
#include <pthread.h>
/*线程退出函数
  pthread_exit(0)
  pthread_join(pthread_t pid,void **infor)//等待线程退出
  pthread_exit(0)的退出码是0， pthread_join()接收到的退出码也是0，它被存放在*info中 
  一个线程不能被多个线程等待，一个线程可以等待多个线程
*/


void *thread(void *argv)
{

        printf("i am a thread \n");
        

        char *a="hello";
        int p=3;
        pthread_exit((void *)a);
        //pthread_exit(9);

}


int main()
{

        pthread_t pid ;
        void *a;
        int b;
        if(pthread_create(&pid,NULL,thread,NULL)!=0)
        {
        
                printf("error\n");
                return -1;
        }

        pthread_join(pid,(void *)&a);
        //pthread_join(pid,&b);
        printf("a=%s\n",(char *)a);
        //printf("b=%d\n",b);
}

第三节：线程的取消

（1）创建两个线程-->> 创建步骤如第一节

（2）设置线程的取消属性

ps:

#include <stdio.h>

#include <pthread.h>

#define DIS1

#define xxx1

/*取消线程函数

  pthread_cancel(pthread_t pid);

*/

void *thread(void *argv)

{

        int a=110;

        while(1)

        {

             sleep(1);

             

             printf("a= %d\n",a);   

        }

        

}

void *thread1(void *argv)

{

       #ifdef DIS 

        //设置该线程不可以被pthread_cancel()取消

        pthread_setcancelstate(PTHREAD_CANCEL_DISABLE,NULL);

       #else

        //线程可以被pthread_cancel()取消

        pthread_setcancelstate(PTHREAD_CANCEL_ENABLE,NULL);

        #endif

        

        

        #ifdef xxx

        //线程在可取消点的时候被pthread_cancel()取消（延迟取消）

        pthread_setcanceltype(PTHREAD_CANCEL_DISABLE,NULL);

       #else

        //线程可以立刻被pthread_cancel()取消

        pthread_setcanceltype( PTHREAD_CANCEL_ASYNCHRONOUS,NULL);

        #endif

        

        

        int a=120;

        while(1)

        {

             sleep(1);

            

             printf("a= %d\n",a);   

        }

        

}

int main()

{

        pthread_t pid,pid1;

        if(pthread_create(&pid,NULL,thread,NULL)!=0)

        {

                printf("error\n");

                return -1;

        }

        if(pthread_create(&pid1,NULL,thread1,NULL)!=0)

        {

                printf("error\n");

                return -1;

        }

        

        sleep(6);

        pthread_cancel(pid);

        pthread_cancel(pid1);

        //因为没有分离线程属性所以取消线程后要使用pthread_join()函数来回收资源

        printf("%d\n",pthread_join(pid,NULL));

        printf("%d\n",pthread_join(pid1,NULL));

        return 0;

}

第四节：线程同步---->互斥锁

（1）创建三个线程---->>创建步骤如第一节所示

（2）声明一个锁 pthread_mutex_t mutex;

（3）初始化锁 pthread_mutex_init(&mutex,NULL)

（4）加锁pthread_mutex_lock(&mutex)

（5）解锁pthread_mutex_unlock(&mutex)

（6）销毁锁 pthread_mutex_destroy(&mutex)

#include <stdio.h>
#include <pthread.h>
#define PIN()   printf("%s:%s():len:%d:is error\n",__FILE__,__FUNCTION__,__LINE__)

/*
互斥锁（用于同步线程，保护公共资源）

注销：int pthread_mutex_destroy(pthread_mutex_t *mutex);
 
第一种初始化锁：int pthread_mutex_init(pthread_mutex_t *restrict mutex,
      const pthread_mutexattr_t *restrict attr(锁的属性));

第二种初始化锁： pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_lock(pthread_mutex_t *mutex),//加锁
pthread_mutex_try‐lock(pthread_mutex_t *mutex),//测试加锁，
pthread_mutex_unlock(pthread_mutex_t *mutex),//解锁
枷锁之后不解锁会造成死锁（灾难性的后果）
*/

pthread_mutex_t mutex;
int global=0;
void *thread1(void *agrc)
{
                pthread_mutex_lock(&mutex);//加锁
                global++;
                printf("i am t1 %d\n",global);
                //sleep(3);
                pthread_mutex_unlock(&mutex);//解锁
                pthread_exit(0);
}

void *thread2(void *agrc)
{
                int a;
                pthread_mutex_lock(&mutex);//加锁
                a=global;
                printf("i am t2 %d\n",a);
                //sleep(3);
                pthread_mutex_unlock(&mutex);//解锁
       
        pthread_exit(0);
}

void *thread3(void *agrc)
{
                sleep(1);
                pthread_mutex_lock(&mutex);//加锁
                global=77;
                printf("i am t3 %d\n",global);
                pthread_mutex_unlock(&mutex);//解锁

        pthread_exit(0);
}


int main()
{
        pthread_t p1;
        pthread_t p2;
        pthread_t p3;
        pthread_mutex_init(&mutex,NULL);
        if(0!=pthread_create(&p1,NULL,thread1,NULL))
        {
                PIN();
                return -1;
        }
        if(0!=pthread_create(&p2,NULL,thread2,NULL))
        {
                PIN();
                return -1;
        }
        if(0!=pthread_create(&p3,NULL,thread3,NULL))
        {
                PIN();
                return -1;
        }
        
        
        pthread_join(p1,NULL);
        pthread_join(p2,NULL);
        pthread_join(p3,NULL);
        pthread_mutex_destroy(&mutex);
        return 0;
}

第五节：解决死锁问题

（1）创建线程---->创建步骤如第一节所示

（2）创建互斥锁--->创建步骤如第四节所示

（3）使用解决死锁问题的处理函数

phtread_cleanup_push(void (*name)(void *argv),(void *)argv)

pthread_cleanup_pop(0(一般都为0));

ps

#include <stdio.h>
#include <pthread.h>
#define PIN()   printf("%s:%s():len:%d:is error\n",__FILE__,__FUNCTION__,__LINE__)
#define UNT   (unsigned int )

/**解决死锁问题
 void pthread_cleanup_push(void (*routine)(void *),
                                 void *arg);
       void pthread_cleanup_pop(int execute);
互斥锁（用于同步线程，保护公共资源）
注销：int pthread_mutex_destroy(pthread_mutex_t *mutex);
 
第一种初始化锁：int pthread_mutex_init(pthread_mutex_t *restrict mutex,
      const pthread_mutexattr_t *restrict attr(锁的属性));


第二种初始化锁： pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_lock(pthread_mutex_t *mutex),//加锁
pthread_mutex_try‐lock(pthread_mutex_t *mutex),//测试加锁，
pthread_mutex_unlock(pthread_mutex_t *mutex),//解锁


枷锁之后不解锁会造成死锁（灾难性的后果）


*/
pthread_mutex_t mutex;
int global=0;

void unlock_mutex(void *argv)
{
        pthread_mutex_unlock((pthread_mutex_t *)argv);
        printf("id=%u unlock mutex\n",UNT pthread_self());
}

void *thread1(void *argv)
{
       int i=5;
        while(i)
        {
                sleep(1);
                i--;
                printf("i=%d\n",i);
        }
        
       
}

void *thread2(void *argv)
{
        printf("thread2=%u\n",UNT pthread_self());
        //如果没有死锁处理的函数的话将会造成程序无法继续运行
        pthread_cleanup_push(unlock_mutex,(void *)&mutex);
        global=8;
        pthread_mutex_lock(&mutex);
        sleep(4);
        printf("global=%d\n",global);
        pthread_mutex_unlock(&mutex);
        pthread_cleanup_pop(0);
}


void *thread3(void *argv)
{
        printf("thread3=%u\n",UNT pthread_self());
        //如果没有死锁处理的函数的话将会造成程序无法继续运行
        pthread_cleanup_push(unlock_mutex,(void *)&mutex);
        global=1;
        pthread_mutex_lock(&mutex);
        sleep(4);
        printf("global=%d\n",global);
        pthread_mutex_unlock(&mutex);
        pthread_cleanup_pop(0);
}

int main()
{
        pthread_t p1,p2,p3;
        pthread_mutex_init(&mutex,NULL);
        
        if(pthread_create(&p1,NULL,(void *)thread1,NULL)!=0)
        {
                PIN();
                return -1;
        }
        if(pthread_create(&p2,NULL,(void *)thread2,NULL)!=0)
        {
                PIN();
                return -1;
        }
        if(pthread_create(&p3,NULL,(void *)thread3,NULL)!=0)
        {
                PIN();
                return -1;
        }
        
        sleep(2);
        printf("global=%d\n",global);
        //pthread_cancel(p1);
        pthread_cancel(p2);
        pthread_cancel(p3);
       
        pthread_join(p1,NULL);
        pthread_join(p2,NULL);
        pthread_join(p3,NULL);
        
        pthread_mutex_destroy(&mutex);
        return 0;
}