4 线程

线程：轻量化的进程

　　优点：CPU在多线程中切换资源占用时间会缩短
　　缺点：多线程具有共享空间，操作共享数据时需要加入同步和互斥机制

线程共享空间
　　每个线程具有独立的文本段和系统数据段，但是一个进程中所有线程共享同一数据段
　　优点：方便多线程间通信
　　缺点：共享空间中数据可能被更改，有风险
pthread_create.c

/* 线程：轻量化的进程
 * 优点：CPU在多线程中切换资源占用时间会缩短
 * 缺点：多线程具有共享空间，操作共享数据时需要加入同步和互斥机制
 *
 * 线程共享空间
 * 每个线程具有独立的文本段和系统数据段，但是一个进程中所有线程共享同一数据段
 * 优点：方便多线程间通信
 * 缺点：共享空间中数据可能被更改，有风险
 * */
#include <stdio.h>
#include <pthread.h>
void *thread(void *arg)/*线程函数*/
{
    while(1)
    {
        printf("我是线程!\n");
            sleep(1);
    }
    return NULL;
}

int main(void)
{
    /*在调用进程中创建一个线程  
     * int pthread_create(pthread_t *thread, const pthread_attr_t *attr,
     *                   void *(*start_routine) (void *), void *arg);
     * 参数：  
     * thread:保存线程ID空间的首地址
     * attr:线程的属性
     * start_routine:线程函数的首地址
     * arg:给线程函数传递的参数
     *成功返回0；失败返回非0。
     * */
    pthread_t tid;
    if(0 != (pthread_create(&tid,NULL,thread,NULL)))
    {
            perror("fail to pthread_create!");
            return -1;
    }

    getchar();
    return 0;
}

pthread_create1.c

/* 线程：轻量化的进程
 * 优点：CPU在多线程中切换资源占用时间会缩短
 * 缺点：多线程具有共享空间，操作共享数据时需要加入同步和互斥机制
 *
 * 线程共享空间
 * 每个线程具有独立的文本段和系统数据段，但是一个进程中所有线程共享同一数据段
 * 优点：方便多线程间通信
 * 缺点：共享空间中数据可能被更改，有风险
 * */
#include <stdio.h>
#include <pthread.h>
int a = 20;
void *thread1(void *arg)/*线程函数*/
{
    int count = 0;
    while(1)
    {
        printf("我是线程1  a = %d\n",a);
        if(count == 5) a = 666;
            sleep(1);
            count++;
    }
    return NULL;
}
void *thread2(void *arg)
{
    while(1)
    {
        printf("我是线程2 a = %d\n",a);
        sleep(1);
    }
    return NULL;

}

int main(void)
{
    /*在调用进程中创建一个线程  
     * int pthread_create(pthread_t *thread, const pthread_attr_t *attr,
     *                   void *(*start_routine) (void *), void *arg);
     * 参数：  
     * thread:保存线程ID空间的首地址
     * attr:线程的属性
     * start_routine:线程函数的首地址
     * arg:给线程函数传递的参数
     *成功返回0；失败返回非0。
     * */
    pthread_t tid1,tid2;
    if(0 != (pthread_create(&tid1,NULL,thread1,NULL)))
    {
            perror("fail to pthread_create!");
            return -1;
    }

    if(0 != (pthread_create(&tid2,NULL,thread2,NULL)))
    {
            perror("fail to pthread_create!");
            return -1;
    }

    getchar();
    return 0;
}

pthread_create_multi.c

#include <stdio.h>
#include <pthread.h>
void *thread1(void *arg)/*线程函数*/
{
    printf("我是线程1!\n");
    pthread_exit("线程1退出...\n");
    return NULL;
}

void *thread2(void *arg)/*线程函数*/
{
    printf("我是线程2!\n");
    pthread_exit("线程2退出...\n");
    return NULL;
}

void *thread3(void *arg)/*线程函数*/
{
    printf("我是线程3!\n");
    pthread_exit("线程3退出...\n");
    return NULL;
}

void *thread4(void *arg)/*线程函数*/
{
    printf("我是线程4!\n");
    pthread_exit("线程4退出...\n");
    return NULL;
}

void *thread5(void *arg)/*线程函数*/
{
    printf("我是线程5!\n");
    pthread_exit("线程5退出...\n");
    return NULL;
}


int main(void)
{
    /*在调用进程中创建一个线程  
     * int pthread_create(pthread_t *thread, const pthread_attr_t *attr,
     *                   void *(*start_routine) (void *), void *arg);
     * 参数：  
     * thread:保存线程ID空间的首地址
     * attr:线程的属性
     * start_routine:线程函数的首地址
     * arg:给线程函数传递的参数
     *成功返回0；失败返回非0。
     * */
    int i = 0;
    pthread_t tid[i];
    void *ret = NULL;
    /*函数指针数组，存放着各个函数作为数组元素*/
    void *(*thread[])(void *) = {thread1,
                                thread2,
                                thread3,
                                thread4,
                                thread5
                            };
    for(i = 0;i < 5;i++)
    {
        if(0 != (pthread_create(&tid[i],NULL,thread[i],NULL)))/*arg 给线程函数传递的参数  此为NULL*/
        {
                perror("fail to pthread_create!");
                return -1;
        }
    }
    
    for(i = 0;i < 5;i++)
    {
        if(0 != (pthread_join(tid[i],&ret)))/*ret 接受线程退出的值*/
        {
                perror("fail to pthread_create!");
                return -1;
        }
        printf("ret = %s\n",(char *)ret);
    }
    return 0;
}

pthread_exit.c

#include <stdio.h>
#include <pthread.h>
/*让一个线程退出！
 * void pthread_exit(void *retval);
 * retval:退出的值
 * */
void *thread(void *arg)/*线程函数*/
{
        printf("我是线程!\n");
        pthread_exit("我要退出了！\n");//没有pthread_join这样的函数来接受线程结束时的状态值，故不打印
        printf("我还活着!\n");
}

int main(void)
{
    pthread_t tid;
    if(0 != (pthread_create(&tid,NULL,thread,NULL)))
    {
            perror("fail to pthread_create!");
            return -1;
    }

    getchar();
    return 0;
}

pthread_join.c

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

void *thread(void *arg)/*线程函数*/
{
    sleep(3);
    printf("我是线程1 即将退出...\n");
    pthread_exit("线程退出...\n");
    return NULL;
}
int main(void)
{
    pthread_t tid;
    if(0 != (pthread_create(&tid,NULL,thread,NULL)))
    {
            perror("fail to pthread_create!");
            return -1;
    }
    /*回收退出的线程资源
     * int pthread_join(pthread_t thread, void **retval);
     * thread:线程ID号；
     * retval:接受线程退出的值
     * 成功返回0；失败返回非0.
     */
    void *ret = NULL;
    if(0 != (pthread_join(tid,&ret)))//用ret来接受线程退出的状态值
    {
            perror("fail to pthread_join!");
            return -1;
    }
    printf("ret = %s\n",(char*)ret);/*显示线程退出状态*/
    getchar();
    return 0;
}

 pthread_sem.c

/*
 * 信号量（资源）
 * 第一种线程间同步方式(包含互斥):
 * 可使用信号量（一种资源）——多个线程协同处理某事件
 *                        //信号量也可用于进程间同步
 * */
#include <stdio.h>
#include <pthread.h>
#include <semaphore.h>

sem_t sem_r;
sem_t sem_w;
char buff[64] = {0};

void *thread1(void *arg)/*线程函数*/
{
        while(1)
        {
            sem_wait(&sem_w);    /*申请-1；        2:申请一个资源:若资源数>0，则该资源数减1；
                                                若资源数=0，则阻塞等待能获得该资源或者被信号中断为止*/
            //write(stdin,buff,sizeof(buff));
            fgets(buff,sizeof(buff),stdin);
            printf("我是线程1...\n");
            sem_post(&sem_r);    /*释放+1；        3：释放一个信号量*/
        }
        return NULL;
}

void *thread2(void *arg)/*线程函数*/
{
        while(1)
        {
            sem_wait(&sem_r);
            printf("我是线程2...\n");
            printf("buff = %s\n",buff);
            sem_post(&sem_w);
        }
        return NULL;
}
int main(void)
{
    pthread_t tid1,tid2; 
    /*初始化信号量
     * int sem_init(sem_t *sem, int pshared, unsigned int value);
     * sem: 信号量地址
     * pshared:信号量的共享域/0为线程间共享；1为进程间共享
     * value：信号量初始值
     * 成功返回0；失败返回-1.
     * */
    if(-1 == (sem_init(&sem_w,0,1)))//1:初始化信号量
    {
        perror("fail to sem_init!");
        return -1;
    }
    if(-1 == (sem_init(&sem_r,0,0)))
    {
        perror("fail to sem_init!");
        return -1;
    }

    if(0 != (pthread_create(&tid1,NULL,thread1,NULL)))
    {
            perror("fail to pthread_create1!");
            return -1;
    }
    if(0 != (pthread_create(&tid2,NULL,thread2,NULL)))
    {
            perror("fail to pthread_create2!");
            return -1;
    }

    if(0 != (pthread_join(tid1,NULL)))/*记得回收线程资源*/
    {
            perror("fail to pthread_join!");
            return -1;
    }
    if(0 != (pthread_join(tid2,NULL)))
    {
            perror("fail to pthread_join!");
            return -1;
    }
    getchar();
    return 0;
}

pthread_lock.c

/*
 *第二种线程间同步方式(包含互斥)：
 *线程间互斥使用互斥锁（一种资源）——多个线程互斥处理某事件
 *临界区域：互斥锁中间的一段代码
 *原子操作：CPU执行操作的最小单元，CPU在执行原子操作时不可能在进程或者线程间切换
 * */
#include <stdio.h>
#include <pthread.h>
#include <semaphore.h>

pthread_mutex_t lock;/*定义一把互斥锁*/
char a,b;
char data = 10;

void *thread1(void *arg)/*线程函数*/
{
        while(1)
        {
            pthread_mutex_lock(&lock);/*加锁*/
            a = data;
            b = data;
            a+=1;
            pthread_mutex_unlock(&lock);/*解锁*/
            sleep(1);
        }
        return NULL;
}

void *thread2(void *arg)/*线程函数*/
{
        while(1)
        {
            pthread_mutex_lock(&lock);
            if(a != b) printf("a = %d b = %d \n",a,b);
            pthread_mutex_unlock(&lock);
            sleep(1);
        }
        return NULL;
}
int main(void)
{
    pthread_t tid1,tid2;
    /* 定义互斥锁
       pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;//lock
       初始化一个互斥锁
       int pthread_mutex_init(pthread_mutex_t *restrict mutex,const pthread_mutexattr_t *restrict attr);
           参数：
            mutex:互斥锁地址
            attr:互斥锁属性
            成功返回0；失败返回非0.

       销毁一个互斥锁
       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);

       */

    if(0 != (pthread_mutex_init(&lock,NULL)))/*初始化互斥锁*/
    {
        perror("fail to pthread_mutex_init!");
        return -1;
    }

    if(0 != (pthread_create(&tid1,NULL,thread1,NULL)))/*创建线程*/
    {
            perror("fail to pthread_create1!");
            return -1;
    }
    if(0 != (pthread_create(&tid2,NULL,thread2,NULL)))
    {
            perror("fail to pthread_create2!");
            return -1;
    }

    if(0 != (pthread_join(tid1,NULL)))/*记得回收退出线程的资源*/
    {
            perror("fail to pthread_join!");
            return -1;
    }
    if(0 != (pthread_join(tid2,NULL)))
    {
            perror("fail to pthread_join!");
            return -1;
    }
    if(0 != (pthread_mutex_destroy(&lock)))/*销毁互斥锁*/
    {
        perror("fail to pthread_mutex_destroy!");
        return -1;
    }
    return 0;
}

pthread_cond.c

/*
 * 第三种线程间同步方式(包含互斥)：
 * 条件变量：
 * 线程锁一般都是自己去解锁，但是条件变量可以让其他线程帮助该线程解锁
 */
#include <stdio.h>
#include <stdlib.h>
#include <error.h>
#include <errno.h>
#include <pthread.h>

#define error_exit(_errmsg_) error(EXIT_FAILURE,errno,_errmsg_)

pthread_cond_t cond;    /*定义一个条件变量*/
pthread_mutex_t lock;    /*定义一个互斥锁*/
/*初始化一个条件变量
 * pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
 * int pthread_cond_init(pthread_cond_t *restrict cond,const pthread_condattr_t *restrict attr);
 * 参数：
 *     cond:条件变量的地址
 *     attr:条件变量的属性
 *     成功返回0；失败返回非0.
 * 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_signal(pthread_cond_t *cond);                                        //唤醒该线程

 * */

    /* 定义互斥锁     复习回顾
       pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;//lock
       初始化一个互斥锁
       int pthread_mutex_init(pthread_mutex_t *restrict mutex,const pthread_mutexattr_t *restrict attr);
           参数：
            mutex:互斥锁地址
            attr:互斥锁属性
            成功返回0；失败返回非0.
       销毁一个互斥锁
       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);
       */
void *thread1(void *arg)
{
    printf("hello world----->1\n");
    pthread_mutex_lock(&lock);//加互斥锁

    pthread_cond_wait(&cond,&lock);/*让本线程开始挂起*/ //3.让一个线程挂起...无休止的等待...

    printf("I love you, baby----->1\n");
    pthread_mutex_unlock(&lock);//解互斥锁
    return NULL;
}

void *thread2(void *arg)
{
    sleep(3);//3s
    pthread_cond_signal(&cond);/*唤醒1线程*/ //4.唤醒条件变量对应的线程

    return NULL;
}

int main(void)
{
    pthread_t tid1,tid2;

    if(0 != (pthread_mutex_init(&lock,NULL)))
        error_exit("fail to pthread_mutex_init!");

    if(0 != (pthread_cond_init(&cond,NULL)))//1.初始化一个条件变量
        error_exit("fail to pthread_cond_init!");

    if(0 != (pthread_create(&tid1,NULL,thread1,NULL)))
        error_exit("fail to pthread_create1!");
    if(0 != (pthread_create(&tid2,NULL,thread2,NULL)))
        error_exit("fail to pthread_create2!");

    if(0 !=(pthread_join(tid1,NULL)))
        error_exit("fail to pthread_exit1!");
    if(0 !=(pthread_join(tid2,NULL)))
        error_exit("fail to pthread_exit2!");

    if(0 != (pthread_mutex_destroy(&lock)))
        error_exit("fail to pthread_mutex_destroy!");

    if(0 != (pthread_cond_destroy(&cond)))//2.销毁一个条件变量
        error_exit("fail to pthread_cond_destroy!");

    return 0;
}