Linux加油站 - 线程同步

已于 2023-09-13 22:35:57 修改
阅读量132 收藏
点赞数 1
分类专栏： Linux 文章标签： java c++ 开发语言
于 2023-01-21 16:32:28 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Huuaaaaa/article/details/128727416
版权
本文介绍了多线程编程中的几种同步机制，包括互斥锁用于保护共享资源的访问，条件变量实现线程间的通信，信号量作为计数器控制资源访问，以及读写锁以优化读写操作的并发性能。通过具体的示例展示了这些机制如何在实际问题如卖票系统、生产者消费者模型中应用。
摘要由CSDN通过智能技术生成

目录

互斥锁

条件变量

信号量

读写锁

互斥锁

         互斥锁接口：

    pthread_mutex_t // 互斥量的类型 

    int pthread_mutex_init(pthread_mutex_t *restrict mutex, const pthread_mutexattr_t *restrict attr);
        - 功能：初始化互斥量
        - 参数 ：
            - mutex ： 需要初始化的互斥量变量
            - attr ： 互斥量相关的属性，NULL(一般使用默认)

    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);
        - 解锁

        案例描述，使用多线程实现用户买票问题： 有3个窗口同时卖票，一共是100张票，卖完即止。

int tickets = 100;   

void * mysellfunc(){

    while (tickets >0)
    {   
        usleep(6000);       
        printf("%ld 正在卖第 %d 张门票\n" , pthread_self() , tickets);
        tickets--;
    }
    return NULL; 
}

int main(){

    pthread_t tid1 , tid2 ,tid3;
    pthread_create(&tid1 , NULL , mysellfunc , NULL);
    pthread_create(&tid2 , NULL , mysellfunc , NULL);
    pthread_create(&tid3 , NULL , mysellfunc , NULL);

    pthread_detach(tid1);
    pthread_detach(tid2);
    pthread_detach(tid3);

    pthread_exit(NULL);

    return 0;
}

         显然，没有进行线程同步的情况下，会出现非常混乱的情况：


        实现方面，显然，临界区（线程共享变量）即各线程对票数的售卖操作，因此对此操作需要加锁：

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


int tickets = 1000;   
pthread_mutex_t mutex;     //创建互斥量类型

void * mysellfunc(void * arg){

    while (1)          
    {   
        pthread_mutex_lock(&mutex);
        
        if(tickets > 0)             
        {       
            usleep(6000);
            printf("%ld 正在卖第 %d 张门票\n" , pthread_self() , tickets);
            tickets--;
        }
        else
        {   
            pthread_mutex_unlock(&mutex);
            break;
        }
        pthread_mutex_unlock(&mutex);
    }
    return NULL;
}

int main(){

    pthread_mutex_init(&mutex , NULL);    // 初始化互斥量

    pthread_t tid1 , tid2 ,tid3;
    pthread_create(&tid1 , NULL , mysellfunc , NULL);
    pthread_create(&tid2 , NULL , mysellfunc , NULL);
    pthread_create(&tid3 , NULL , mysellfunc , NULL);

    pthread_detach(tid1);
    pthread_detach(tid2);
    pthread_detach(tid3);

    pthread_exit(NULL);

    pthread_mutex_destroy(&mutex);     //  释放互斥量

    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);
        - 等待函数，调用了该函数，线程会阻塞在这里。
        - 注意一下，当运行到该函数并处于阻塞状态时，会先对持有的互斥锁进行解锁，从而不影响其他线程拿互斥锁。当不阻塞时（也就是被sinal函数唤醒后），会重新加锁，继续向下执行。

    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);
        - 唤醒所有的等待的线程

       

        先看看什么是生产者消费者模型：

        上图表明生产者生产满了以后，要通知消费者去消费；同样的，消费者消费完后 ，也会通知生产者去生产， 如果需要实现以上的机制，就可以用到条件变量这种线程同步的机制。

        直接上实例：

        1、先创建五个生产者线程，五个消费者线程，并进行互斥锁和条件变量的初始化：

struct ListNode{
    int val;
    struct ListNode *next;
}*head;

head = NULL;

int main(){
    pthread_cond_init(&cond  , NULL);

    pthread_mutex_init(&mutex, NULL);

    //创建5个生产者线程和5个消费者线程
    pthread_t ptids[5] , ctids[5];
    for(int i = 0 ; i<5 ;i++)
    {
        pthread_create(&ptids[i] , NULL , producerfunc , NULL);
        pthread_create(&ctids[i] , NULL , customerfunc , NULL);

    }
    for(int i = 0 ; i<5 ;i++)
    {
        pthread_detach(ptids[i]);
        pthread_detach(ctids[i]);
    }
    pthread_mutex_destroy(&mutex);

    pthread_cond_destroy(&cond);

    pthread_exit(NULL);

    return 0;
}

         2、以链表结点作为线程生产和消费的对象，

        生产者线程函数生产了一个结点就调用signal函数通知消费者线程进行消费（也就是删除结点）：

void * producerfunc(void * arg){        
    while (1)    //生产者不断生产结点
    {      
        pthread_mutex_lock(&mutex);

        struct ListNode *newNode = (struct ListNode*)malloc(sizeof(struct ListNode));         
        newNode ->next = head;
        head = newNode;
        newNode ->val = rand()%1000;
        printf("add Node, num: %d , tid  : %ld\n" , newNode->val , pthread_self());

        //只要生产了一个就通知 消费者消费（signal函数）
        pthread_cond_signal(&cond);
       
        pthread_mutex_unlock(&mutex);

        usleep(100);
    }
    return NULL;
}

        消费者线程函数：

void * customerfunc(void * arg){        //消费者不断的消费结点(删除)
    while (1)
    {
        pthread_mutex_lock(&mutex);

        struct ListNode *cur = head;
        if(head != NULL)            //判断是否有数据 (不等于空表示有数据，通知消费者去消费数据) 
        {   
            head = head ->next;
            printf("delete node num: %d , tid: %ld\n", cur->val, pthread_self()); 
            free(cur);
            pthread_mutex_unlock(&mutex);

            usleep(100);
        }
        else
        {
            //没有数据需要等待（wait函数）
            pthread_cond_wait(&cond, &mutex);
            //该函数有两个参数，第二个参数即需要配合使用的锁，这个锁用来解开唤醒这个条件变量的所控制的线程。
            //补充一下，当这个函数调用阻塞的时候，会对互斥锁进行解锁，当不阻塞的时候，继续向下执行，会重新加锁。
            
            pthread_mutex_unlock(&mutex);
        }
    }
    return NULL;
}

          完整代码：

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

/创建条件变量
pthread_cond_t cond;


pthread_mutex_t mutex;

struct ListNode{
    int val;
    struct ListNode *next;
};

struct ListNode *head = NULL;

void * producerfunc(void * arg){        //生产者不断的生产结点
    while (1)
    {      
        pthread_mutex_lock(&mutex);

        struct ListNode *newNode = (struct ListNode*)malloc(sizeof(struct ListNode));        
        newNode ->next = head;
        head = newNode;
        newNode ->val = rand()%1000;
        printf("add Node, num: %d , tid  : %ld\n" , newNode->val , pthread_self());

        /只要生产了一个就通知消费者 消费
        pthread_cond_signal(&cond);
        

        pthread_mutex_unlock(&mutex);

        usleep(100);
    }
    return NULL;
}

void * customerfunc(void * arg){        //消费者不断的消费结点(删除)
    
    while (1)
    {
        pthread_mutex_lock(&mutex);

        struct ListNode *cur = head;
        if(head != NULL)            //判断是否有数据 (不等于空表示有数据，通知消费者去消费数据) 
        {   
            head = head ->next;
            printf("delete node num: %d , tid: %ld\n", cur->val, pthread_self()); 
            free(cur);
            pthread_mutex_unlock(&mutex);

            usleep(100);
        }
        else
        {
            / 没有数据需要等待
            pthread_cond_wait(&cond, &mutex);
             当这个函数调用阻塞的时候，会对互斥锁进行解锁，当不阻塞的时候，继续向下执行，会重新加锁。
            
            pthread_mutex_unlock(&mutex);

        }
    }
    return NULL;
}

int main(){
    //main函数初始化条件变量
    pthread_cond_init(&cond  , NULL);

    pthread_mutex_init(&mutex, NULL);

    //创建5个生产者线程和5个消费者线程
    pthread_t ptids[5] , ctids[5];
    for(int i = 0 ; i<5 ;i++)
    {
        pthread_create(&ptids[i] , NULL , producerfunc , NULL);
        pthread_create(&ctids[i] , NULL , customerfunc , NULL);
    }

    for(int i = 0 ; i<5 ;i++)
    {
        pthread_detach(ptids[i]);
        pthread_detach(ctids[i]);
    }

    pthread_mutex_destroy(&mutex);
    
    //释放条件变量
    pthread_cond_destroy(&cond);
    
    pthread_exit(NULL);

    return 0;
}

         执行结果如下，可以看到，一个生产者线程生产了一个结点后，会通知一个消费者线程进行消费：

信号量

        信号量是一种计数器，用于控制对共享资源的访问。实现的目标与条件变量是相似的，都是用于阻塞线程的存在。主要不同的是，信号量有“信号灯”的概念，灯只有两种状态，要么是亮的，要么是灭的。这也就对应了二进制信号量的 0 ，1 两种状态。 灯亮了代表资源可用，灯灭了代表资源不可用。

        使用信号量其实只是限定了访问资源的次数。如果信号量里的值是0，则会阻塞进程，直到信号灯大于0为止。例如初始化信号灯的值是5，那么调用一次就会-1 ，为0时则会阻塞进程，不允许调用。

        来看看信号量的接口：

    信号量的类型 sem_t
    int sem_init(sem_t *sem, int pshared, unsigned int value);
        - 初始化信号量
        - 参数：
            - 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);

        使用案例：

        还是上面的生产者消费者模型样例，以下是简单的伪代码实现：

    sem_t psem;
    sem_t csem;  初始化信号量

    init(psem, 0, 8);
    init(csem, 0, 0);

    producer() {
        sem_wait(&psem);    会对8进行-1，变成7

        sem_post(&csem);     生产了一个内容要通知消费者去消费，因此要 +1        
    }

    customer() {
        sem_wait(&csem);
        sem_post(&psem)
    }

        

具体实现：

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

///     创建两个信号量
sem_t psem;
sem_t csem;
///


pthread_mutex_t mutex;
struct ListNode{
    int val;
    struct ListNode *next;
};
struct ListNode *head = NULL;

void * producerfunc(void * arg){        //生产者不断的生产结点
    
    while (1)
    {   
        ///   每次生产-1,可以知道在这个循环里生产了8个链表节点,生产者进来先消费一个信号灯
        sem_wait(&psem);        
        ///

        pthread_mutex_lock(&mutex);
        struct ListNode *newNode = (struct ListNode*)malloc(sizeof(struct ListNode));        
        newNode ->next = head;
        head = newNode;
        newNode ->val = rand()%1000;
        printf("add Node, num: %d , tid  : %ld\n" , newNode->val , pthread_self());
        pthread_mutex_unlock(&mutex);

        ///     当上面的减到0时候,证明发送给消费者的就是8了，表示他可以消费8个
        sem_post(&csem);
        ///

    }
    return NULL;
}

void * customerfunc(void * arg){        //消费者不断的消费结点(删除)
    
    while (1)
    {   
        ///   代码到这里 csem的值已经是8了，证明生产者给他生产了8个链表结点可以消费
        sem_wait(&csem);        
        ///

        pthread_mutex_lock(&mutex);
        struct ListNode *cur = head;
        head = head ->next;
        printf("delete node num: %d , tid: %ld\n", cur->val, pthread_self()); 
        free(cur);
        pthread_mutex_unlock(&mutex);

        ///     
        sem_post(&psem);
        ///

    }
    return NULL;
}


int main(){

    ///     初始化两个信号量
    sem_init(&psem , 0 , 8);
    sem_init(&csem , 0 , 0);
    ///

    pthread_mutex_init(&mutex, NULL);

    //创建5个生产者线程和5个消费者线程
    pthread_t ptids[5] , ctids[5];
    for(int i = 0 ; i<5 ;i++)
    {
        pthread_create(&ptids[i] , NULL , producerfunc , NULL);
        pthread_create(&ctids[i] , NULL , customerfunc , NULL);

    }

    for(int i = 0 ; i<5 ;i++)
    {
        pthread_detach(ptids[i]);
        pthread_detach(ctids[i]);
    }

    while (1)
    {
        sleep(10);
    }
    
    pthread_mutex_destroy(&mutex);
    
 
    pthread_exit(NULL);

    return 0;
    
}

读写锁

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

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

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

        

        直接看案例，案例描述，8个线程操作同一个全局变量：3个线程不定时写这个全局变量，5个线程不定时的读这个全局变量。

        读写锁接口：

    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_unlock(pthread_rwlock_t *rwlock);
    
    //上读 OR 写锁
    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);

        1、先创建读写锁：

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

int nums = 0 ;    //全局变量

pthread_rwlock_t rwlock;

int main(){
    //  初始化读写锁
    pthread_rwlock_init(&rwlock , NULL);
    
    pthread_t wtids[3] , rtids[5];

    //创建读， 写线程
    for(int i = 0 ; i<3 ; i++)
    {
        pthread_create(&wtids[i] , NULL , myWrite , NULL);      //写线程池
    }

    for(int i = 0 ; i<5; i++)
    {
        pthread_create(&rtids[i] , NULL , myRead , NULL);       //读线程池
    }

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

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

    pthread_exit(NULL);

    // 释放读写锁
    pthread_rwlock_destroy(&rwlock);

    return 0;
}

        2、初始化工作完毕后，开始编写读写线程的执行函数

        写：

void * myWrite(void *arg){
    while (1)
    {   
        // 写操作加写锁
        pthread_rwlock_wrlock(&rwlock);
        nums++;
        printf("++write , tid: %ld, nums: %d\n" , pthread_self() , nums);
        pthread_rwlock_unlock(&rwlock);

        usleep(100);
    }
    return NULL; 
}

        读：

void * myRead(void *arg){
    while (1)
    {   
        //读操作加读锁
        pthread_rwlock_rdlock(&rwlock);
        printf("==read , tid: %ld, nums: %d\n" , pthread_self() , nums);
        pthread_rwlock_unlock(&rwlock);

        usleep(100);
    }
    return NULL;
}

        整体代码：

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

int nums = 0 ;

pthread_rwlock_t rwlock;

void * myWrite(void *arg){
    while (1)
    {   
        // 写操作加写锁
        pthread_rwlock_wrlock(&rwlock);
        nums++;
        printf("++write , tid: %ld, nums: %d\n" , pthread_self() , nums);
        pthread_rwlock_unlock(&rwlock);

        usleep(100);
    }
    return NULL; 
}
void * myRead(void *arg){
    while (1)
    {   
        // 读操作加读锁
        pthread_rwlock_rdlock(&rwlock);
        printf("==read , tid: %ld, nums: %d\n" , pthread_self() , nums);
        pthread_rwlock_unlock(&rwlock);

        usleep(100);
    }
    return NULL;
}

int main(){
    //  初始化读写锁
    pthread_rwlock_init(&rwlock , NULL);
    
    pthread_t wtids[3] , rtids[5];

    // 创建读， 写线程
    for(int i = 0 ; i<3 ; i++)
    {
        pthread_create(&wtids[i] , NULL , myWrite , NULL);      //写线程池
    }

    for(int i = 0 ; i<5; i++)
    {
        pthread_create(&rtids[i] , NULL , myRead , NULL);       //读线程池
    }

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

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

    // 退出主线程
    pthread_exit(NULL);

    // 释放读写锁
    pthread_rwlock_destroy(&rwlock);

    return 0;
}

        执行结果：

Huuaaaaa
关注
专栏目录
linux系统编程 互斥量mutex
m0_59008960的博客
03-24 769
linux中线程在执行过程中都有可能因为cpu的资源问题而导致暂时失去执行的权利而导致某些问题。 在某些线程例如使用了alarm（）定时后，却应为暂时失去cpu资源而导致下一步动作没能执行pause（），回复执行的权利的时间>定时的时间，导致进程一直挂起。 如果加上锁将alarm（）与pause（）绑定在一起，就能避免这种问题的出现 互斥锁是Linux锁机制中的一种锁，该锁的特点： 同一时刻只能有一个线程持有互斥锁 互斥锁只对执行了加载互斥锁的线程具有作用 互斥锁是一把建议锁，没有强制的限制
Linux下的多线程编程
m0_68431045的博客
12-15 1312
　线程（thread）技术早在60年代就被提出，但真正应用多线程到操作系统中去，是在80年代中期，solaris是这方面的佼佼者。传统的Unix也支持线程的概念，但是在一个进程（process）中只允许有一个线程，这样多线程就意味着多进程。现在，多线程技术已经被许多操作系统所支持，包括Windows/NT，当然，也包括Linux。　　为什么有了进程的概念后，还要再引入线程呢？使用多线程到底有哪些好处？什么的系统应该选用多线程？我们首先必须回答这些问题。 　　使用多线程的理由之一是和进程相比，它是一种非常"节
Linux操作系统应用程序设计——线程
weixin_52109967的博客
08-07 436
Linux操作系统，线程的相关函数
Linux加油站 - IO模型
Huuaaaaa的博客
01-29 81
简述五种IO模型，重点描述 IO多路复用。
RT-Thread快速入门-线程间同步之信号量
一起学嵌入式
02-16 1799
首发，公众号【一起学嵌入式】，RTOS、Linux、C 线程同步是指多个线程通过某种特定的机制，来控制线程之间的先后执行顺序。 RT-Thread 提供了几种线程同步的方式：信号量（semaphore）、 互斥量（mutex）、和事件集（event）。本篇文章主要介绍信号量相关的内容。 信号量的工作机制 信号量是一种可以用来解决线程间同步问题的内核对象，线程通过获取和释放信号量，来达到同步的目的。 每个信号量对象都有一个信号量值和一个线程等待队列，信号量的值表示信号对象的实例数目或者资源数目；线程等待队.
python多线程同步教程,python多线程同步
weixin_34551660的博客
03-26 190
python多线程同步作者:vpoet日期:大约在夏季import threadingimport timemylock = threading.RLock()num=0class myThread(threading.Thread):def __init__(self, name):threading.Thread.__init__(self)self.t_name = namedef run(...
一文搞懂Linux内核之内核线程
m0_74282605的博客
11-15 2636
Linux内核可以看作服务进程（管理软硬件资源，响应用户进程的各种进程）。内核需要多个执行流并行，为了防止可能的阻塞，支持多线程。内核线程就是内核的一个分身，可以用以处理一件特定事情，内核线程的调度由内核负责，一个内核线程的处于阻塞状态时不影响其他的内核线程。内核线程是直接由内核本身启动的进程。内核线程实际上是将内核函数委托给独立的进程执行，它与内核中的其他“进程”并行执行。内核线程经常被称之为内核守护进程。周期性地将修改的内存页与页来源块设备同步如果内存页很少使用，则写入交换区。
Linux内存管理-SMP缓存一致性
m0_74282605的博客
03-11 241
但如果是write back系统，就不太容易，因为有可能有个处理器修改了该数据（将其标为dirty），但是还没有写到内存中，即最新的值在该处理器的私有cache中。解决：发生cache miss的处理器会将所需数据地址放到总线上，其他所有处理器均会监听，如果发现自己有该地址的dirty副本，则响应请求。多处理器系统：有些数据是多个处理器共享的，共享数据在每个cache中(每个处理器具有私有的L1 cache)均缓存，带来缓存一致性问题。MSI缺陷：操作不是原子性的，可能造成死锁和竞争，解决办法，
浅析Linux内核同步机制之completion
m0_74282605的博客
12-10 120
这个活动可能是，创建一个新的内核线程或者新的用户空间进程、对一个已有进程的某个请求，或者某种类型的硬件动作，等等。不看内核实现的源代码我们也能想到他的实现，不外乎在wait函数中循环等待done变为可用（正），而另一边的complete函数为唤醒函数，当然是将done加一，唤醒待处理的函数。2， insmod complete.ko 插入驱动模块，这里要注意的是，因为我们的代码中是手动分配的设备号，很可能被系统已经使用了，所以如果出现这种情况，查看/proc/devices文件。找一个没有被使用的设备号。
多线程编程--5种方法实现线程同步
m0_74282605的博客
10-14 195
还有一点值得注意：如果要同步的代码执行得很快，在出现争夺资源的时候，系统把其他线程挂起，而当前线程又马上执行完成了，系统又将挂起的线程唤醒，这个过程是非常浪费CPU的，也影响程序的性能，为了避免这种情况，可以结合旋转锁和CRITICAL_SECTION，先用旋转锁轮询一定次数，还不能获得资源，再将线程挂起，等待资源被释放，系统再将线程唤醒，实现这一功能的就是方法。在实现线程同步时，建议用方法2和方法3，如不能解决你的需求，再用方法4，方法5，用内核对象实现的线程同步性能要差一些。
Linux性能优化之磁盘优化
m0_74282605的博客
11-29 1193
关于本章内容，设计的东西比较多。这里会有关于文件系统、磁盘、CPU等方面的知识，以及涉及到关于这方面的性能排查等。
【值得收藏】Linux内核原理理解
m0_74282605的博客
11-14 1028
当进程再次被调度回来的时候，通过cpu_context中保存的ip回到了cpu_switch_to的下一条指令继续执行，而由于cpu_context中保存的sp导致当前进程回到自己的内核栈，经过一系列的内核栈的出栈处理，最后将原来保存在pt_regs中的通用寄存器的值恢复到了通用寄存器，这样进程回到用户空间就可以继续沿着被中断打断的下一条指令开始执行，用户栈也回到了被打断之前的位置，而进程访问的指令数据做地址转化也都是从自己的pgd开始进行一切对用户来说就好像没有发生一样。文件的层级表示关系。
Linux内核CPU调度域内容讲解
m0_74282605的博客
11-22 924
如果用户不知道怎么办？除非当前进程的优先级高于系统中所有被锁定的资源的优先级的上限，否则任务尝试执行临界区的时候会被阻塞；时间切片，每个队列都得到一个确定的能够调度其进程的CPU总时间，例如，80%给前台，20%给后台。因为有的用户可能开的进程多，有的用户进程少。但是切换之前要保护现场，保存当前进程/线程在PCB/TCP中的执行上下文(也就是CPU的状态)；需要考虑的问题是 调度的时机（从一个状态到另一个状态的时候会发生调度 ）。可以是抢占的也可以是不抢占的，对于抢占类型的，才是SRT（最短剩余时间）。
linux内核设计与实现
m0_74282605的博客
03-20 827
/禁止中断请求锁 spin_lock_irqsave(&mr_lock);//确保中断是激活的情况可用的方法 spin_lock_irq(&mr_lock) /**临界区**/ spin_unlock_irq(&mr_lock) spin_unlock_irqrestore(&mr_lock);/**只读临界区**/ read_unlock(&mr_rwlock) write_lock(&mr_rwlock) /**读写临界区**/ write_unlock(&mr_rwlock)以达到快速检索的目的。
Java-网络
2301_81543552的博客
09-14 778
Java中的网络编程主要涉及使用Socket类进行网络通信，以及理解各种网络协议。以下是一些关键概念和示例代码，帮助您入门。
Java企业面试题3
最新发布
m0_74972727的博客
09-15 761
1. break和continue的作用(智*图) break：用于完全退出一个循环（如 for, while）或一个 switch 语句。当在循环体内遇到break语句时，程序会立即跳出当前循环体，继续执行循环之后的代码。 continue：用于跳过当前循环体中剩余的部分，并开始下一次循环。如果是在 for 循环中使用continue，则会直接进行条件判断以决定是否执行下一轮循环。 2. if分支语句和switch分支语句的异同之处(智*图) 相同点：都是用来根据不同的条件执行不同的代码块。
上传文件到钉盘流程详解
jspyth的博客
09-14 797
本文详解如何通过钉钉的API实现上传文件到钉盘目录，代码通过JAVA实现。
自动生成不重复的订单id
ClaireCheney的博客
09-13 340
【代码】自动生成不重复的订单id。
Linux系统中互斥锁实现线程同步
"《Linux 高级程序设计(第2版)》中详细阐述了Linux线程间同步机制，特别是互斥锁的概念和操作。互斥锁作为一种关键的同步工具，用于防止多个线程并发访问共享资源，确保数据的一致性。互斥锁具有两种状态：开锁...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值