多线程pthread使用

 

pthread_create是操作系统创建线程的函数。它的功能是创建线程，线程创建之后，执行对应的线程函数。

1、pthread_create
头文件：#include <pthread.h>
原型：int pthread_create(pthread_t *tidp,const pthread_attr_t *attr,
(void*)(*start_rtn)(void*),void *arg);
作用：创建一个线程
编译链接参数：-lpthread
返回值：线程创建成功返回0，创建失败返回错误编号。
参数：参数一为线程标识符的指针
     参数二表示线程熟悉，一般为NULL
     参数三为线程运行函数的起始地址
     参数四为运行函数的参数

2、pthread_join
头文件：#include <pthread.h>
原型：int pthread_join(pthread_t thread, void **retval);
作用：阻塞当前线程等待指定的线程执行结束
返回值：成功返回0，失败返回错误号
参数：参数一表示线程标识符
     参数二表示线程thread所执行的函数返回值（返回值地址需要保证有效），其中status可以为NULL。

可以看出pthread_join()有两种作用：

• 用于等待其他线程结束：当调用 pthread_join() 时，当前线程会处于阻塞状态，直到被调用的线程结束后，当前线程才会重新开始执行。
• 对线程的资源进行回收：如果一个线程是非分离的（默认情况下创建的线程都是非分离）并且没有对该线程使用 pthread_join() 的话，该线程结束后并不会释放其内存空间，这会导致该线程变成了“僵尸线程”。

3、pthread_mutex_init
头文件：#include <pthread.h>
原型：int pthread_mutex_init(pthread_mutex_t *restrict mutex,const pthread_mutexattr_t *restrict attr);
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
作用：用于多线程编程时，互斥锁的初始化
返回值：成功返回0，失败返回其他值
参数：参数一为锁变量
     参数二为锁属性，NULL值表示默认属性

4、pthread_mutex_lock
头文件：#include <pthread.h>
原型：int  pthread_mutex_lock(pthread_mutex_t *mutex)
作用：加锁

5、pthread_mutex_unlock
头文件：#include <pthread.h>
原型：int pthread_mutex_unlock(pthread_mutex_t *mutex)
作用：解锁

6、pthread_mutex_destroy
原型：int  pthread_mutex_destroy(pthread_mutex_t *mutex);
作用：使用完后释放

7、死锁

死锁主要发生在有多个依赖锁存在时, 会在一个线程试图以与另一个线程相反顺序锁住互斥量时发生. 如何避免死锁是使用互斥量应该格外注意的东西。

　　总体来讲, 有几个不成文的基本原则:

　　对共享资源操作前一定要获得锁。

　　完成操作以后一定要释放锁。

　　尽量短时间地占用锁。

　　如果有多锁, 如获得顺序是ABC连环扣, 释放顺序也应该是ABC。

　　线程错误返回时应该释放它所获得的锁。

 

多线程pthread使用时两种释放方法：

1、使用pthread_join
#include <stdio.h>
#include <pthread.h>
void *add1()
{
    //pthread_detach(pthread_self());
    printf("AAAAA\n");
    pthread_exit(NULL);
    return;
}
int main()
{
    int i = 0;
    for(i = 0; i < 100; i++)
    {
        pthread_t t1 = 0;
        pthread_create(&t1, NULL, add1, NULL);
        sleep(1);
        pthread_join(t1, NULL);
    }
    return;
}

2、使用pthread_detach(pthread_self());
#include <stdio.h>
#include <pthread.h>
void *add1()
{
    pthread_detach(pthread_self());
    printf("AAAAA\n");
    pthread_exit(NULL);
    return;
}
int main()
{
    int i = 0;
    for(i = 0; i < 100; i++)
    {
        pthread_t t1 = 0;
        pthread_create(&t1, NULL, add1, NULL);
        sleep(1);
        //pthread_join(t1, NULL);
    }
    return;
}

pthread_detach()使主线程与子线程分离，两者相互不干涉，子线程结束的同时子线程的资源由系统自动回收。

pthread_join()即是子线程合入主线程，主线程会一直阻塞，直到子线程执行结束，然后回收子线程资源，并继续执行。

所以每个进程创建以后都应该调用pthread_join 或 pthread_detach 函数，只有这样在线程结束的时候线程的独有资源(线程的描述信息和stack)才能被释放，不然必会造成内存泄漏。

 

pthread互斥锁的使用

#include <stdio.h>
#include <pthread.h>
pthread_mutex_t mutex;
void *add1()
{
    pthread_mutex_lock(&mutex);
    int i = 0;
    for(i = 0; i < 5; i++)
    {
        printf("AAAAA\n");
        sleep(1);
    }
    pthread_mutex_unlock(&mutex);
    pthread_exit(NULL);
    return;
}
void *add2()
{   
    //pthread_detach(pthread_self());
    pthread_mutex_lock(&mutex);
    int i = 0; 
    for(i = 0; i < 5; i++)
    {   
        printf("BBBBB\n");
        sleep(1);
    }
    pthread_mutex_unlock(&mutex);
    pthread_exit(NULL);
    return;
}
int main()
{   
    int i = 0;
    pthread_mutex_init(&mutex, NULL);
    for(i = 0; i < 100; i++)
    {   
        pthread_t t1 = 0;
        pthread_t t2 = 0;
        pthread_create(&t1, NULL, add1, NULL);
        pthread_create(&t2, NULL, add2, NULL);
        sleep(1);
        pthread_join(t1, NULL);
        pthread_join(t2, NULL);
    }
    pthread_mutex_destroy(&mutex);
    return;
}

参考：

https://blog.csdn.net/wushuomin/article/details/80051295

https://blog.csdn.net/yzy1103203312/article/details/80849831

https://www.cnblogs.com/muhe221/articles/4848393.html

 

互斥锁：

https://www.cnblogs.com/eustoma/p/10054783.html