Linux线程的创建和基本操作

线程是什么？

线程是操作系统进行调度运算的最小单位，它包含在进程之中，一个进程中可以有多个并发线程，比如银行是一个进程，那么银行里面的服务小窗口就是线程，进程的所有信息对于线程都是共享的。

为什么要使用线程？

使用多线程的理由之一，跟进程相比，它是非常节俭的多任务操作方式。在linux系统下面，执行一个新进程必须分配给他地址空间，并且还要维护它的代码段，数据段，堆栈段。这是非常昂贵的工作方式。而运行一个进程中的多个线程，他们都使用的是同一个空间，共享大部分数据，启动一个进程的空间远远大于启动一个线程的空间。而且进程间彼此切换也远远大于线程间切换所需要的时间。

使用多线程的理由之二，线程间通信方便，同一进程下的线程由于共享数据，所以一个线程的数据可以直接被其它线程所用。

一.线程相关的接口

1.头文件

#include<pthread.h>

2.创建线程

函数原型如下

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

参数一：是一个phread_t类型的指针，线程标识符

参数二：是线程属性，无特殊需求一般填NULL

参数三：是线程执行的函数，

参数四：是参数

3.终止线程

int pthread_exit(void *rval_ptr);

参数 rval_ptr 是返回信息，可以写也可以不写。

4.等待线程

为了防止主函数已经执行完了，线程还未执行，调用这个函数，主函数会一直阻塞在这，知道线程调用pthread_exit这个函数。

int pthread_join(pthread_t thread, void **rval_ptr);

参数一： 线程标识符

参数二：接受的返回值

5.获取线程ID

pthread_t pthread_self(void);

返回值，调用线程的id；

6.示例代码

#include<pthread.h>
#include<stdio.h>

void *Si_yuan(void *arg)
{
        printf("我叫李思源，我是明德第一GAY\n");  
        long id = pthread_self();//获取线程id
        printf("我的ID号是：%ld\n",id);
        pthread_exit(NULL);//退出
}

int main()
{
    pthread_t t1;
    int ret;
    ret = pthread_create(&t1,NULL,Si_yuan,NULL);//创建线程
    if(ret == 0)//判断是否创建成功
    {
        printf("create success\n");//创建成功打印信息
    }

    pthread_join(t1,NULL);//等待
    return 0;
}

二.互斥锁

互斥锁，类似于一把锁，在进入房间前对门（互斥量）进行加锁，知道在在里面办事情后，出来对门（互斥量）解锁。对门（互斥量）加锁后，其他线程想再次对门加锁的线程都会被阻塞，直到当前线程办完事出来对门（互斥量）解锁。

1.初始化

使用互斥锁之前必须初始化。

初始化的方式有两种，如下

pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;//1、使用特定的宏

pthread_mutex_t mutex;//2、调用初始化的函数
pthread_mutex_init(&mutex , NULL);

2.创建互斥锁

int pthread_mutex_init(pthread_mutex_t *restrict mutex, const pthread_mutexattr_t *restrict attr);

参数一：为pthread_mutex_t数据类型指针。

参数二：属性。

创建互斥锁也可是使用宏定义来静态初始话，如下

pthread_mutex_t mutex =  PTHREAD_MUTEX_INITIALIZER

3.销毁互斥锁

如果调用函数创建的锁则要要通过以下函数销毁。

int pthread_mutex_destroy(pthread_mutex_t *mutex);

参数：表示要销毁的互斥锁。

4.对互斥量加锁

int pthread_mutex_lock(pthread_mutex_t mutex);

参数与互斥锁参数一的一致。

5.对互斥量解锁

int pthread_mutex_unlock(pthread_mutex_t mutex);

参数与互斥锁参数一的一致

6.示例代码

#include<pthread.h>
#include<stdio.h>


int data = 0;

void *Si_yuan(void *arg)//思源线程
{
        printf("我叫李思源，我是明德第一GAY\n");  
        long id = pthread_self();//获取线程id
        printf("我的ID号是：%ld\n",id);

        pthread_mutex_lock(&mutex);//加锁
        while(1)
        {
            printf("t1    data = %d\n",data++);
            printf("梓椿是GAY\n");//先让思源说3遍梓椿是GAY，在解锁
            sleep(1);
            if(data == 3)等于3遍
            {
                pthread_mutex_unlock(&mutex);解锁
            }
        }
       
}



void *Zi_chun(coid *arg)//死gay线程
{
        pthread_mutex_lock(&mutex);//加锁等待思源说完
        printf("我叫张梓椿，我是明德第二GAY\n");  
        long id = pthread_self();//获取线程id
        printf("我的ID号是：%ld\n",id);
        while(1)
        {
            printf("t1    data = %d\n",data++);
            printf("你才是GAY\n");
            sleep(1);
            pthread_mutex_unlock(&mutex);//解锁
        }
    
}



int main()
{
    pthread_mutex_t mutex;

    pthread_mutex_init(&mutex，NULL);//创建互斥锁
    pthread_t t1;
    pthread_t t2;

    int ret;
    int ret2;

    ret = pthread_create(&t1,NULL,Si_yuan,NULL);//创建线程
    if(ret == 0)//判断是否创建成功
    {
        printf("create success\n");//创建成功打印信息
    }

    ret2 = pthread_create(&t2,NULL,Zi_chun,NULL);//创建第二个线程
    if(ret2 == 0)//判断是否创建成功
    {
        printf("create success\n");//创建成功打印信息
    }


    pthread_join(t1,NULL);//等待t1线程返回
    pthread_join(t2,NULL);//等待t2线程返回
    pthread_mutex_destroy(&mutex);//销毁互斥锁

    return 0;
}

三.条件变量

条件变量通常搭配互斥锁一起使用，因为互斥锁只有锁和非锁两种状态，而条件变量可以通过，线程阻塞，等待其他线程来唤醒。所以互斥锁和条件变量通常一起使用。

例如：

定义一个全局变量 data = 0；

给A进程设定一个（data = 5）条件，达到条件后才能运行。

这时进程开始执行，但由于A进程没有达到条件（data = 5），所以一直阻塞在这个地方。

B进程则一直在跑 data++，

等到B进程一直执行data =5 的时候，唤醒A进程，接下来A进程才能执行。

条件变量相关的接口

1.创建条件变量。

条件变量使用之前必须要初始化，pthread_cond_t的数据类型，可以使用静态的宏PTHREAD_COND_INITIALIZER。

int pthread_cond_init(pthread_cond_t *restrict cond, const pthread_condattr_t *restrict attr);

参数一：为pthread_cond_t的数据类型。

参数二为属性。

2.销毁条件变量

如果使用动态分配的就要使用下面的函数来释放。

int pthread_cond_destroy(pthread_cond_t *cond);

参数，表示要摧毁的条件变量，

3.等待

当条件不成立时一直阻塞该线程。

int pthread_cond_wait(pthread_cond_t *restrict cond, pthread_mutex_t *restrict mutex);

参数一：表示已初始化好的条件变量，

参数二：表示与条件变量搭配的互斥锁。

4.触发

pthread_cond_signal函数将唤醒等待该条件的某个线程，

int pthread_cond_signal(pthread_cond_t cond);

5.示例代码

#include<pthread.h>
#include<stdio.h>


int data = 0;

void *Si_yuan(void *arg)//思源线程
{
        printf("我叫李思源，我是明德第一GAY\n");  
        long id = pthread_self();//获取线程id
        printf("我的ID号是：%ld\n",id);
        pthread_mutex_lock(&mutex);
        while(1)
        {    
             pthread_cond_wait(&cond,&mutex); //添加条件变量
             printf("-----------------梓椿时GAY---------------------\n");
             printf("t1    data = %d\n",data++);
            sleep(1);
        
        }
        
       
}



void *Zi_chun(coid *arg)//死gay线程
{
       
        printf("我叫张梓椿，我是明德第二GAY\n");  
        long id = pthread_self();//获取线程id
        printf("我的ID号是：%ld\n",id);
        while(1)
        {
            printf("t2    data = %d\n",data++);
            pthread_mutex_lock(&mutex);
            if(data == 4)
            {
                    pthread_cond_signal(&cond);
            }
            sleep(1);
            pthread_mutex_unlock(&mutex);//解锁
        }
    
}



int main()
{
    pthread_mutex_t mutex;
    pthread_cond_t  cond;

    pthread_cond_init(&cond,NULL);//创建条件变量
    pthread_mutex_init(&mutex，NULL);//创建互斥锁
    pthread_t t1;
    pthread_t t2;

    int ret;
    int ret2;

    ret = pthread_create(&t1,NULL,Si_yuan,NULL);//创建线程
    if(ret == 0)//判断是否创建成功
    {
        printf("create success\n");//创建成功打印信息
    }

    ret2 = pthread_create(&t2,NULL,Zi_chun,NULL);//创建第二个线程
    if(ret2 == 0)//判断是否创建成功
    {
        printf("create success\n");//创建成功打印信息
    }


    pthread_join(t1,NULL);//等待t1线程返回
    pthread_join(t2,NULL);//等待t2线程返回
    pthread_mutex_destroy(&mutex);//销毁互斥锁
    pthread_cond_destroy(&cond);//销毁条件变量
    return 0;
}