进程、线程和进程间通信——线程的取消和互斥

最新推荐文章于 2025-12-30 14:18:03 发布
原创 最新推荐文章于 2025-12-30 14:18:03 发布 · 209 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#linux #bash #vim

本文详细介绍了Linux线程的取消、清理、互斥锁和读写锁的使用，以及如何避免死锁。重点讲解了pthread库中的线程取消点、互斥锁的初始化、申请和释放，以及读写锁的特性与应用。同时，探讨了防止死锁的策略，如调整获取锁的顺序。

目录

一、线程的取消

 二、线程的清理

三、线程通信 – 互斥

1.互斥锁的相关概念

2.互斥锁初始化 – pthread_mutex_init

3.互斥锁的创建、销毁和使用

（1）创建互斥锁

（2）锁的销毁：

（3）互斥锁的使用：

4.申请和释放锁

（1）申请锁 – pthread_mutex_lock

（2）释放锁 – pthread_mutex_unlock

四、读写锁

1.读写锁特性：

2.读写锁的使用

五、死锁的避免

1.死锁的概念（两把或以上的锁才会出现死锁）

 2.死锁的避免

（1）通过时间改变顺序

 （2）通过改变获得锁的顺序

一、线程的取消

int pthread_cancel(pthread_t thread);

作用：随时杀掉一个线程

示例代码：pthread_cancel函数可以直接杀死一个线程然后通过pthread_jion函数回收

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

void * func(void *arg)
{
    printf("This is child thread\n");
    while(1)//取消点
    {
        sleep(2);
    }
    pthread_exit("thread return\n");//前面有阻塞函数，线程无法用该函数退出
}

int main()
{
    pthread_t tid;
    void *retv;
    int i;

    pthread_create(&tid,NULL,func,NULL);
    sleep(5);
    pthread_cancel(tid);
    pthread_join(tid,&retv);//线程没有退出无法用该函数回收
    while(1)
    {
        sleep(1);
    }

}

执行结果：线程被杀掉一个

注意：线程的取消要有取消点才可以，不是说取消就取消，线程的取消点主要是阻塞的系统调用

如果没有取消点，手动设置一个：

void pthread_testcancel(void);

设置取消使能或禁止：

int pthread_setcancelstate(int state, int *oldstate);

PTHREAD_CANCEL_ENABLE    //能取消

PTHREAD_CANCEL_DISABLE   //不能取消

示例代码：线程运行时有些内容期望执行完再被取消，需要手动设置能否取消的参数。

void *func(void *arg)
{
    printf("This is child thread\n");

    pthread_setcancelstate(PTHREAD_CANCEL_DISABLE,NULL);//下面程序执行完前不能取消    
   
    sleep(5);
    pthread_testcancel();//手动设置取消点
  
    pthread_setcancelstate(PTHREAD_CANCEL_ENABLE,NULL);//下面程序执行完前能取消
    
    while(1)
    {
        sleep(1);
    }
    pthread_exit("thread return");
}

设置取消类型（了解）：

int pthread_setcanceltype(int type, int *oldtype);

PTHREAD_CANCEL_DEFERRED                等到取消点才取消

PTHREAD_CANCEL_ASYNCHRONOUS           目标线程会立即取消

 二、线程的清理

必要性： 当线程非正常终止，需要清理一些资源

void pthread_cleanup_push(void (*routine) (void *), void *arg)

void pthread_cleanup_pop(int execute)

routine 函数被执行的条件：

  1. 被pthread_cancel取消掉。
  2. 执行pthread_exit
  3. 非0参数执行pthread_cleanup_pop()

注意：

  1. 必须成对使用，即使pthread_cleanup_pop不会被执行到也必须写上，否则编译错误。
  2. pthread_cleanup_pop()被执行且参数为0，pthread_cleanup_push回调函数routine不会被执行.
  3. pthread_cleanup_push 和pthread_cleanup_pop可以写多对，routine执行顺序正好相反
  4. 线程内的return 可以结束线程，也可以给pthread_join返回值，但不能触发pthread_cleanup_push里面的回调函数，所以我们结束线程尽量使用pthread_exit退出线程。

三、线程通信 – 互斥

1.互斥锁的相关概念

临界资源：

        一次只允许一个任务(进程、线程)访问的共享资源

        不能同时访问的资源，比如写文件，只能由一个线程写，同时写会写乱。

        比如外设打印机，打印的时候只能由一个程序使用，外设基本上都是不能共享的资源。

        生活中比如卫生间，同一时间只能由一个人使用。

        必要性： 临界资源不可以共享

临界区：访问临界资源的代码

互斥机制 ：mutex互斥锁，任务访问临界资源前申请锁，访问完后释放锁

2.互斥锁初始化 – pthread_mutex_init

#include  <pthread.h>  

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

要点： 

成功时返回0，失败时返回错误码  

mutex  指向要初始化的互斥锁对象  

attr  互斥锁属性，NULL表示缺省属性

注：man手册找不到 pthread_mutex_xxxxxxx （提示No manual entry for pthread_mutex_xxx）的解决方法：

apt-get install manpages-posix-dev

3.互斥锁的创建、销毁和使用

（1）创建互斥锁

动态方式：

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

其中mutex attr用于指定互斥锁属性，如果为NULL则使用缺省属性。

静态方式：

pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;

（2）锁的销毁：

int pthread_mutex_destroy(pthread_mutex_t *mutex)

在Linux中，互斥锁并不占用任何资源，因此LinuxThreads中的 pthread_mutex_destroy()除了检查锁状态以外（锁定状态则返回EBUSY）没有其他动作。

（3）互斥锁的使用：

int pthread_mutex_lock(pthread_mutex_t *mutex)

int pthread_mutex_unlock(pthread_mutex_t *mutex)

int pthread_mutex_trylock(pthread_mutex_t *mutex)

vim 设置代码全文格式化：gg=G

4.申请和释放锁

（1）申请锁 – pthread_mutex_lock

#include  <pthread.h>  

int  pthread_mutex_lock(pthread_mutex_t *mutex);  

int pthread_mutex_trylock(pthread_mutex_t *mutex)  

要点：

成功时返回0，失败时返回错误码  

mutex  指向要初始化的互斥锁对象  

pthread_mutex_lock 如果无法获得锁，任务阻塞

pthread_mutex_trylock 如果无法获得锁，返回EBUSY而不是挂起等待

（2）释放锁 – pthread_mutex_unlock

 #include  <pthread.h>  

int  pthread_mutex_unlock(pthread_mutex_t *mutex);  

要点：

成功时返回0，失败时返回错误码  

mutex  指向要初始化的互斥锁对象  执行完临界区要及时释放锁

示例代码：实现多个线程写一个文件，使用互斥锁

#include <pthread.h>
#include <stdio.h>
#include <unistd.h>
#include <string.h>
 
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;//静态初始化
//如果有多个临界资源，需要定义多个锁
 
FILE *fp;

void *func2(void *arg)
{
    pthread_detach(pthread_self());
    printf("This is func2 thread\n");
    
    char str[] = "I write func2 line\n";
    char c;
    int i = 0;
    while(1)
    {
        pthread_mutex_lock(&mutex);//加锁
        while(i < strlen(str))//把字符一个个写进文件
        {
            c = str[i];
            fputc(c,fp);
            usleep(1);//usleep单位是微秒
            i++;
        }
        pthread_mutex_unlock(&mutex);//解锁
        i=0;
        usleep(1);//释放cpu，不让while（1）一直运行
    }
 
    pthread_exit("func2 exit"); 
}
 
void *func(void *arg)
{
    pthread_detach(pthread_self());
    printf("This is func1 thread\n");
    char str[] = "You read func1 thread\n";
    char c;
    int i = 0;
    while(1)
    {
        pthread_mutex_lock(&mutex);
        while(i < strlen(str))
        {
            c = str[i];
            fputc(c,fp);
            i++;
            usleep(1);
        }
        pthread_mutex_unlock(&mutex);
        i=0;
        usleep(1);
    }
    pthread_exit("func1 exit");
}
 
 
int main()
{
    pthread_t tid,tid2;
    void *retv;
    int i;
    fp = fopen("1.txt","a+");
    if(fp == NULL)
    {
        perror("fopen");
        return 0;
    }
 
    pthread_create(&tid,NULL,func,NULL);
    pthread_create(&tid2,NULL,func2,NULL);
    while(1)
    {    
        sleep(1);
    } 
 
}

四、读写锁

必要性：提高线程执行效率

1.读写锁特性：

写者：写者使用写锁，如果当前没有读者，也没有其他写者，写者立即获得写锁；否则写者将等待，直到没有读者和写者。

读者：读者使用读锁，如果当前没有写者，读者立即获得读锁；否则读者等待，直到没有写者。

注意：

（1）同一时刻只有一个线程可以获得写锁，同一时刻可以有多个线程获得读锁。

（2）读写锁出于写锁状态时，所有试图对读写锁加锁的线程，不管是读者试图加读锁，还是写者试图加写锁，都会被阻塞。

（3）读写锁处于读锁状态时，有写者试图加写锁时，之后的其他线程的读锁请求会被阻塞，以避免写者长时间的不写锁

2.读写锁的使用

初始化一个读写锁   pthread_rwlock_init

读锁定读写锁       pthread_rwlock_rdlock

非阻塞读锁定　　   pthread_rwlock_tryrdlock

写锁定读写锁      pthread_rwlock_wrlock

非阻塞写锁定      pthread_rwlock_trywrlock

解锁读写锁         pthread_rwlock_unlock

释放读写锁         pthread_rwlock_destroy

示例代码:读锁和写锁的使用区别

#include <pthread.h>
#include <stdio.h>
#include <unistd.h>
#include <string.h>
 
 
pthread_rwlock_t rwlock;//定义一个读写锁
 
FILE *fp;

void * read_func(void *arg)
{
    pthread_detach(pthread_self());
    printf("read thread\n");
    char buf[32] = {0};
    while(1)
    {
        rewind(fp);//把流指针指向这里
        pthread_rwlock_rdlock(&rwlock);//读锁
        while(fgets(buf,32,fp) != NULL)
        {
            printf("%d,rd=%s\n",(int)arg,buf);//第几个线程读的
            usleep(1000);
        }
        pthread_rwlock_unlock(&rwlock);//读解锁
        sleep(1);
    }
 
}
 
 
void *func2(void *arg)
{
    pthread_detach(pthread_self());
    printf("This is func2 thread\n");
    
    char str[] = "I write func2 line\n";
    char c;
    int i = 0;
    while(1)
    {
        pthread_rwlock_wrlock(&rwlock);//写锁
        while(i < strlen(str))
        {
            c = str[i];
            fputc(c,fp);
            usleep(1);
            i++;
        }
        pthread_rwlock_unlock(&rwlock);//写解锁
        i = 0;
        usleep(1); 
    }
 
    pthread_exit("func2 exit");
 
}
 
void *func(void *arg)
{
    pthread_detach(pthread_self());
    printf("This is func1 thread\n");
    char str[] = "You read func1 thread\n";
    char c;
    int i = 0;
    while(1)
    {
        pthread_rwlock_wrlock(&rwlock);
        while(i < strlen(str))
        {
            c = str[i];
            fputc(c,fp);
            i++;
            usleep(1);
        }
        pthread_rwlock_unlock(&rwlock);
        i = 0;
        usleep(1);
 
    }
    pthread_exit("func1 exit");
}
 
 
int main()
{
    pthread_t tid1,tid2,tid3,tid4;
    void *retv;
    int i;
    fp = fopen("1.txt","a+");
    if(fp == NULL)
    {
        perror("fopen");
        return 0;
    }
    pthread_rwlock_init(&rwlock,NULL);
    pthread_create(&tid1,NULL,read_func,1);
    pthread_create(&tid2,NULL,read_func,2);
	sleep(3);
    pthread_create(&tid3,NULL,func,NULL);
    pthread_create(&tid4,NULL,func2,NULL);
    while(1)
    {    
        sleep(1);
    } 
 
}

五、死锁的避免

1.死锁的概念（两把或以上的锁才会出现死锁）

 2.死锁的避免

（1）通过时间改变顺序

示例代码：

#include <pthread.h>
#include <stdio.h>
#include <unistd.h>
#include <string.h>
 
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t mutex2 = PTHREAD_MUTEX_INITIALIZER;//两把锁
 
FILE *fp;
void *func2(void *arg)
{
    pthread_detach(pthread_self());
    printf("This is func2 thread\n");
    
    char str[] = "I write func2 line\n";
    char c;
    int i = 0;
    while(1)
    {
        pthread_mutex_lock(&mutex2);//获得锁2
        printf("%d,I got lock2\n",(int)arg);//打印线程序号
        sleep(1);
        pthread_mutex_lock(&mutex);//获得锁1
        printf("%d,I got 2 locks\n",(int)arg);
 
        pthread_mutex_unlock(&mutex);
        pthread_mutex_unlock(&mutex2);
        sleep(10);
    }
    pthread_exit("func2 exit");
}
 
void *func(void *arg)
{
    pthread_detach(pthread_self());
    printf("This is func1 thread\n");
    char str[] = "You read func1 thread\n";
    char c;
    int i = 0;
    while(1)
    {
        pthread_mutex_lock(&mutex);
        printf("%d,I got lock1\n",(int)arg);
        sleep(1);
        pthread_mutex_lock(&mutex2);
        printf("%d,I got 2 locks\n",(int)arg);
 
        pthread_mutex_unlock(&mutex2);
        pthread_mutex_unlock(&mutex);
        sleep(10);//休息10s，这个时候线程2可以去获得了
    }
    pthread_exit("func1 exit");
}
 
 
int main()
{
    pthread_t tid,tid2;
    void *retv;
    int i;
    fp = fopen("1.txt","a+");
    if(fp == NULL)
    {
        perror("fopen");
        return 0;
    }
    pthread_create(&tid,NULL,func,1);
	sleep(5);//线程1先执行，两把锁都获得了并释放了，这个时候线程2才去获得，就不会死锁
    pthread_create(&tid2,NULL,func2,2);
 
    while(1)
    {    
        sleep(1);
    } 
 
}

 （2）通过改变获得锁的顺序

示例代码：

​
#include <pthread.h>
#include <stdio.h>
#include <unistd.h>
#include <string.h>
 
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t mutex2 = PTHREAD_MUTEX_INITIALIZER;//两把锁
 
FILE *fp;

void *func2(void *arg)
{
    pthread_detach(pthread_self());
    printf("This is func2 thread\n");
    
    char str[] = "I write func2 line\n";
    char c;
    int i = 0;
    while(1)
    {
        pthread_mutex_lock(&mutex);
        printf("%d,I got lock2\n",(int)arg);//打印线程序号
        sleep(1);
        pthread_mutex_lock(&mutex2);
        printf("%d,I got 2 locks\n",(int)arg);
 
        pthread_mutex_unlock(&mutex2);
        pthread_mutex_unlock(&mutex);
        sleep(10);
    }
    pthread_exit("func2 exit");
}
 
void *func(void *arg)
{
    pthread_detach(pthread_self());
    printf("This is func1 thread\n");
    char str[] = "You read func1 thread\n";
    char c;
    int i = 0;
    while(1)
    {
        pthread_mutex_lock(&mutex);
        printf("%d,I got lock1\n",(int)arg);
        sleep(1);
        pthread_mutex_lock(&mutex2);
        printf("%d,I got 2 locks\n",(int)arg);
 
        pthread_mutex_unlock(&mutex2);
        pthread_mutex_unlock(&mutex);
        sleep(10);
    }
    pthread_exit("func1 exit");
}
 
 
int main()
{
    pthread_t tid,tid2;
    void *retv;
    int i;
    fp = fopen("1.txt","a+");
    if(fp == NULL)
    {
        perror("fopen");
        return 0;
    }
    pthread_create(&tid,NULL,func,1);
    pthread_create(&tid2,NULL,func2,2);
    while(1)
    {    
        sleep(1);
    } 
 
}

​

Riley_L
关注
【系统面试篇】进程和线程类（1）（笔记）——区别、通讯方式、同步、互斥、锁分类
CXDNW的博客
11-02 994
目录 一、问题综述 1. 进程和线程的区别？ 2.进程的状态有哪些？ 3.进程之间的通信方式? （1）管道 （2）消息队列 （3）共享内存 （4）信号量 （5）信号 （6）Socket 4.解释一下进程同步和互斥，以及解决这些问题的方法？ （1）互斥的概念 （2）同步的概念 （3）锁 （4）信号量 （5）使用信号量和 PV 操作 5.什么是死锁？如何避免死锁？ （1）互斥条件 （2）持有并等待条件 （3）不可剥夺条件 （4）环路等待条件 ​​​​​​​（5
进程与线程（四）——进程间通信
WWWWwwwBJ的博客
02-24 947
C语言提供了多种进程通信机制（如管道、信号、消息队列、共享内存、信号量和套接字），每种方法都有其特定的应用场景。选择合适的通信方法取决于进程间数据传递的需求、性能考虑和同步要求。
进程同步互斥以及通信机制
bbbbobbb的博客
08-16 992
进程之所以会产生同步和互斥问题，一切源于进程的并发执行。如果是单个进程的话，是不可能产生互斥和同步问题的。 一个最经典的例子就是ATM问题： 进程互斥 由于各个进程要求使用共享资源，而这些资源需要排他性使用，各个进程之间竞争使用这些资源，这一关系称为进程互斥。 临界资源：系统中某些资源一次只允许一个进程使用 临界区：各个进程中对某个临界资源实施操作的程序片段 临界区使用原则： 没有进程在临界区时，想进入临界区的进程可以进入 不允许两个进程同时处于临界区 临界区外运行的进程不得阻塞其他进程进入临界区 不得
进程的同步、互斥、通信的区别，进程与线程同步的区别
qq_43966957的博客
11-15 345
进程的同步、互斥、通信的区别，进程与线程同步的区别
笔记总结 | 线程、进程的概念和区别、进程间通信、线程间通信
大虎牙的博客
06-25 996
请你说一下进程与线程的概念，以及为什么要有进程线程，其中有什么区别，他们各自又是怎么同步的。 01 基本概念： 进程是对运行时程序的封装，是系统进行资源调度和分配的的基本单位，实现了操作系统的并发； 一个程序加载到内存后就变为进程。进程 = 程序 + 执行。线程可以理解为进程中执行的一段程序片段。 线程是进程的子任务，是CPU调度和分派的基本单位，用于保证程序的实时性，实现进程内部的并发； 线程是操作系统可识别的最小执行和调度单位。每个线程都独自占用一个虚拟处理器：独自的寄存器组，指令计数器和处理器状.
【王道考研】进程同步与互斥
qq_45495899的博客
11-28 808
2.3.1 进程同步与互斥 知识来源： B站王道考研 什么是进程同步 知识回顾：进程具有异步性的特征。异步性是指，各并发执行的进程以各自独立的、不可预知的速度向前推进。 读进程和写进程并发地运行，由于并发必然导致异步性，因此“写数据”和“读数据”两个操作执行的先后顺序是不确定的。而实际应用中，又必须按照“写数据 --> 读数据”的顺序来执行的。 如果解决这种异步问题，就是“进程同步”所讨论的内容。 同步也称为直接制约关系，它是指为完成某种任务而建立的两个或多个进程，这些进程因为需要在某些位置上协调他
进程间通信（一）：竞争条件与互斥方案
HCodeRunner的博客
03-29 2132
进程间通信（一）：进程之间的冲突与处理方式                                                            ——《现代操作系统第二章第三节》      1、问题的提出      我们想象一个假脱机打印程序，当一个进程需要打印一个文件时，它会将该文件放在一个假脱机目录下。另一个进程负责周期性地检查是否有文件需要被打印，如果有就打印并将其在目
Linux应用编程——线程间同步机制与进程间通信
weixin_69590097的博客
08-18 1007
本文摘要介绍了代码设计和进程/线程管理的核心概念。代码设计强调低耦合、高内聚原则；线程同步重点讲解了信号量机制及其操作步骤，并分析了死锁的四个必要条件与解决方法。进程间通信部分对比了管道（无名/有名）、信号、共享内存等传统IPC方式与网络Socket通信的特性及实现方法。文中还提供了常用系统函数如memset的说明，涵盖了从代码结构到并发控制的软件开发关键技术点。
Linux进程通信和线程通信
雪飞_海
01-29 2862
1、进程和线程是什么 简单的描述：进程好比是工厂，线程是工厂里的生产线，一个进程里面可以包含多个线程。 专业术语：进程是cpu资源分配的最小单位，线程是cpu调度的最小单位。 每个进程都有独立的代码和数据空间（程序上下文），程序之间的切换会有较大的开销；线程可以看做轻量级的进程，同一 类线程共享代码和数据空间，每个线程都有自己独立的运行栈和程序计数器（PC），...
高级进程间通信问题——快速排序问题1
08-03
【高级进程间通信问题——快速排序问题1】的实验是一个基于操作系统原理的编程挑战，旨在实现一个多线程或多进程的快速排序算法。这个实验在Ubuntu 18.04.5 LTS环境下进行，采用C/C++编程语言，并且允许使用C++11的...
进程间通信经典——银行柜员服务问题
11-13
在IT领域，进程间通信（IPC，Inter-Process Communication）是多进程系统中不同进程之间交换数据的...这个例子不仅有助于理解进程间通信的基本概念，而且可以帮助开发者掌握在Windows环境下使用C++进行线程同步的方法。
【操作系统】进程(线程)间同步互斥问题——熟睡的理发师问题
壹小崔的博客
04-04 7521
问题描述:熟睡的理发师问题描述的是多个进程(线程)之间的通信与同步问题:有一个理发师的椅子，和n个顾客的椅子如果有顾客在椅子上等，那么理发师为他剪发，否则理发师就在自己的椅子上睡觉。如果理发师在熟睡，那么顾客会叫醒理发师，否则顾客会看有没有空椅子，有的话，他坐下等，否则，他将离开理发店。问题分析：首先是避免死锁，也就是理发师一直在睡觉，所以我们采取让顾客叫醒理发师的方式，只要理发师一空闲下来，等待...
多进程通信 互斥量
liuguangsh的博客
08-05 1577
多进程通信： 线程一代码： #include #include #include char name[100] = "shanghai"; void main() { //互斥量在内核创建。 // 参数：1、指向安全属性的指针， //2、 初始化互斥对象的所有者，如创建进程希望立即拥有互斥体，则设为TRUE。一个互斥体同时只能由一个线程拥有 //3、 指向互斥对象名的指针 //一旦
进程间通信同步方法（互斥）
LittleMonkey的博客
05-17 3602
进程间通信（Inter Process Communication, IPC）要解决三个问题：（1）进程间如何传递信息（2）确保两个或更多进程在关键活动中不会出现交叉（3）有协作关系的进程的时序问题竞争条件（race condition）定义：多个进程读写某些共享数据，而最后的结果取决于进程运行的精确时序。互斥（mutual exclusion）定义：对于个共享数据，同一时刻只有一个进程操作他。临...
Linux:五种IO模型
2301_80894970的博客
12-27 991
本文介绍了五种I/O模型的理论概念，重点分析了非阻塞I/O和多路转接I/O模式。文章通过钓鱼的生动比喻，阐述了阻塞I/O、非阻塞I/O、信号驱动I/O、多路检测I/O和异步I/O的区别。详细讲解了select、poll和epoll三种多路转接技术的实现原理和代码示例，比较了它们的优缺点。特别深入分析了epoll的水平触发(LT)和边缘触发(ET)两种工作模式，指出ET模式必须配合非阻塞I/O使用才能发挥最佳性能。通过理论讲解和代码实现相结合的方式，全面展示了Linux系统下高效I/O处理的实现方法和技术演进
基于 Linux 内核模块的字符设备互斥访问实验
weixin_57340941的博客
12-30 444
这个信号量实验是。
Linux CFS 调度器深度解析
最新发布
X
12-30 776
数学模型驱动: 用 vruntime 精确量化公平性简单性: 核心算法简洁优雅, 易于理解和维护自适应性: 自动适应不同负载和工作模式可扩展性: 通过组调度支持复杂场景表5: CFS 调度器的核心优势总结维度传统调度器CFS改进效果公平性基于优先级的时间片按权重的比例公平更精确的公平分配交互性需要启发式识别自然获得良好响应交互进程响应更快吞吐量固定时间片可能浪费动态调整, 减少切换整体吞吐量提升可配置性多个复杂参数主要调整 nice 值用户接口更简单代码维护复杂启发式逻辑。
Linux 实战：从零实现动态进度条（含缓冲区原理与多版本优化）
会当凌绝顶，一览众山小
12-28 2087
在 Linux 开发中，进度条是最基础也最实用的系统程序之一 —— 无论是文件下载、编译构建还是数据处理，一个直观的动态进度条能极大提升用户体验。但看似简单的进度条，背后藏着行缓冲区、回车换行区别、字符刷新等关键知识点。本文从基础概念入手，先拆解进度条的实现逻辑，再逐步实现 “固定速度” 和 “自适应进度” 两个版本，最后优化细节让进度条更流畅美观，帮你不仅 “会写”，还能 “理解为什么这么写”。
Linux系统下的进程调度与线程通信实验解析
管道（Pipeline）是一种用于进程间通信的机制，而有名管道（FIFO）则是一种特殊类型的管道，它以文件的形式存在于文件系统中。 1. **有名管道程序**：在这种机制下，进程可以通过FIFO文件进行数据交换。一个进程...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值