Linux应用——线程（二）

最新推荐文章于 2024-09-17 20:39:29 发布
最新推荐文章于 2024-09-17 20:39:29 发布
阅读量626 收藏 26
点赞数 10
分类专栏： Linux应用 文章标签： 开发语言 linux ubuntu 服务器
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_56399733/article/details/140441106
版权

目录

一、线程同步

二、互斥量

2.1概述        

2.2 互斥量相关操作函数

三、死锁

 3.1忘记释放锁

3.2重复加锁

3.3多线程多锁

四、读写锁

五、生产者消费者模型

六、条件变量

七、信号量

一、线程同步

        多线程中重要的内容。

案例：使用多线程卖票的案例，有3个窗口，100张票；

微观角度：并发执行；宏观角度：并行执行；

#include <stdio.h>
#include <pthread.h>
#include <unistd.h>
void * sellticket(void * arg)
{
     int tickets=100;
    //卖票；
    while(tickets>0)
    {
       // usleep(7000);
        printf("%ld 正在卖第 %d 张票；\n",pthread_self(),tickets);
        tickets--;
    }
    return NULL;
}
int main()
{
    //创建三个子线程；
    pthread_t tid1,tid2,tid3;
    pthread_create(&tid1,NULL,sellticket,NULL);
    pthread_create(&tid2,NULL,sellticket,NULL);
    pthread_create(&tid3,NULL,sellticket,NULL);
    //回收子线程的资源,阻塞
    pthread_join(tid1,NULL);
    pthread_join(tid2,NULL);
    pthread_join(tid3,NULL);
    pthread_exit(NULL);//退出主线程；

        return 0;
}

结果分析：

        三个线程各自卖了100张票， 但是需求是三个窗口一共100张，所以，结果并不是我们预想的那样。因为tickets作为局部变量，在函数里面，每个线程都有自己的局部变量，这样就有三个tickets。

修改为全局变量：

//全局变量，所有的线程卖100张；

int tickets=100;

void * sellticket(void * arg)

{ 

    //卖票；

    while(tickets>0)

    {

        printf("%ld 正在卖第 %d 张票；\n",pthread_self(),tickets);

        tickets--;

    }

    return NULL;

}

运行结果：

        我们发现还是有问题，比如说第100张票卖了好几遍，这显然是不正确的。我们在程序中加上延时，这种现象会更加明显：     

void * sellticket(void * arg)

{

     

    //卖票；

    while(tickets>0)

    {

        usleep(7000);

        printf("%ld 正在卖第 %d 张票；\n",pthread_self(),tickets);

        tickets--;

    }

    return NULL;

}

运行结果：

        根据上面我们甚至发现出现了零票、负数票的现象，这是为什么呢？

        线程同步有关的问题，三个线程并发执行，抢占CPU资源，谁抢到就谁执行，这样会导致，同一个票数，ABC都进入卖票的程序，在票数没减之前，其他线程就会出票。

        多个线程对同一个资源做了同时的处理。那么如何处理这种问题？

        对于共享数据的操作同一个时间只能有一个线程进行操作。

        线程的主要优势在于，能够通过全局变量来共享信息，不过这种便捷的共享是有代价的：必须确保多个线程不会同时修改同一变量，或者某一线程不会读取正在有其他进程修改的变量。

临界区：访问某一共享资源的代码片段，并且这段代码的执行应为原子操作，也就是同时访问同一共享资源的其他线程不应终端该片段的执行。

线程同步：即当有一个线程在对内存进行操作时，其他线程都不可以对这个内存地址进行操作，直到该线程完成操作，其他线程才能对该线程的内存地址进行操作，而其他线程则处于等待状态。

线程同步能降低代码的执行效率，但是这是必须的，因为这得保证代码的安全性；

二、互斥量

2.1概述        

为何解决线程数据的安全问题；

        为了避免线程更新共享变量出现问题，可以使用互斥量(mutex)，来确保同时只有一个线程来访问某项共享资源。可以使用互斥量来保证任意共享资源的原子访问。

        互斥量有两种状态：已锁定和未锁定。

        任何时候，只有有一个线程可以锁定该互斥量。试图对已经锁定的某一互斥量再次进行加锁，将可能阻塞线程或者报错，具体取决于加锁时使用的方法；

        一旦线程锁定互斥量，随即称为该互斥量的所有者，只有所有者才能给互斥量解锁。一百清凉下，对每一共享资源（可能由多个相关变量组成）会使用不同的互斥量，每一个线程在访问同一资源时将采用如下协议：

        针对共享资源锁定互斥量；

        访问共享资源；

        对互斥量解锁；      

 如果多个新城试图执行这个代码（一个临界区），事实上只有一个线程能够持有该互斥量（其他线程将遭到阻塞），即同时只有一个线程能够进入这段代码区域：

2.2 互斥量相关操作函数

◼ 互斥量的类型 pthread_mutex_t

类似于变量的类型，使用互斥量需要先定义一个互斥量；
◼ int pthread_mutex_init(pthread_mutex_t *restrict mutex,
const pthread_mutexattr_t *restrict attr);

初始化互斥量：

        参数：mutex:需要初始化的互斥量；

                   attr:互斥量相关属性-NULL；

          restrict:C语言修饰符。被修饰指针不能由另外的指针操作；
◼ 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);

        解锁。

        我们在前面的卖票程序中，出现的问题就是，三个线程抢占CPU资源，都进入临界区进行卖票，这就会出现一票多卖以及负票这种现象。为了解决这个问题，我们提出来加锁这种方法，就是在一个线程进入临界区时，加锁，不让别的线程进来，它卖，卖完后再解锁，允许其他线程进入。

#include <stdio.h>
#include <pthread.h>
#include <unistd.h>
//全局变量，所有的线程卖100张；
int tickets=100;
//创建一个互斥量
 pthread_mutex_t mutex;


void * sellticket(void * arg)
{
  //加锁  
    //卖票；
    while(1)
    {
         pthread_mutex_lock(&mutex);
        if(tickets>0)
            {        
                printf("%ld 正在卖第 %d 张票；\n",pthread_self(),tickets);
                tickets--;
            }
            else
            {
                pthread_mutex_unlock(&mutex);
                usleep(7000);
                break;
            }
            pthread_mutex_unlock(&mutex);
            usleep(7000);
    }   
    //解锁
    

    return NULL;
}
int main()
{
    //初始化互斥量
    pthread_mutex_init(&mutex,NULL);


    //创建三个子线程；
    pthread_t tid1,tid2,tid3;
    pthread_create(&tid1,NULL,sellticket,NULL);
    pthread_create(&tid2,NULL,sellticket,NULL);
    pthread_create(&tid3,NULL,sellticket,NULL);
    //回收子线程的资源,阻塞
    pthread_join(tid1,NULL);
    pthread_join(tid2,NULL);
    pthread_join(tid3,NULL);
    //释放互斥量资源
     pthread_mutex_destroy(&mutex);
    pthread_exit(NULL);//退出主线程；

        return 0;
}

运行结果：

        交替卖票，三个线程交替完成卖票； 

void * sellticket(void * arg)

{

    while(1)

    {

         pthread_mutex_lock(&mutex);

        if(tickets>0)

            {        

                printf("%ld 正在卖第 %d 张票；\n",pthread_self(),tickets);

                tickets--;

            }

            else

            {

                pthread_mutex_unlock(&mutex);

                usleep(7000);

                break;

            }

            pthread_mutex_unlock(&mutex);

            usleep(7000);

    }

    return NULL;

}

注意：加锁和解锁的位置，以及加延时的位置，加延迟的作用是，防止一个线程抢占到CPU资源后，一直把票给卖完了，加上延时后，线程就算卖票，抢占上一个CPU资源，一次也卖不了太多的票。

三、死锁

        有时，一个线程需要同时访问两个或者更多不同的共享资源，而每个共享资源又都由不同的互斥量进行管理，当超过一个线程加锁同一组互斥量时，就有可能发生死锁。

        两个或者连个以上的进程执行过程中，因为争夺共享资源造成的一种互相等待的现象，若无外力作用，他们都将无法推进下去。此时称系统处于死锁状态或系统产生了死锁。

死锁的几种场景：

        忘记释放锁；

        重复加锁；

        多线程多锁，抢占锁资源；

 3.1忘记释放锁

#include <stdio.h>
#include <pthread.h>
#include <unistd.h>
//全局变量，所有的线程卖100张；
int tickets=100;
//创建一个互斥量
 pthread_mutex_t mutex;
void * sellticket(void * arg)
{
  //加锁  
    //卖票；
    while(1)
    {
         pthread_mutex_lock(&mutex);  
        if(tickets>0)
            {        
                printf("%ld 正在卖第 %d 张票；\n",pthread_self(),tickets);
                tickets--;
            }
            else
            {
                pthread_mutex_unlock(&mutex);
                usleep(7000);
                break;
            }
            usleep(7000);
    }   
    return NULL;
}
int main()
{
    //初始化互斥量
    pthread_mutex_init(&mutex,NULL);
    //创建三个子线程；
    pthread_t tid1,tid2,tid3;
    pthread_create(&tid1,NULL,sellticket,NULL);
    pthread_create(&tid2,NULL,sellticket,NULL);
    pthread_create(&tid3,NULL,sellticket,NULL);
    //回收子线程的资源,阻塞
    pthread_join(tid1,NULL);
    pthread_join(tid2,NULL);
    pthread_join(tid3,NULL);
    //释放互斥量资源
    pthread_mutex_destroy(&mutex);
    pthread_exit(NULL);//退出主线程；
       return 0;
}

运行结果： 

         多线程抢占共享资源区，一个进程进入，加锁，出来，第二次无法进入以及其他进程也无法进入，造成死锁现象；

3.2重复加锁

#include <stdio.h>
#include <pthread.h>
#include <unistd.h>
//全局变量，所有的线程卖100张；
int tickets=100;
//创建一个互斥量
 pthread_mutex_t mutex;
void * sellticket(void * arg)
{
  //加锁  
    //卖票；
    while(1)
    {
         pthread_mutex_lock(&mutex);
         pthread_mutex_lock(&mutex);
        if(tickets>0)
            {        
                printf("%ld 正在卖第 %d 张票；\n",pthread_self(),tickets);
                tickets--;
            }
            else
            {
                pthread_mutex_unlock(&mutex);
                usleep(7000);
                break;
            }
            pthread_mutex_unlock(&mutex);
            pthread_mutex_unlock(&mutex);
            usleep(7000);
    }   
    return NULL;
}
int main()
{
    //初始化互斥量
    pthread_mutex_init(&mutex,NULL);
    //创建三个子线程；
    pthread_t tid1,tid2,tid3;
    pthread_create(&tid1,NULL,sellticket,NULL);
    pthread_create(&tid2,NULL,sellticket,NULL);
    pthread_create(&tid3,NULL,sellticket,NULL);
    //回收子线程的资源,阻塞
    pthread_join(tid1,NULL);
    pthread_join(tid2,NULL);
    pthread_join(tid3,NULL);
    //释放互斥量资源
    pthread_mutex_destroy(&mutex);
    pthread_exit(NULL);//退出主线程；
       return 0;
}

运行结果： 

       多线程抢占共享资源区，一个进程进入，进入第一道锁，第二道锁无法进入因为已经这道锁已经被加过了，没能解锁，无法再加，造成死锁现象。 

3.3多线程多锁

#include <stdio.h>
#include <pthread.h>
#include <unistd.h>
//创建两个互斥量
pthread_mutex_t mutex1,mutex2;

void * workA(void *arg)
{
    
    pthread_mutex_lock(&mutex1);
    sleep(1);
    pthread_mutex_lock(&mutex2);
    printf("workA...\n");

    pthread_mutex_unlock(&mutex2);
    pthread_mutex_unlock(&mutex1);
  return NULL;

}

void * workB(void *arg)
{
    pthread_mutex_lock(&mutex2);
      sleep(1);
    pthread_mutex_lock(&mutex1);
    printf("workB...\n");

    pthread_mutex_unlock(&mutex1);
    pthread_mutex_unlock(&mutex2);

    return NULL;
}

运行结果： 

         线程A运行A区共享资源，线程B运行B区共享资源，两个区各有两把锁A区a锁将线程A锁住，B区b锁将线程B锁住，线程A在A区无法被B锁锁住，线程B无法在B区被A锁锁住，造成死锁。

四、读写锁

     问题：当有一个线程已经持有互斥锁时，互斥锁将所有试图进入临界区的线程都阻塞住。但是考虑一种情形，当前持有互斥锁的线程只是要读访问共享资源，而同时有其它几个线程也想读取这个共享资源，但是由于互斥锁的排它性，所有其它线程都无法获取锁，也就无法读访问共享资源了，但是实际上多个线程同时读访问共享资源并不会导致问题。   

     解决：在对数据的读写操作中，更多的是读操作，写操作较少，例如对数据库数据的读写应用。为了满足当前能够允许多个读出，但只允许一个写入的需求，线程提供了读写锁来实现。

读写锁的特点：

1、 如果有其它线程读数据，则允许其它线程执行读操作，但不允许写操作。
2、 如果有其它线程写数据，则其它线程都不允许读、写操作。
3、 写是独占的，写的优先级高。

◼ 读写锁的类型 pthread_rwlock_t
◼ int pthread_rwlock_init(pthread_rwlock_t *restrict rwlock,
const pthread_rwlockattr_t *restrict attr);
◼ int pthread_rwlock_destroy(pthread_rwlock_t *rwlock);
◼ int pthread_rwlock_rdlock(pthread_rwlock_t *rwlock);
◼ int pthread_rwlock_tryrdlock(pthread_rwlock_t *rwlock);
◼ int pthread_rwlock_wrlock(pthread_rwlock_t *rwlock);
◼ int pthread_rwlock_trywrlock(pthread_rwlock_t *rwlock);
◼ int pthread_rwlock_unlock(pthread_rwlock_t *rwlock);

 案例; 

        创建8个线程，操作同一个全局变量。

        3个线程不定时写全局变量；

        5个线程不定时读全局变量。

#include <stdio.h>
#include <pthread.h>
#include <unistd.h>
int num=1;
pthread_mutex_t mutex;
pthread_rwlock_t rwlock;
void * writenum(void * arg)
{

    while(1)
    {
        pthread_rwlock_wrlock(&rwlock);
        num++;
        printf("++write,tid:%ld,num:%d\n",pthread_self(),num);
        pthread_rwlock_unlock(&rwlock);
        usleep(100);
    }

    return NULL;

}
void * readnum(void * arg)
{
    while(1)
    {
        pthread_rwlock_rdlock(&rwlock);
        printf("===read,tid:%ld,num:%d\n",pthread_self(),num);
        pthread_rwlock_unlock(&rwlock);
         usleep(100);
    }
    return NULL;
}


int main()
{//创建3个写线程，5个读线程；
    pthread_t wtid[3],rtid[5];
    int i;
   // pthread_mutex_init(&mutex,NULL);
    pthread_rwlock_init(&rwlock,NULL);
    for(i=0;i<3;i++)
    {
        pthread_create(&wtid[i],NULL,writenum,NULL);
    }

    for(i=0;i<5;i++)
    {
        pthread_create(&rtid[i],NULL,readnum,NULL);
    }

    //设置线程分离
     for(i=0;i<3;i++)
    {
       pthread_detach(wtid[i]);
    }

    for(i=0;i<5;i++)
    {
        pthread_detach(rtid[i]);
    }

    pthread_rwlock_destroy(&rwlock);
    pthread_exit(NULL);
    return 0;
}

运行结果： 

        利用读写锁实现，写线程具有较高权限，读线程可以并行执行，不会发生阻塞，写线程会具有阻塞行为，整体效率要高效于互斥锁。 

五、生产者消费者模型

生产者消费者模型：

        模型含有三个对象：生产者、消费者以及容器；

        由生产者生产产品，消费者使用产品，且数量都是多个的，每个生产者与消费者用一个线程实现，那么容器中的产品就是数据。当容器满后生产者会阻塞等待消费者进行消费。当容器为空后，消费者会堵塞等待生产者生产。

#include <stdio.h>
#include <pthread.h>
#include <stdlib.h>
#include <unistd.h>
struct Node
{
    int num;
    struct Node * next;
};
//头结点
struct Node* head=NULL;

void * producter(void * arg)
{
    //不断创建新的结点，添加在链表中；
    while(1)
    {
           struct Node * newNode =(struct Node *)malloc(sizeof(struct Node));
           newNode->next=head;
           head=newNode;
           newNode->num=rand()%1000;
           printf("add node,num:%d tid；%ld\n",newNode->num,pthread_self());
           usleep(100);
    }
    return NULL;
}

void * customer(void * arg)
{
    while(1)
    {
        //保存头结点的指针；
        struct Node* temp=head;
        head=head->next;
        printf("del node num:%d,tid:%ld\n",temp->num,pthread_self());
        free(temp);
        usleep(100);
    }
    return NULL;
}

int main()
{
    int i;
//创建5个生产者线程，和5个消费者线程；
    pthread_t ptids[5],ctids[5];
    for(i=0;i<5;i++)
    {
        pthread_create(&ptids[i],NULL,producter,NULL);
        pthread_create(&ctids[i],NULL,customer,NULL);
    }
    for(i=0;i<5;i++)
    {
        pthread_detach(ptids[i]);
        pthread_detach(ctids[i]);
    }
    while(1)
    {
    sleep(1);
    }
    pthread_exit(NULL);
    return 0;
}

运行结果：

        上述运行结果中，会出现段错误，出现的原因是多种的，首先我们在程序中没有考虑当 容器满后生产者会阻塞等待消费者进行消费。当容器为空后，消费者会堵塞等待生产者生产。这种情况就需要用到互斥锁、读写锁等操作。

六、条件变量

        问题：没有产品，消费者无法消费；

        解决：没有产品，消费者需要通知生产者去生产产品，当有了产品需要通知消费者进行消费。条件变量；

        条件变量不是锁，它的作用是当满足某些条件后，线程会发生阻塞；或者满足某些条件后，解除线程。它不能保证线程同步带来的数据安全性的问题，它是配合互斥锁来进行合作。

条件变量的类型 pthread_cond_t
◼ int pthread_cond_init(pthread_cond_t *restrict cond, const
pthread_condattr_t *restrict attr);
◼ 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_timedwait(pthread_cond_t *restrict cond,
pthread_mutex_t *restrict mutex, const struct timespec *restrict
abstime);
◼ int pthread_cond_signal(pthread_cond_t *cond);
◼ int pthread_cond_broadcast(pthread_cond_t *cond)

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

//创建一个互斥量
pthread_mutex_t mutex;
//创建条件变量
pthread_cond_t cond;
struct Node
{
    int num;
    struct Node * next;
};
//头结点
struct Node* head=NULL;

void * producter(void * arg)
{
    //不断创建新的结点，添加在链表中；
    while(1)
    {
           pthread_mutex_lock(&mutex);
           struct Node * newNode =(struct Node *)malloc(sizeof(struct Node));
           newNode->next=head;
           head=newNode;
           newNode->num=rand()%1000;
           printf("add node,num:%d tid:%ld\n",newNode->num,pthread_self());
           //只要生产一个就通知消费者消费；
           pthread_cond_signal(&cond);
           pthread_mutex_unlock(&mutex);
           usleep(100);
    }
    return NULL;
}

void * customer(void * arg)
{
    while(1)
    {
        //保存头结点的指针；
        pthread_mutex_lock(&mutex);
        struct Node* temp=head;
        if(head!=NULL)
        {
            //有数据；
            head=head->next;
            printf("del node num:%d tid:%ld\n",temp->num,pthread_self());
            free(temp);
            pthread_mutex_unlock(&mutex);
            usleep(100);
        }else
        {
            //没有数据,需要等待
            //当这个函数调用阻塞时，会对互斥锁进行解锁，当不阻塞是时，继续向下执行会进行加锁。
            pthread_cond_wait(&cond,&mutex);
            pthread_mutex_unlock(&mutex);
        }
        
    }
    return NULL;
}

int main()
{
    pthread_mutex_init(&mutex,NULL);
    pthread_cond_init(&cond,NULL);
    int i;
//创建5个生产者线程，和5个消费者线程；
    pthread_t ptids[5],ctids[5];
    for(i=0;i<5;i++)
    {
        pthread_create(&ptids[i],NULL,producter,NULL);
        pthread_create(&ctids[i],NULL,customer,NULL);
    }
    for(i=0;i<5;i++)
    {
        pthread_detach(ptids[i]);
        pthread_detach(ctids[i]);
    }
    while(1)
    {
    sleep(1);
    }
    pthread_mutex_destroy(&mutex);
    pthread_cond_destroy(&cond);
    pthread_exit(NULL);
    return 0;
}

 运行结果：

         加上互斥锁，作用在于线程同步时，共享资源区数据的安全性。

        加上条件变量，其意义在于当产品为0时，不使用条件变量，消费者处于无意义的缓冲，此时，只执行加锁和解锁，直到时间片用完才发生线程切换，浪费CPU资源。而加入条件变量，一旦发现缓冲区是空的，会立刻从运行态进入阻塞态，此时一定会发生线程切换，把CPU资源让出来。互斥锁和条件变量都可以实现线程同步，但是使用条件变量效率更高。

七、信号量

        信号量也称之为信号灯，它跟条件变量的作用是一致的，能起到阻塞线程的作用；灯亮表示资源可用，灯灭表示资源不可用。

◼ 信号量的类型 sem_t

◼ int sem_init(sem_t *sem, int pshared, unsigned int value);初始化；

    头文件： #include <semaphore.h>

         sem：信号量变量的地址；

         pshared为0：线程使用；非0：进程使用；

         value：信号量中的值；

◼ int sem_destroy(sem_t *sem);释放资源；

◼ int sem_wait(sem_t *sem);对信号量加锁，调用一次，对信号量的值减1，如果值为0就阻塞。

◼ int sem_trywait(sem_t *sem);尝试阻塞；

◼ int sem_timedwait(sem_t *sem, const struct timespec *abs_timeout);阻塞多久；

◼ int sem_post(sem_t *sem);对信号量解锁，调用一次，对信号量的值+1；

◼ int sem_getvalue(sem_t *sem, int *sval);  获取post的值；

利用信号量完成生产者消费者的模型：

sem_t psem;//创建一个生产者信号量

sem_t csem;//创建一个消费者信号量

init(psem,0,8);//初始化生产者信号量，其信号量的初值设置为8；

init(csem,0,0);//初始化消费者信号量，其信号量的初值设置为0；

producer()

{

    sem_wait(&psem);//对生产者信号量加锁，调用一次，对生产者信号量的值减1，如果值为0就阻塞。

    sem_pose(&csem);//调用一次，对消费信号量的值+1；

}

customer()

{

    sem_wait(&csem);对消费者信号量加锁，调用一次，对消费者信号量的值减1，如果值为0就阻塞。

    sem_pose(&psem);//调用一次，对生产者信号量的值+1；

}

 

    


#include <stdio.h>
#include <pthread.h>
#include <stdlib.h>
#include <unistd.h>
#include <semaphore.h>
//创建一个互斥量
pthread_mutex_t mutex;
//创建两个信号量
sem_t psem,csem;

struct Node
{
    int num;
    struct Node * next;
};
//头结点
struct Node* head=NULL;

void * producter(void * arg)
{
    //不断创建新的结点，添加在链表中；
    while(1)
    {
           sem_wait(&psem);
           pthread_mutex_lock(&mutex);
           struct Node * newNode =(struct Node *)malloc(sizeof(struct Node));
           newNode->next=head;
           head=newNode;
           newNode->num=rand()%1000;
           printf("add node,num:%d tid:%ld\n",newNode->num,pthread_self());   
           pthread_mutex_unlock(&mutex);
           sem_post(&csem);
           usleep(100);
    }
    return NULL;
}

void * customer(void * arg)
{
    while(1)
    {
         sem_wait(&csem);
        //保存头结点的指针；
        pthread_mutex_lock(&mutex);
        struct Node* temp=head;
            //有数据；
            head=head->next;
            printf("del node num:%d tid:%ld\n",temp->num,pthread_self());
            free(temp);
            pthread_mutex_unlock(&mutex);
            sem_post(&psem);
    }
    return NULL;
}

int main()
{
    pthread_mutex_init(&mutex,NULL);
    sem_init(&psem,0,8);
    sem_init(&csem,0,0);
    int i;
//创建5个生产者线程，和5个消费者线程；
    pthread_t ptids[5],ctids[5];
    for(i=0;i<5;i++)
    {
        pthread_create(&ptids[i],NULL,producter,NULL);
        pthread_create(&ctids[i],NULL,customer,NULL);
    }
    for(i=0;i<5;i++)
    {
        pthread_detach(ptids[i]);
        pthread_detach(ctids[i]);
    }
    while(1)
    {
    sleep(1);
    }
    pthread_mutex_destroy(&mutex);

    pthread_exit(NULL);
    return 0;
}

    运行结果：

        本次我们讲述了线程的同步、互斥问题以及与互斥相关的死锁、读写锁以及举了相关案例——生产者消费者模型，并结合条件变量以及信息量完善了案例的实现。

        创做不易，感谢大家多多支持！！！ 

 

King~30+
关注
专栏目录
Linux——线程控制
kkbca的博客
04-01 1677
线程控制，如何操控一个线程完成任务，同时能取消线程、等待线程，分离线程。
Linux 线程 —— 锁相关
Outside_的博客
08-30 1202
【代码】Linux 线程 —— 锁相关。
Linux 线程———详解
m0_51551385的博客
05-12 4200
1、线程的概念 和 基础知识 1.1 什么是线程 线程可看作轻量级进程（light weight process），Linux的线程本质仍然是进程。Linux先有进程后有线程，当创建了一个进程时，系统给他分配一段4G的虚拟内存，并在其内生成进程的PCB，当他调用相关函数创建一个线程时，会为新的线程生成一个PCB也存放在当前的4G虚拟内存中，而原来的进程也沦为一个线程。 所以，进程和线程的区别是：是否共享地址空间。 进程总是独享4G的虚拟内存，而多个线程共享一段4G的空间。 线程是CPU调度的最小单位，也是
Linux——线程互斥与互斥锁的使用
kkbca的博客
04-07 1678
由于线程可以创建多个，也就是操作系统中存在多个由某一个进程创建的执行流。那么他们在访问并修改共享资源时，可能会发生数据不一致的问题，进而我们需要让线程互斥来保护公共资源。
Linux应用学习——多线程
火红色祥云
03-08 711
Linux应用学习——多线程
Linux多线程——概念
weixin_57023347的博客
09-22 1720
前言 Linux系统中并没有真正意义上的多线程，因为linux内核中并没有为线程构建数据结构。它的线程使用进程来模拟的。 一.线程的概念 1.1 什么是线程 现在再理解进程：进程是承担分配系统资源的基本实体 线程是进程里的一个执行流，CPU调度的基本单位是线程。就比如上图的一个tast_struct就是一个线程。它们共用一个进程地址空间。一个进程可以有一个或者多个执行流。 由于在Linux中没有真正意义上的线程，...
Linux——进程、线程
wei
06-22 1446
Q&A 进程的六种状态及其转换过程（生命周期）——就绪态，运行态，深度睡眠态，浅睡眠态，停止态，僵尸态。 进程的生命周期，就绪态和运行态在数值上是相等的，都是由宏TASK_RUNNING定义。 Linux中Task_struct是如何被管理的呢？ 理解僵尸进程——放弃了几乎所有内存空间，没有任何可执行代码，也不能被调度，仅仅在进程列表中保留一个位置（资源已经释放，Task_struct结构还在）。如果他的父进程没安装SIGCHLD信号处理函数调用wait()/waitpid()等待子进程结束，又没
实验 5——Linux 线程管理
qq_56817149的博客
12-06 1846
实验 5——Linux 线程管理
【Linux】多线程——线程概念|进程VS线程|线程控制
AAlykk的博客
05-31 1781
早期我们的计算机还只能单个进程运行，这样的话每个进程就只能独立存在，不可以进行每个进程交互，在这个基础上我们的先人（大佬）看看能不能多个进程同时运行，也就有了现在的多进程，那对比单个进程，多进程有什么优势呢？值不值得我们学习呢？咱们带上这两个问题来康康Linux下的多线程。⭐主体。
Linux 系统应用编程——线程基础
知秋一叶
01-07 2853
传送门：Linux多线程编程实例解析 .  linux多线程编程——同步与互斥 .      统多任务操作系统中一个可以独立调度的任务（或称之为顺序执行流）是一个进程。每个程序加载到内存后只可以唯一地对应创建一个顺序执行流，即传统意义的进程。每个进程的全部系统资源是私有的，如虚拟地址空间，文件描述符和信号处理等等。使用多进程实现多任务应用时存在如下问题： 1）任务切换，即进程间上下文切换
多线程服务器端的实现1 —— 线程概念1
08-08
在UNIX或类UNIX系统中，如Linux，多线程的实现通常遵循POSIX标准，其中`pthread_create`函数用于创建新的线程。该函数接受四个参数：线程ID的指针、线程属性（默认为NULL）、线程执行的入口函数指针和传递给该函数的...
11原理 1：鞭辟入里 —— 线程 IO 模型(1).md
04-01
Redis和Node.js等单线程高性能应用正是利用了这一点，通过巧妙地组织代码和操作，实现了看似不可能的高并发处理能力。而对于Java开发者来说，理解NIO的相关原理和技术，能够更好地编写高效、可扩展的网络程序。
Linux线程（7）——线程安全函数
cj_lsk的博客
04-28 640
线程安全函数 了解了可重入函数之后，再来看看线程安全函数。 一个函数被多个线程（其实也是多个执行流，但是不包括由信号处理函数所产生的执行流）同时调用时，它总会一直产生正确的结果，把这样的函数称为线程安全函数。线程安全函数包括可重入函数，可重入函数是线程安全函数的一个真子集，也就是说可重入函数一定是线程安全函数，但线程安全函数不一定是可重入函数，它们之间的关系如下： 譬如下面这个函数是一个不可重入函数，同样也是一个线程不安全函数（上篇最后一例）：
Linux——线程详解
m0_46657980的博客
01-11 467
1. 线程的概念 1.1 基本概念 线程是进程中的一条执行流，是CPU调度的基本单位，一个进程中可以有多个线程 Linux下的线程执行流是通过pcb实现的，且一个进程中可能有多个pcb，并且这些pcb共享同一个进程中的大部分资源，因此，也被称为轻量级进程 Linux下，线程是CPU调度的基本单位，进程是系统进行资源分配的基本单位 1.2 线程之间的独有与共享 共享：虚拟地址空间（代码段和数据段）、文件描述符表、信号处理方式、工作路径 独有：线程栈、寄存器、信号屏蔽字、优先级、errno、线程标
二十种编程语言庆祝中秋节
敲代码别忘了喝上一杯凉白开。
09-17 389
在全球范围内，编程语言作为技术沟通的桥梁，不仅仅局限于解决技术问题，还能承载文化传递的使命。本文展示了如何使用二十种不同的编程语言来表达对中秋节的祝福，这些语言包括了Python、C、C++、Java、C#、Perl、Go、ASP、PHP、JavaScript、HTML、Visual Basic、VB早期版本、Visual C++、Delphi、Shell、Cobol、ActionScript、Foxpro和DOS批处理。每种语言的代码示例简单直接，都以其独特的语法输出“祝大家中秋快乐”的信息。
【Linux】：信号与信号产生
Yikefore的博客
09-12 946
信号的基本概念、对信号的理解、信号的多种产生方式以及核心转储的详细介绍！
linux-网络相关概念
最新发布
zdd56789的博客
09-17 351
linux-网络相关概念
Linux如何使用sed命令进行文本替换
yang295242361的博客
09-12 533
在Linux中，sed（Stream Editor）是一个用于处理文本流的命令行工具，它非常适合用于执行基本的文本转换。sed可以读取输入的文本文件，根据指定的指令对文本进行处理，并将结果输出到标准输出设备。
linux实用操作
lonelyxxyo的博客
09-13 1654
环境变量PATH这个项目里面记录了系统执行命令的搜索路径。这些搜索路径我们也可以自行添加到PATH中去。黑马教学案例：测试：在当前HOME目录内创建文件夹，myenv，在文件夹内创建文件mkhaha通过vim编辑器，在mkhaha文件内填入：echo 哈哈哈哈哈完成上述操作后，随意切换工作目录，执行mkhaha命令尝试一下，会发现无法执行修改PATH的值。
Linux应用调优实战指南
本指南是一份深入解析Linux应用程序调用的实用手册——《Linux ® Application Tuning Guide》。该书由Jean Wilson和Terry Schultz撰写，插图出自Chrystie Danzer的手笔，生产工作则由Karen Jacobson负责。书中涵盖...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值