Linux线程

线程

进程和线程的区别？进程，创建进程的时候会拷贝一份父进程的代码段、数据段、堆栈等给子进程，如果想用多个进程的话，这样会浪费特别多的内存，而线程就是相当于寄生在一个进程里面的东西，它共享进程的所有资源，不会在拷贝进程的代码段、数据段、堆栈等，大大减少了内存的浪费，因为线程是寄生在进程上的，只要进程退出，线程也会全部退出。main函数是主线程，在创建第一个线程

在Linux里面并没有pthread,所以编译的话 -pthread pthread(第三方库)

pthread_create	pthread_self（返回线程的ID）	pthread_exit	pthread_join

pthread-create创建线程

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

brief：创建线程

param：pthread_t ,是一个unsigned long类型，restrict,这个线程的id，restrict_attr,线程属性，一般用NULL，第三个参数是一个函数指针指向要处理的函数，第四个参数，可以跟线程传参

return：返回0，创建成功

pthread_join等待线程

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

brief：调用了pthread_join函数，会称为阻塞状态，只有当调用的线程结束后，才退出

param：第一个参数，即要调用的线程id，第二个用于接收线程的返回码，也可以直接写NULL

return：0成功，非0失败

pthread_exit线程退出

void pthread_exit( void * value_ptr );

brief:线程的退出

param:value_ptr,即指向线程退出的返回码

return:

#include <stdio.h>
#include <pthread.h>
​
void * handler(void * arg)
{
        static int ret = 1;
​
        printf("tid:%ld\n",(unsigned long)pthread_self());
        printf("t1_param:%d\n",*(int *)arg);
        pthread_exit((void *)&ret);
}
​
​
void main()
{
        pthread_t t1;//unsigned long
        int panduan;
        int param = 666;
        int * ret;
​
        panduan = pthread_create(&t1,NULL,handler,(void *)&param);
        if(panduan == 0)
        {
                printf("pthread creat succeed!\n");
        }
​
        printf("main_tid:%ld\n",(unsigned long)pthread_self());
​
        pthread_join(t1,(void **)&ret);
​
        printf("main:t1_ret:%d\n",*ret);
​
}
输出结果：
pthread creat succeed!
main_tid:140327588333376
tid:140327579809536
t1_param:666
main:t1_ret:1  

如果有多个线程都有用互斥锁，他没有用条件变量，也是按照随机顺序执行

pthread_mutex_intt初始化互斥锁

pthread_mutex_t mutex;//创建一把互斥锁，pthread_mutex_t,是一个结构体

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

brief：初始化一把互斥锁，互斥锁的作用就是保护共享资源的完整性，加锁过后一次性只能一个线程访问

param：restrict mutex，要初始化的互斥锁，第二个参数，NULL

return:

pthread_mutex_lock/pthread_mutex_unlock加锁/解锁

int pthread_mutex_lock(pthread_mutex_t *mutex);

int pthread_mutex_unlock(pthread_mutex_t *mutex);

brief:对需要操作的共享资源进行加锁或解锁，这样就可以只能一个线程访问共享资源

param：传入要加的锁的地址

return：成功返回0

pthread_mutex_destroy销毁锁

int pthread_mutex_destroy(pthread_mutex_t *mutex);

brief“：销毁锁

param：传入需要销毁锁的地址

return:

#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
​
pthread_mutex_t mutex;//struct
​
int a = 0;
​
void * handler1(void * arg)
{
​
        pthread_mutex_lock(&mutex);
​
        while(1)
        {
                printf("t1:%d\n",a++);
                sleep(1);
​
​
                if(a == 5)
                {       printf("---------t1_quit---------\n");
                        pthread_mutex_unlock(&mutex);
                        pthread_exit(NULL);
                }
        }
​
​
}
​
void *handler2(void *arg)
{
​
        while(1)
        {
                pthread_mutex_lock(&mutex);
​
                printf("t2:%d\n",a++);
                sleep(1);
                pthread_mutex_unlock(&mutex);
​
        }
​
}
​
​
void main()
{
        pthread_t t1;//unsigned long
        pthread_t t2;
        int panduan;
​
        pthread_mutex_init(&mutex,NULL);
​
        panduan = pthread_create(&t1,NULL,handler1,NULL);
        if(panduan == 0)
        {
                printf("t1 pthread creat succeed!\n");
        }
​
        panduan = pthread_create(&t2,NULL,handler2,NULL);
        if(panduan == 0)
        {
                printf("t2 pthread creat succeed!\n");
        }
​
​
        printf("main_tid:%ld\n",(unsigned long)pthread_self());
​
        pthread_join(t1,NULL);
        pthread_join(t2,NULL);
​
        pthread_mutex_destroy(&mutex);  //销毁锁
​
​
​
}