imToken安卓版官方网址|swap指令

作者： imToken安卓版官方网址

2024-03-17 05:51:22

【转载】Linux SWAP 深度解读 - 知乎

【转载】Linux SWAP 深度解读 - 知乎切换模式写文章登录/注册【转载】Linux SWAP 深度解读ZeroKernel、Storage原文链接： https://mp.weixin.qq.com/s?__biz=MzA4Nzg5Nzc5OA==&mid=2651660097&idx=1&sn=a3d38e3af2c9d8d431c46fe7680b428d&scene=2&srcid=0606f21oK1jm1IKMwEyi6aNz&from=timeline&isappinstalled=0#wechat_redirect作者简介邹立巍Linux系统技术专家。目前在腾讯SNG社交网络运营部计算资源平台组，负责内部私有云平台的建设和架构规划设计。曾任新浪动态应用平台系统架构师，负责微博、新浪博客等重点业务的内部私有云平台架构设计和运维管理工作。编者的话邹老师关于Linux研究的技术文章向来入木三分，如果本文您读起来感觉费解，那么可以先收藏，然后侧重了解这些内容：swap、swappiness及kswapd原理，swap分区优先级的妙用。真可谓一文在手，SWAP从此不再忧愁。敬请笑纳。概述本文讨论的swap基于Linux4.4内核代码。Linux内存管理是一套非常复杂的系统，而swap只是其中一个很小的处理逻辑。希望本文能让读者了解Linux对swap的使用大概是什么样子。阅读完本文，应该可以帮你解决以下问题：1、swap到底是干嘛的？2、swappiness到底是用来调节什么的？3、kswapd什么时候会进行swap操作？4、什么是内存水位标记？5、swap分区的优先级（priority）有啥用？1、什么是SWAP，到底是干嘛的？我们一般所说的swap，指的是一个交换分区或文件。在Linux上可以使用swapon -s命令查看当前系统上正在使用的交换空间有哪些，以及相关信息：[zorro@zorrozou-pc0 linux-4.4]$ swapon -s

Filename Type Size Used Priority

/dev/dm-4 partition 33554428 0 -1从功能上讲，交换分区主要是在内存不够用的时候，将部分内存上的数据交换到swap空间上，以便让系统不会因内存不够用而导致oom或者更致命的情况出现。所以，当内存使用存在压力，开始触发内存回收的行为时，就可能会使用swap空间。内核对swap的使用实际上是跟内存回收行为紧密结合的。那么关于内存回收和swap的关系，我们需要思考以下几个问题：为什么要进行内存回收？哪些内存可能会被回收呢？回收的过程中什么时候会进行交换呢？具体怎么交换？下面我们就从这些问题出发，一个一个进行分析。为什么要进行内存回收？内核之所以要进行内存回收，主要原因有两个：内核需要为任何时刻突发到来的内存申请提供足够的内存。所以一般情况下保证有足够的free空间对于内核来说是必要的。另外，Linux内核使用cache的策略虽然是不用白不用，内核会使用内存中的page cache对部分文件进行缓存，以便提升文件的读写效率。所以内核有必要设计一个周期性回收内存的机制，以便cache的使用和其他相关内存的使用不至于让系统的剩余内存长期处于很少的状态。当真的有大于空闲内存的申请到来的时候，会触发强制内存回收。所以，内核在应对这两类回收的需求下，分别实现了两种不同的机制：一个是使用kswapd进程对内存进行周期检查，以保证平常状态下剩余内存尽可能够用。另一个是直接内存回收（directpagereclaim），就是当内存分配时没有空闲内存可以满足要求时，触发直接内存回收。这两种内存回收的触发路径不同：一个是由内核进程kswapd直接调用内存回收的逻辑进行内存回收；参见mm/vmscan.c中的kswapd()主逻辑另一个是内存申请的时候进入slow path的内存申请逻辑进行回收。参见内核代码中的mm/page_alloc.c中的__alloc_pages_slowpath方法这两个方法中实际进行内存回收的过程殊途同归，最终都是调用shrink_zone()方法进行针对每个zone的内存页缩减。这个方法中会再调用shrink_lruvec()这个方法对每个组织页的链表进程检查。找到这个线索之后，我们就可以清晰的看到内存回收操作究竟针对的page有哪些了。这些链表主要定义在mm/vmscan.c一个enum中：根据这个enum可以看到，内存回收主要需要进行扫描的链表有如下4个：anon的inactiveanon的activefile的inactivefile的active就是说，内存回收操作主要针对的就是内存中的文件页（file cache）和匿名页。关于活跃（active）还是不活跃（inactive）的判断内核会使用lru算法进行处理并进行标记，我们这里不详细解释这个过程。整个扫描的过程分几个循环：首先扫描每个zone上的cgroup组；然后再以cgroup的内存为单元进行page链表的扫描；内核会先扫描anon的active链表，将不频繁的放进inactive链表中，然后扫描inactive链表，将里面活跃的移回active中；进行swap的时候，先对inactive的页进行换出；如果是file的文件映射page页，则判断其是否为脏数据，如果是脏数据就写回，不是脏数据可以直接释放。这样看来，内存回收这个行为会对两种内存的使用进行回收:一种是anon的匿名页内存，主要回收手段是swap；另一种是file-backed的文件映射页，主要的释放手段是写回和清空。因为针对filebased的内存，没必要进行交换，其数据原本就在硬盘上，回收这部分内存只要在有脏数据时写回，并清空内存就可以了，以后有需要再从对应的文件读回来。内存对匿名页和文件缓存一共用了四条链表进行组织，回收过程主要是针对这四条链表进行扫描和操作。2、swappiness到底是用来调节什么的？很多人应该都知道/proc/sys/vm/swappiness这个文件，是个可以用来调整跟swap相关的参数。这个文件的默认值是60，可以的取值范围是0-100。这很容易给大家一个暗示：我是个百分比哦！那么这个文件具体到底代表什么意思呢？我们先来看一下说明：======swappinessThis control is used to define how aggressive the kernel will swap memory pages. Higher values will increase agressiveness, lower values decrease the amount of swap.A value of 0 instructs the kernel not to initiate swap until the amount of free and file-backed pages is less than the high water mark in a zone.The default value is 60.======这个文件的值用来定义内核使用swap的积极程度：值越高，内核就会越积极的使用swap；值越低，就会降低对swap的使用积极性。如果这个值为0，那么内存在free和file-backed使用的页面总量小于高水位标记（high water mark）之前，不会发生交换。在这里我们可以理解file-backed这个词的含义了，实际上就是上文所说的文件映射页的大小。那么这个swappiness到底起到了什么作用呢？我们换个思路考虑这个事情。假设让我们设计一个内存回收机制，要去考虑将一部分内存写到swap分区上，将一部分file-backed的内存写回并清空，剩余部分内存出来，我们将怎么设计？我想应该主要考虑这样几个问题:如果回收内存可以有两种途径（匿名页交换和file缓存清空），那么我应该考虑在本次回收的时候，什么情况下多进行file写回，什么情况下应该多进行swap交换。说白了就是平衡两种回收手段的使用，以达到最优。如果符合交换条件的内存较长，是不是可以不用全部交换出去？比如可以交换的内存有100M，但是目前只需要50M内存，实际只要交换50M就可以了，不用把能交换的都交换出去。分析代码会发现，Linux内核对这部分逻辑的实现代码在get_scan_count()这个方法中，这个方法被shrink_lruvec()调用。get_sacn_count()就是处理上述逻辑的，swappiness是它所需要的一个参数，这个参数实际上是指导内核在清空内存的时候，是更倾向于清空file-backed内存还是更倾向于进行匿名页的交换的。当然，这只是个倾向性，是指在两个都够用的情况下，更愿意用哪个，如果不够用了，那么该交换还是要交换。简单看一下get_sacn_count()函数的处理部分代码，其中关于swappiness的第一个处理是：这里注释的很清楚：如果swappiness设置为100，那么匿名页和文件将用同样的优先级进行回收。很明显，使用清空文件的方式将有利于减轻内存回收时可能造成的IO压力。因为如果file-backed中的数据不是脏数据的话，那么可以不用写回，这样就没有IO发生，而一旦进行交换，就一定会造成IO。所以系统默认将swappiness的值设置为60，这样回收内存时，对file-backed的文件cache内存的清空比例会更大，内核将会更倾向于进行缓存清空而不是交换。这里的swappiness值如果是60，那么是不是说内核回收的时候，会按照60:140的比例去做相应的swap和清空file-backed的空间呢？并不是。在做这个比例计算的时候，内核还要参考当前内存使用的其他信息。对这里具体是怎么处理感兴趣的人，可以自己详细看get_sacn_count()的实现，本文就不多解释了。我们在此要明确的概念是：swappiness的值是用来控制内存回收时，回收的匿名页更多一些还是回收的file cache更多一些。swappiness设置为0的话，是不是内核就根本不会进行swap了呢？这个答案也是否定的。首先是内存真的不够用的时候，该swap的话还是要swap。其次在内核中还有一个逻辑会导致直接使用swap，内核代码是这样处理的：这里的逻辑是说，如果触发的是全局回收，并且zonefile + zonefree <= high_wmark_pages(zone)条件成立时，就将scan_balance这个标记置为SCAN_ANON。后续处理scan_balance的时候，如果它的值是SCAN_ANON，则一定会进行针对匿名页的swap操作。要理解这个行为，我们首先要搞清楚什么是高水位标记（high_wmark_pages）。3、kswapd什么时候会进行swap操作？我们回到kswapd周期检查和直接内存回收的两种内存回收机制。直接内存回收比较好理解，当申请的内存大于剩余内存的时候，就会触发直接回收。那么kswapd进程在周期检查的时候触发回收的条件是什么呢？还是从设计角度来看，kswapd进程要周期对内存进行检测，达到一定阈值的时候开始进行内存回收。这个所谓的阈值可以理解为内存目前的使用压力，就是说，虽然我们还有剩余内存，但是当剩余内存比较小的时候，就是内存压力较大的时候，就应该开始试图回收些内存了，这样才能保证系统尽可能的有足够的内存给突发的内存申请所使用。4、什么是内存水位标记？(watermark)那么如何描述内存使用的压力呢？Linux内核使用水位标记（watermark）的概念来描述这个压力情况。Linux为内存的使用设置了三种内存水位标记:high、low、min。他们所标记的含义分别为：剩余内存在high以上表示内存剩余较多，目前内存使用压力不大；high-low的范围表示目前剩余内存存在一定压力；low-min表示内存开始有较大使用压力，剩余内存不多了；min是最小的水位标记，当剩余内存达到这个状态时，就说明内存面临很大压力。小于min这部分内存，内核是保留给特定情况下使用的，一般不会分配。内存回收行为就是基于剩余内存的水位标记进行决策的：当系统剩余内存低于watermark[low]的时候，内核的kswapd开始起作用，进行内存回收。直到剩余内存达到watermark[high]的时候停止。如果内存消耗导致剩余内存达到了或超过了watermark[min]时，就会触发直接回收（direct reclaim）。明白了水位标记的概念之后，zonefile + zonefree <= high_wmark_pages(zone)这个公式就能理解了。这里的zonefile相当于内存中文件映射的总量，zonefree相当于剩余内存的总量。内核一般认为，如果zonefile还有的话，就可以尽量通过清空文件缓存获得部分内存，而不必只使用swap方式对anon的内存进行交换。整个判断的概念是说，在全局回收的状态下（有global_reclaim(sc)标记），如果当前的文件映射内存总量+剩余内存总量的值评估小于等于watermark[high]标记的时候，就可以进行直接swap了。这样是为了防止进入cache陷阱，具体描述可以见代码注释。这个判断对系统的影响是，swappiness设置为0时，有剩余内存的情况下也可能发生交换。那么watermark相关值是如何计算的呢？所有的内存watermark标记都是根据当前内存总大小和一个可调参数进行运算得来的，这个参数是：/proc/sys/vm/min_free_kbytes首先这个参数本身决定了系统中每个zone的watermark[min]的值大小。然后内核根据min的大小并参考每个zone的内存大小分别算出每个zone的low水位和high水位值。想了解具体逻辑可以参见源代码目录下的该文件：mm/page_alloc.c在系统中可以从/proc/zoneinfo文件中查看当前系统的相关的信息和使用情况。我们会发现以上内存管理的相关逻辑都是以zone为单位的，这里zone的含义是指内存的分区管理。Linux将内存分成多个区，主要有:直接访问区(DMA)一般区(Normal)高端内存区(HighMemory)内核对内存不同区域的访问因为硬件结构因素会有寻址和效率上的差别。如果在NUMA架构上，不同CPU所管理的内存也是不同的zone。相关参数设置zone_reclaim_mode：zone_reclaim_mode模式是在2.6版本后期开始加入内核的一种模式，可以用来管理当一个内存区域(zone)内部的内存耗尽时，是从其内部进行内存回收还是可以从其他zone进行回收的选项，我们可以通过/proc/sys/vm/zone_reclaim_mode文件对这个参数进行调整。在申请内存时(内核的get_page_from_freelist()方法中)，内核在当前zone内没有足够内存可用的情况下，会根据zone_reclaim_mode的设置来决策是从下一个zone找空闲内存还是在zone内部进行回收。这个值为0时表示可以从下一个zone找可用内存，非0表示在本地回收。这个文件可以设置的值及其含义如下：echo 0 > /proc/sys/vm/zone_reclaim_mode：意味着关闭zone_reclaim模式，可以从其他zone或NUMA节点回收内存。echo 1 > /proc/sys/vm/zone_reclaim_mode：表示打开zone_reclaim模式，这样内存回收只会发生在本地节点内。echo 2 > /proc/sys/vm/zone_reclaim_mode：在本地回收内存时，可以将cache中的脏数据写回硬盘，以回收内存。echo 4 > /proc/sys/vm/zone_reclaim_mode：可以用swap方式回收内存。不同的参数配置会在NUMA环境中对其他内存节点的内存使用产生不同的影响，大家可以根据自己的情况进行设置以优化你的应用。默认情况下，zone_reclaim模式是关闭的。这在很多应用场景下可以提高效率，比如文件服务器，或者依赖内存中cache比较多的应用场景。这样的场景对内存cache速度的依赖要高于进程进程本身对内存速度的依赖，所以我们宁可让内存从其他zone申请使用，也不愿意清本地cache。如果确定应用场景是内存需求大于缓存，而且尽量要避免内存访问跨越NUMA节点造成的性能下降的话，则可以打开zone_reclaim模式。此时页分配器会优先回收容易回收的可回收内存（主要是当前不用的page cache页），然后再回收其他内存。打开本地回收模式的写回可能会引发其他内存节点上的大量的脏数据写回处理。如果一个内存zone已经满了，那么脏数据的写回也会导致进程处理速度收到影响，产生处理瓶颈。这会降低某个内存节点相关的进程的性能，因为进程不再能够使用其他节点上的内存。但是会增加节点之间的隔离性，其他节点的相关进程运行将不会因为另一个节点上的内存回收导致性能下降。除非针对本地节点的内存限制策略或者cpuset配置有变化，对swap的限制会有效约束交换只发生在本地内存节点所管理的区域上。min_unmapped_ratio：这个参数只在NUMA架构的内核上生效。这个值表示NUMA上每个内存区域的pages总数的百分比。在zone_reclaim_mode模式下，只有当相关区域的内存使用达到这个百分比，才会发生区域内存回收。在zone_reclaim_mode设置为4的时候，内核会比较所有的file-backed和匿名映射页，包括swapcache占用的页以及tmpfs文件的总内存使用是否超过这个百分比。其他设置的情况下，只比较基于一般文件的未映射页，不考虑其他相关页。page-cluster：page-cluster是用来控制从swap空间换入数据的时候，一次连续读取的页数，这相当于对交换空间的预读。这里的连续是指在swap空间上的连续，而不是在内存地址上的连续。因为swap空间一般是在硬盘上，对硬盘设备的连续读取将减少磁头的寻址，提高读取效率。这个文件中设置的值是2的指数。就是说，如果设置为0，预读的swap页数是2的0次方，等于1页。如果设置为3，就是2的3次方，等于8页。同时，设置为0也意味着关闭预读功能。文件默认值为3。我们可以根据我们的系统负载状态来设置预读的页数大小。swap的相关操纵命令可以使用mkswap将一个分区或者文件创建成swap空间。swapon可以查看当前的swap空间和启用一个swap分区或者文件。swapoff可以关闭swap空间。我们使用一个文件的例子来演示一下整个操作过程：制作swap文件：启用swap文件：关闭swap空间：5、swap分区的优先级（priority）有啥用？在使用多个swap分区或者文件的时候，还有一个优先级的概念（Priority）。在swapon的时候，我们可以使用-p参数指定相关swap空间的优先级，值越大优先级越高，可以指定的数字范围是－1到32767。内核在使用swap空间的时候总是先使用优先级高的空间，后使用优先级低的。当然如果把多个swap空间的优先级设置成一样的，那么两个swap空间将会以轮询方式并行进行使用。如果两个swap放在两个不同的硬盘上，相同的优先级可以起到类似RAID0的效果，增大swap的读写效率。另外，编程时使用mlock()也可以将指定的内存标记为不会换出，具体帮助可以参考man 2 mlock。最后关于swap的使用建议，针对不同负载状态的系统是不一样的。有时我们希望swap大一些，可以在内存不够用的时候不至于触发oom-killer导致某些关键进程被杀掉，比如数据库业务。也有时候我们希望不要swap，因为当大量进程爆发增长导致内存爆掉之后，会因为swap导致IO跑死，整个系统都卡住，无法登录，无法处理。这时候我们就希望不要swap，即使出现oom-killer也造成不了太大影响，但是不能允许服务器因为IO卡死像多米诺骨牌一样全部死机，而且无法登陆。跑cpu运算的无状态的apache就是类似这样的进程池架构的程序。所以：swap到底怎么用?要还是不要？设置大还是小？相关参数应该如何配置？是要根据我们自己的生产环境的情况而定的。阅读完本文后希望大家可以明白一些swap的深层次知识。Q&A：一个内存剩余还比较大的系统中，是否有可能使用swap？A: 有可能，如果运行中的某个阶段出发了这个条件”zonefile+zonefree<=high_wmark_pages(zone)“，就可能会swap。swappiness设置为0就相当于关闭swap么？A: 不是的，关闭swap要使用swapoff命令。swappiness只是在内存发生回收操作的时候用来平衡cache回收和swap交换的一个参数，调整为0意味着，尽量通过清缓存来回收内存。A: swappiness设置为100代表系统会尽量少用剩余内存而多使用swap么？不是的，这个值设置为100表示内存发生回收时，从cache回收内存和swap交换的优先级一样。就是说，如果目前需求100M内存，那么较大机率会从cache中清除50M内存，再将匿名页换出50M，把回收到的内存给应用程序使用。但是这还要看cache中是否能有空间，以及swap是否可以交换50m。内核只是试图对它们平衡一些而已。kswapd进程什么时候开始内存回收？A: kswapd根据内存水位标记决定是否开始回收内存，如果标记达到low就开始回收，回收到剩余内存达到high标记为止。如何查看当前系统的内存水位标记？A: cat /proc/zoneinfo。发布于 2020-02-17 10:03Linux 系统管理Linux 入门赞同 362 条评论分享喜欢收藏申请

操作系统中的Swap指令实现互斥(java实现)-CSDN博客

操作系统中的Swap指令实现互斥(java实现)

最新推荐文章于 2023-09-24 15:27:55 发布

夜石

最新推荐文章于 2023-09-24 15:27:55 发布

阅读量5.2k

点赞数

分类专栏：

java

计算机理论与基础

文章标签：

操作系统

java

swap指令

本文链接：https://blog.csdn.net/Abit_Go/article/details/104025325

版权

java

同时被 2 个专栏收录

89 篇文章

2 订阅

订阅专栏

计算机理论与基础

13 篇文章

2 订阅

订阅专栏

在学习操作系统这本书的时候，我们使用的是汤小丹老师的《计算机操作系统》接下来我将会使用java语言去实现内部代码。

Swap指令

该指令又称为对换指令，在Intel 80x86中又称为XCHG指令，用于交换两个字的内容。下面为伪代码。

void swap(boolean *a,boolean *b){

boolean temp;

temp = *a;

*a = *b;

*b = temp;

}

方法是为每个临界资源设置一个全局的布尔变量lock，初值为false，在每个进程中再利用一个局部变量key，利用swap指令实现进程互斥的循环进程，下面为伪代码描述。

do{

key = true;

do{

swap(&lock,&key);

}while(key!=false);

//临界区操作

lock = false;

}while(true);

利用上述硬件指令能够有效地实现进程互斥，但当临界资源忙碌时，其他访问进程必须不断地进行尝试，处于一种忙等的状态，不符合“让权等待”的原则，造成处理机时间的浪费，同时难以解决复杂问题。

接下来为java语言描述。

package chapter02;

//the class is the operation system's code

public class P057Swap {

private static int buffer;

private static boolean lock;

public static void main(String[] args) {

lock = false;

buffer = 0;

Thread prov = new ProvThreadClass();

prov.start();

Thread cust = new CustThreadClass();

cust.start();

}

public static boolean swap(boolean param){

boolean temp = lock;

lock = param;

param = temp;

//将替换的param参数回调回去

return param;

}

static class ProvThreadClass extends Thread{

@Override

public void run() {

while(true){

//缓冲池满的话

if(buffer==10){

}

else{

boolean key = true;

do{

//将key值兑换，除非当前的lock为false的时候就可以跳出循环

key = swap(key);

}while (key!=false);

buffer+=1;

System.out.println("生产出1件产品，目前剩余产品个数:"+buffer);

lock = false;

}

try {

Thread.sleep(200);

} catch (InterruptedException e) {

e.printStackTrace();

}

static class CustThreadClass extends Thread{

@Override

public void run() {

while(true){

//缓冲池空的话

if(buffer==0){

}

else{

boolean key = true;

do{

//将key值兑换，除非当前的lock为false的时候就可以跳出循环

key = swap(key);

}while (key!=false);

buffer-=1;

System.out.println("消费1件产品，目前剩余产品个数:"+buffer);

lock = false;

}

try {

Thread.sleep(300);

} catch (InterruptedException e) {

e.printStackTrace();

}

实验代码运行结果：

"C:\Program Files\Java\jdk1.8.0_101\bin\java.exe"

生产出1件产品，目前剩余产品个数:1

消费1件产品，目前剩余产品个数:0

生产出1件产品，目前剩余产品个数:1

消费1件产品，目前剩余产品个数:0

生产出1件产品，目前剩余产品个数:1

消费1件产品，目前剩余产品个数:0

生产出1件产品，目前剩余产品个数:1

生产出1件产品，目前剩余产品个数:2

消费1件产品，目前剩余产品个数:1

生产出1件产品，目前剩余产品个数:2

消费1件产品，目前剩余产品个数:1

生产出1件产品，目前剩余产品个数:2

生产出1件产品，目前剩余产品个数:3

消费1件产品，目前剩余产品个数:2

生产出1件产品，目前剩余产品个数:3

消费1件产品，目前剩余产品个数:2

生产出1件产品，目前剩余产品个数:3

生产出1件产品，目前剩余产品个数:4

消费1件产品，目前剩余产品个数:3

生产出1件产品，目前剩余产品个数:4

消费1件产品，目前剩余产品个数:3

生产出1件产品，目前剩余产品个数:4

生产出1件产品，目前剩余产品个数:5

消费1件产品，目前剩余产品个数:4

生产出1件产品，目前剩余产品个数:5

消费1件产品，目前剩余产品个数:4

生产出1件产品，目前剩余产品个数:5

生产出1件产品，目前剩余产品个数:6

消费1件产品，目前剩余产品个数:5

生产出1件产品，目前剩余产品个数:6

消费1件产品，目前剩余产品个数:5

生产出1件产品，目前剩余产品个数:6

生产出1件产品，目前剩余产品个数:7

消费1件产品，目前剩余产品个数:6

生产出1件产品，目前剩余产品个数:7

消费1件产品，目前剩余产品个数:6

生产出1件产品，目前剩余产品个数:7

生产出1件产品，目前剩余产品个数:8

消费1件产品，目前剩余产品个数:7

生产出1件产品，目前剩余产品个数:8

消费1件产品，目前剩余产品个数:7

生产出1件产品，目前剩余产品个数:8

生产出1件产品，目前剩余产品个数:9

Process finished with exit code -1

优惠劵

夜石

关注

踩

觉得还不错?

一键收藏

知道了

操作系统中的Swap指令实现互斥(java实现)

在学习操作系统这本书的时候，我们使用的是汤小丹老师的《计算机操作系统》接下来我将会使用java语言去实现内部代码。Swap指令该指令又称为对换指令，在Intel 80x86中又称为XCHG指令，用于交换两个字的内容。下面为伪代码。void swap(boolean *a,boolean *b){ boolean temp; temp = *a; *a = *...

复制链接

扫一扫

专栏目录

Cadence中实现Swap Pin功能.rar

07-06

在进行大的bga PCB设计的时候，特别是fpga，经常会用到swap pin（管脚交换），文档亲测可用，希望对大家有所帮助。

Linux系统中swap分区的设置与增加/删除

09-15

我们都知道在安装Linux系统时在分区时可以分配swap分区，而系统安装后（在运行中）如何建立或调整swap分区呢？下面这篇文章主要给大家介绍了关于Linux系统中swap分区的设置与增加/删除的相关资料，需要的朋友可以参考下

参与评论

您还未登录，请先

后发表或查看评论

TIA博途-AT指令实现双字中高低字转换的全局FB库文件-GF-AT-Swap.zip

03-02

TIA博途_AT指令实现双字中高低字转换的全局FB库文件

操作系统进程互斥的实现

EDG_Clearlove_7的博客

10-30

1106

操作系统各种互斥资源访问的方法介绍

操作系统_进程与线程(三)

light_2025的博客

07-31

197

首先设置临界区意愿数组，P0 进程首先表达自己想要进入临界区的意愿，然后将 turn 设置为 1 ，表示谦让，我愿意让 P1 进程先进入临界区，然后通过 while 去判断 P1 进程是否也有进入临界区的意愿，如果 P1 进程有进入临界区的意愿，并且 P0 进程也愿意让 P1 优先进入临界区，那么 P0 进程的 while 循环成立，P0 进程等待，P1 进程进入临界区；当有进程存在于临界区时，S 的值为 0，再有进程要进入临界区，执行 P 操作时将会被阻塞，直至在临界区中的进程退出，

进程互斥的实现方法

weixin_53908084的博客

04-01

3042

将某资源比作厕所的一个仅有的马桶。。。

当有两个及以上的进程（几个便秘人）想要访问资源时（马桶），必须要排队，一个一个的访问，不能两个人一起进去，会发生意外。这是因为在同一个时间段内，一个资源只能由一个进程所访问。

设置一个循环条件，若进程满足条件，则会一直循环，一直等到不满足之后，跳出循坏，使用资源。

一软件实现方式

1 单标准检测法

当进程被调度之后，处理机为这个进程服务，然后检查资源是否能够被访问。

此算法是如果要想进入厕所使用马桶，需要有一个通行证，拿到这个特权，才能访问资源。

设置

第二章-进程同步与互斥

伊甸园的博客

09-27

1010

管程是一种特殊的软件模块，有以下部分组成1 局部于管程的共享数据结构说明；2 对该数据结构进行操作的一组过程‘3 对局部于管程的共享数据设置初始值的语句；4 管程有一个名字；基本特征1 局部于管程的数据只能被局部于管程的过程所访问2 一个进程只有通过调用管程的过程才能进入管程访问共享数据；3 每次仅允许一个进程在管程内执行某个内部过程；

三菱FX5U传送指令

weixin_55762091的博客

05-04

1990

MOV传送指令

CML取反传送指令

XCH数据交换

SWAP高低字节交换指令

BMOV传送指令

FMOV多点传送指令

利用Swap指令进程互斥实现

qq_34204094的博客

10-24

5190

这里用线程来模拟硬件方法同步机制的Swap方法指令利用下面的代码能有效的实现进程互斥但当临界资源忙碌时其他访问进程必须不断测试处于一种忙等状态不符合让权等待造成处理机时间的浪费同时很难用于解决复杂的进程问题

#include "iostream.h"

#include "windows.h"

const int N=5,M=3;

//int Max[N][M]={0

【Linux】互斥量原理的实现

Sxy_wspsby的博客

06-10

951

为了实现互斥锁操作大多数体系结构都提供了swap或exchange指令该指令的作用是把寄存器和内存单元的数据相交换,由于只有一条指令保证了原子性即使是多处理器平台访问内存的总线周期也有先后一个处理器上的交换指令执行时另一个处理器的交换指令只能等待总线周期。如下图：对于上图中的加锁解锁汇编代码，是谁在执行呢？答案是调用的线程。这里圈出来的汇编代码的意思是：将共享数据交换到自己的私有上下文当中。

CentOS7系统增加swap的操作方法实例

01-10

内存不够用时系统便将内存中的部分数据腾挪到swap中，为正在运行的程序腾出内存。使用swap能让系统运行更多或更大型的程序，但由于swap的读写速度远逊于内存，频繁使用swap可能让系统和程序有延迟卡顿。大内存...

CSS3实现swap交换动画

09-24

主要为大家介绍了CSS3实现swap动画，实现一个交换动画，一个笑脸慢慢从远处，回到自己的原来位置的一种效果，这种动画在JS里面也是很多见的，感兴趣的小伙伴们可以参考一下

c语言swap的作用,C语言中swap的作用和用法 c语言中swap 是什么意思？

热门推荐

weixin_42303389的博客

05-16

3万+

导航：网站首页 >C语言中swap的作用和用法 c语言中swap 是什么意思？C语言中swap的作用和用法 c语言中swap 是什么意思？相关问题:匿名网友:1.作用：swap的意思是交换两个变量的值，是一个自定义函数。2.用法：使a和b的值进行互换。例如：void swap(int*p1,int*p2) //*p1=a;*p2=b;改变指针指向的地址的值，即a和b的值互换。3.其他用...

三菱st编程手册_通过示例学习三菱ST编程（SUM指令和MOV指令的应用示例）

weixin_39800331的博客

12-06

2905

有人在学习PLC时总会说指令太多没有办法全都记住，我这里想说的是：你说的对，是很难全都记住，但是呢，要对一些指令有一些的了解，最起码的是知道有哪些指令，具体怎么用可以在用时查手册即可。今天要跟大家分享的就是ON位数指令(SUM)和MOV指令综合应用的示例。示例的功能要求：四个按钮分别控制四组灯，当某一个按钮按下时，则此按钮对应的灯亮，同时按多个按钮，则无效。具体程序如下图所示：很简单就是用到了SU...

第二章进程与线程十四、进程互斥的硬件实现方法（中断屏蔽法、TestAndSet指令、Swap指令）

最新发布

icbbm的博客

09-24

168

有的地方也叫Exchange指令，或简称XCHG指令。Swap 指令是用硬件实现的，执行的过程不允许被中断，只能气呵成。

王道操作系统考研笔记——2.3.3 进程互斥的硬件实现方法

弄鹊

02-26

410

2.3.3 进程互斥的硬件实现方法

c语言swap指令_c语言范式编程之swap

weixin_35473217的博客

12-24

5764

引言C语言是一门古老的语言，没有C++语言的诸如模版、应用、面向对象的高级特性。对于数据的交换，只能使用指针来实现。在C语言中，一般使用如下的方法来实现两个整数的交换： 1: void swap(int *ap, int *bp)2: {3: int tmp = *ap;4: int *ap = *bp;5: *bp = tmp;6: }然后，使用如下方法来实现数据交换：1: int x = 1...

进程互斥的硬件实现方法

m0_52559870的博客

05-20

1097

一、中断屏蔽方法

利用“开/关中断指令”实现

（与原语的实现思想相同，即在某进程开始访问临界区到结束访问为止都不允许被中断，也就不能发生进程切换，因此也不可能发生两个同时访问临界区的情况)

关中断后即不允许当前进程被中断，也必然不会发生进程切换

直到当前进程访问完临界区，再执行开中断指令，才有可能有别的进程上处理机并访问临界区

优点:简单、高效

缺点:不适用于多处理机;只适用于操作系统内核进程，不适用于用户进程（因为开/关中断指令只能运行在内核态，这组指令如果能让用户随意使用会很...

关于mybatis返回update的id值

韦海涛的博客

07-07

7148

再次说明一下,本文大部分是搬运的,这该死的mybatis.真骚断了我的腰.原文可以看这个博主大哥的.我就是提个醒的而已.侵权即删https://blog.csdn.net/u012373815/article/details/73864866

废话不多说,上map和xml代码

int changeTaskApplyToEffective(Map...

swap函数实现Java插入排序

03-30

以下是Java插入排序的swap函数实现：

```java

public static void swap(int[] arr, int i, int j) {

int temp = arr[i];

arr[i] = arr[j];

arr[j] = temp;

}

```

该函数接收一个整型数组arr，以及两个整数i和j作为参数。它会将arr[i]和arr[j]的值进行交换，从而实现交换操作。在Java中，数组是引用类型，因此在该函数中直接修改数组元素的值可以影响到调用该函数的代码中的数组。

“相关推荐”对你有帮助么？

非常没帮助

没帮助

一般

有帮助

非常有帮助

提交

夜石

CSDN认证博客专家

CSDN认证企业博客

码龄8年

暂无认证

136

原创

5万+

周排名

202万+

总排名

33万+

访问

等级

4107

积分

粉丝

129

获赞

323

私信

关注

热门文章

python文件选择对话框

58658

idea里external libraries的引用不显示

15602

关于mybatis返回update的id值

7148

操作系统中的Test-and-Set指令实现互斥(java实现)

6710

Redis实战-chapter1

5884

分类专栏

nlp

4篇

后端

18篇

前端

2篇

scala

2篇

android

8篇

电信北向对接

1篇

23篇

python

8篇

蓝桥杯试题

2篇

数据结构与算法

42篇

java

89篇

机器学习

7篇

redis

3篇

计算机理论与基础

13篇

最新评论

Android实战(天气查询+网络通讯)

菜Cai^-^*:

想问一下大佬是用哪个版本的安卓写的？

pytorch安装过程中出现torch.cuda.isavailable()=False问题

我叫陈大同:

谢谢up，学废了

操作系统中的Test-and-Set指令实现互斥(java实现)

majy:

test and set 要原子操作，你没锁怎么玩的转？给ts方法加锁才行

机器学习知识整理

我叫陈大同:

韦老师写得可真好，希望早日出视频

idea里external libraries的引用不显示

wdjie1012:

看个鬼

您愿意向朋友推荐“博客详情页”吗？

强烈不推荐

不推荐

一般般

最新文章

论文复现集合

Numpy部分函数解析

pytorch安装过程中出现torch.cuda.isavailable()=False问题

2023年1篇

2022年6篇

2021年18篇

2020年54篇

2019年24篇

2018年16篇

2017年25篇

2016年4篇

分类专栏

nlp

4篇

后端

18篇

前端

2篇

scala

2篇

android

8篇

电信北向对接

1篇

23篇

python

8篇

蓝桥杯试题

2篇

数据结构与算法

42篇

java

89篇

机器学习

7篇

redis

3篇

计算机理论与基础

13篇

被折叠的条评论

为什么被折叠?

到【灌水乐园】发言

查看更多评论

添加红包

祝福语

请填写红包祝福语或标题

红包数量

个

红包个数最小为10个

红包总金额

元

红包金额最低5元

余额支付

当前余额3.43元

前往充值 >

需支付：10.00元

取消

确定

下一步

知道了

成就一亿技术人!

领取后你会自动成为博主和红包主的粉丝

规则

hope_wisdom 发出的红包

实付元

使用余额支付

点击重新获取

扫码支付

钱包余额

抵扣说明：

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

余额充值

Linux 中 Swap 交换分区设置教程，以及 Swap 大小与内存的关系 - 知乎

Linux 中 Swap 交换分区设置教程，以及 Swap 大小与内存的关系 - 知乎首发于老王的互联网笔记切换模式写文章登录/注册Linux 中 Swap 交换分区设置教程，以及 Swap 大小与内存的关系kingggg老王最近有一台 VPS 一直报内存占用太高，所以想看看 Linux Swap 交换分区功能，用硬盘空间换内存空间。本文分享下 Linux 中 Swap 交换分区设置教程，以及我们在设置 Swap 分区时，如何决定 Swap 的大小。一、Swap 分区是什么Swap（Swap 分区、Swap 内存），中文名是交换分区，类似于 Windows 中的虚拟内存，就是当内存不足的时候，把一部分硬盘空间虚拟成内存使用，从而解决内存容量不足的情况。因此，Swap 分区的作用就是牺牲硬盘，增加内存，解决 VPS 内存不够用或者爆满的问题。二、Swap 分区大小选择Swap 合理的大小是与 VPS 的物理内存有关的，目前老王找到一个比较靠谱的关系表（Red Hat Enterprise Linux）：内存 <= 4g：Swap 至少 4G内存 4~16G：Swap 至少 8G内存 16G~64G：Swap 至少 16G内存 64G~256G：Swap 至少 32G老王有一台 2GB 的 VPS，最开始 Swap 是 2GB，后来升级成了 4GB，内存占用如下图所示，效果非常明显：三、Swap 分区设置教程1.查看 Linux 当前分区情况：free -m如果是增加 swap 分区，则先把当前所有分区都关闭了：swapoff -a可能遇到的问题：《解决 swapoff failed: Cannot allocate memory 无法关闭分区的问题》2.创建要作为 Swap 分区文件（其中 /var/swapfile 是文件位置，bs*count 是文件大下，例如以下命令就会创建一个 4G 的文件）：dd if=/dev/zero of=/var/swapfile bs=1M count=40963.建立 Swap 的文件系统（格式化为 Swap 分区文件）：mkswap /var/swapfile4.启用 Swap 分区：swapon /var/swapfile5.查看 Linux 当前分区：free -m如果有 Swap 就说明创建成功了：6.设置开启启动，在 /etc/fstab 文件中加入一行代码：/var/swapfile swap swap defaults 0 0参考：Linux 创建和增加 Swap 分区教程 - 老王博客Linux 中交换空间 Swap 应该设置多大？与内存大小的关系整理 - 老王博客搬瓦工VPS增加Swap交换分区内存教程 - 搬瓦工优惠网编辑于 2021-08-15 14:40LinuxSwap 分区swap分区赞同 281 条评论分享喜欢收藏申请转载文章被以下专栏收录老王的互联网笔记记录一下自己的互联网

百度知道 - 信息提示

百度首页

商城

网页

资讯

视频

图片

知道

文库

贴吧采购

地图更多

搜索答案

我要提问

百度知道>提示信息

知道宝贝找不到问题了>_

该问题可能已经失效。返回首页

15秒以后自动返回

帮助

| 意见反馈

| 投诉举报

【OS 操作系统】047 | 进程同步与互斥 - 知乎

【OS 操作系统】047 | 进程同步与互斥 - 知乎切换模式写文章登录/注册【OS 操作系统】047 | 进程同步与互斥柠檬沙棘1996互联网行业工程师操作系统[20] 进程同步、进程互斥1. 进程同步进程具有异步性的特征。异步性是指，各并发执行的进程以各自独立的、不可预知的速度向前推进。操作系统要提供“进程同步机制”来解决异步问题。以管道通信为例：写进程和读进程并发进行，由于并发必然导致异步性，二者不可预知。所以“写数据”和“读数据”两个操作执行的先后顺序是不确定的，而实际应用中，又必须按照“写数据 -> 读数据”的顺序来执行。同步又称之为直接制约关系，指为完成某种任务而建立的两个或者多个进程，这些进程因为需要在某些位置协调他们的工作次序而产生的制约关系。进程间的直接制约关系就是来源于他们之间的相互合作。2. 进程互斥（Mutually Exclusive）进程的“并发”需要“共享”的支持。各个并发执行的进程不可避免的需要共享一些系统资源（比如内存，又比如打印机、摄像头这样的I/O设备）。 1. 互斥共享系统中的某些资源，虽然可以提供给多个进程使用，但一个时间段内只允许一个进程访问该资源。 2. 同时共享方式系统中的某些资源，允许一个时间段内由多个进程“同时”对它们进行访问。临界资源（Critical Section）：我们把一个时间段内只允许一个进程使用的资源称为临界资源。许多物理设备（比如摄像头、打印机）都属于临界资源。此外还有许多变量、数据、内存缓冲区等都属于临界资源。对临界资源的访问，必须互斥地进行。互斥，亦称间接制约关系。进程互斥指当一个进程访问某临界资源时，另一个想要访问该临界资源的进程必须等待。当前访问临界资源的进程访问结束，释放该资源之后，另一个进程才能去访问临界资源。对临界资源的互斥访问，可以在逻辑上分为如下四个部分：do {

entry section; // 进入区

critical section; // 临界区

exit section; // 退出区

remainder section; // 剩余区

}

while(true);进入区：负责检查是否可进入临界区，若可进入，则应设置正在访问临界资源的标志（可理解为“上锁”），以阻止其他进程同时进入临界区。临界区：访问临界资源的那段代码。退出区：负责解除正在访问临界资源的标志（可理解为“解锁”）。剩余区：做其他处理。★注意：临界区是进程中访问临界资源的代码段。进入区和退出区是负责实现互斥的代码段。临界区也可称为“临界段”。 ★为了实现对临界资源的互斥访问，同时保证系统整体性能，需要遵循以下原则： 1. 空闲让进。临界区空闲时，可以允许一个请求进入临界区的进程立即进入临界区； 2. 忙则等待。当已有进程进入临界区时，其他试图进入临界区的进程必须等待； 3. 有限等待。对请求访问的进程，应保证能在有限时间内进入临界区（保证不会饥饿）； 4. 让权等待。当进程不能进入临界区时，应立即释放处理机，防止进程忙等待。[21] 进程互斥的软件实现方法如果没有进程互斥会怎样加入进程 P_1 、进程 P_2 在系统中并发地运行，都需要使用打印机。先调度进程 P_1 上处理机运行，进程 P_1 在使用打印机的过程中，假如分配给它的时间片用完了，接下来操作系统调度进程 P_2 让它上处理机运行，进程 P_2 也在使用打印机。这样的结果，就是进程1、进程2 的打印内容混在一起了。因此有必要实现进程间的互斥。1. 单标志法算法思想：两个进程在访问完临界区后会把使用临界区的权限转交给另一个进程。也就是说每个进程进入临界区的权限只能被另一个进程赋予。int turn = 0; // turn 表示当前允许进入临界区的进程号

// turn = 0, 表示当前 0 号进程被允许进入临界区

// P_0 进程：

while(turn != 0); // 1

critical section; // 2

turn = 1; // 3

remainder section; // 4

// P_1 进程

while(turn != 1); // 5

critical section; // 6

turn = 0; // 7

remainder section; // 8算法解释： 1. turn 的初值为 0，即刚开始只允许 0 号进程进入临界区。 2. 若 P_1 先上处理机运行，则会一直卡在代码5。直到 P_1 的时间片用完，发生调度，切换 P_0 上处理机运行。 3. 代码 1不会卡住 P_0 ， P_0 可以正常访问临界区，在 P_0 访问临界区期间即时切换回 P_1 ， P_1 依然会卡在代码5。 4. 只有 P_0 在退出区将 turn 改为 1 后，P_1 才能进入临界区。因此，该算法可以实现 “同一时刻最多只允许一个进程访问临界区”。turn 变量背后的逻辑：表达谦让.单标志法存在的主要问题是：违背“空闲让进”原则。(例如，当处理机是空闲状态的时候，如此时某进程，进程1表示当前我需要使用处理机，而处理机此前刚刚被进程1执行完毕，那么由于此前会做出谦让动作，所以导致目前处理机无法直接使用。)2. 双标志先检查法算法思想：设置一个布尔型数组 flag[ ]，数组中各个元素用来标记各进程想进入临界区的意愿。比如“flag[0] = ture” 意味着 0 号进程 P_0 现在想要进入临界区。每个进程在进入临界区之前先检查当前有没有别的进程想进入临界区，如果没有，则把自身对应的标志 flag[i] 设为 true，之后开始访问临界区。bool flag [2]; // 表达进入临界区意愿的数组

flag[0] = false; // 初始化：两者都不想进入临界区

flag[1] = false;

// P_0 进程

while (flag [1]); // 1 如果此时P_1 想进入临界区，P0 就需要循环等待

flag[0] = true; // 2 标记为P0 进程想要进入临界区

critical section; // 3 访问临界区

flag[0] = false; // 4 访问完临界区，修改标记为 P0 不想使用临界区

remainder section;

// P_1 进程

while (flag [0]); // 5

flag[1] = true; // 6

critical section; // 7

flag[1] = false; // 8

remainder section;问题：若两个程序并发执行，即按照 1、5、2、6、3、7...... 的顺序执行， $P_0$ 和 $P_1$ 将会同时访问临界区。flag[i] 背后的逻辑含义： “表达意愿”因此，双标志先检查法的主要问题是：违反“忙则等待”原则。原因在于，进入区的“检查”和“上锁” 两个处理不是一气呵成的。“检查”后，“上锁”前可能发生进程切换。3. 双标志后检查算法思想：双标志先检查法的改版。前一个算法的问题是先“检查”后“上锁”，但是这两个操作又无法一气呵成，因此导致了两个进程同时进入临界区的问题。因此，人们又想到先“上锁”后“检查”的方法，来避免上述问题。bool flag [2]; // 表达进入临界区意愿的数组

flag[0] = false;

flag[1] = false; // 刚开始的时候设置为两个进程都不想进去临界区

// P0 进程

flag[0] = true; // 1 标记为 P0 进程想要进入临界区

while (flag [1]); // 2 如果此时 P1 想进入临界区，P0 就需要循环等待

critical section; // 3 访问临界区

flag[0] = false; // 4 访问完临界区，修改标记为 P0 不想使用临界区

remainder section;

// P1 进程

flag[1] = true; // 5

while (flag [0]); // 6

critical section; // 7

flag[1] = false; // 8

remainder section;若按照 1、5、2、6….的顺序执行， P_0 和 P_1 将都无法进入临界区，2、6陷入两个死循环。flag[i] 背后的逻辑含义： “表达意愿”因此，双标志后检查法虽然解决了“忙则等待”的问题，但是又违背了“空闲让进”和“有限等待”原则，会因各进程都长期无法访问临界资源而产生“饥饿”现象。两个进程都争着想进入临界区，但是谁也不让谁，最后谁都无法进入临界区。4. Peterson算法算法思想：结合双标志法、单标志法的思想。如果双方都争着想进入临界区，那可以让进程尝试“孔融让梨”（谦让）。做一个有礼貌的进程。bool flag [2]; // 表达进入临界区意愿的数组，初始值都是 false

// 背后的含义：“表达意愿”

int turn; // turn 表示有限让哪个进程进入临界区

// 背后的含义：“谦让”

// P0 进程

flag[0] = true; // 1 表达 P0 进程有有意愿进入临界区

turn = 1; // 2 优先让 P1 进程使用临界区

while (flag [1] && turn == 1); // 3 如果对方有意愿并且

// 最后一次是自己谦让，则需要继续等待

critical section; // 4

flag[0] = false; // 5 访问完表示自己不想再访问了

remainder section;

// P1 进程

flag[1] = true; // 6

turn = 0; // 7

while (flag [0] && turn == 0); // 8

critical section; // 9

flag[1] = false; // 10

remainder section;算法的进入区完成以下几件事: 1. 主动争取（把flag 置成true）； 2. 主动谦让（把turn 设置成对方）； 3. 检查对方是否也想使用临界资源，且最后一次是不是自己说了“客气话”。 Peterson 算法用软件方法解决了进程互斥问题，遵循了空闲让进、忙则等待、有限等待三个原则，但是依然未遵循让权等待的原则。 Peterson 算法相较于之前三种软件解决方案来说，是最好的，但依然不够好。[22] 进程互斥的硬件实现方法1. 中断屏蔽方法利用“开/关中断指令”实现（与原语的实现思想相同，即在某进程开始访问临界区到结束访问为止都不允许被中断，也就不能发生进程切换，因此也不可能发生两个同时访问临界区的情况）。关中断

-----临界区访问-----

开中断优点：简单、高效缺点：不适用于多处理机；只适用于操作系统内核进程，不适用于用户进程（因为开/关中断指令只能运行在内核态，这组指令如果能让用户随意使用会很危险）。2. TestAndSet （TS指令 / TSL指令）TestAndSet 简称 TS 指令，也有地方称为 TestAndSetLock 指令，或 TSL 指令， TSL 指令是用硬件实现的，执行的过程不允许被中断，只能一气呵成。以下是用C语言描述的逻辑：// 布尔型共享变量 lock 表示当前临界区是否被加锁

// true 表示已经枷锁， false 表示未加锁

bool TestAndSet(bool *lock)

{

bool old;

old = *lock; // 用于存放lock 原来的值

*lock = true; // 无论之前是否已经加锁，都将lock值设为true

return old; // 返回lock原来的值

}以下是使用TSL指令，实现互斥的算法逻辑：while (TestAndSet(&lock)); // “上锁”并“检查”

临界区代码段...

lock = false; // “解锁”

剩余区代码段...代码说明：若刚开始 lock 是 false，则 TSL 返回的 old 值为 false，while 循环条件不满足，直接跳过循环，进入临界区。若刚开始 lock 是 true，则执行 TLS 后 old 返回的值为 true，while 循环条件满足，会一直循环，直到当前访问临界区的进程在退出区进行“解锁”。相比软件实现方法，TSL 指令把“上锁”和“检查”操作用硬件的方式变成了一气呵成的原子操作。 - 优点：实现简单，无需像软件实现方法那样严格检查是否会有逻辑漏洞；适用于多处理机环境 - 缺点：不满足“让权等待”原则，暂时无法进入临界区的进程会占用CPU并循环执行 TSL 指令，从而导致“忙等”。3. Swap指令（XCHG指令）有的地方也叫 Exchange 指令，或简称 XCHG 指令。 Swap 指令是用硬件实现的，执行的过程不允许被中断，只能一气呵成。以下是用C语言描述的逻辑:// swap指令的作用是交换两个变量的值

void Swap (bool *a, bool *b)

{

bool temp;

temp = *a;

*a = *b;

*b = temp;

}以下是使用Swap指令实现互斥的算法逻辑， lock表示当前临界区是否被加锁bool old = true;

while (old == true)

{

Swap (&lock, &old);

}

临界区代码段...

lock = false;

剩余区代码段...逻辑上来看 Swap 和 TSL 并无太大区别，都是先记录下此时临界区是否已经被上锁（记录在 old 变量上），再将上锁标记 lock 设置为 true，最后检查 old. 如果 old 为 false 则说明之前没有别的进程对临界区上锁，则可跳出循环，进入临界区。 - 优点：实现简单，无需像软件实现方法那样严格检查是否会有逻辑漏洞；适用于多处理机环境 - 缺点：不满足“让权等待”原则，暂时无法进入临界区的进程会占用CPU并循环执行TSL指令，从而导致“忙等”。 [23] 信号量机制0. 前期总结进程互斥的四种软件实现方式（单标志法、双标志先检查、双标志后检查、Peterson算法）进程互斥的三种硬件实现方式（中断屏蔽方法、TS/TSL指令、Swap/XCHG指令） 1. 在双标志先检查法中，进入区的“检查”、“上锁” 操作无法一气呵成，从而导致了两个进程有可能同时进入临界区的问题； 2. 所有的解决方案都无法实现“让权等待”。1. 信号量机制1965年，荷兰学者Dijkstra提出了一种卓有成效的实现进程互斥、同步的方法 —— 信号量机制。用户进程可以通过使用操作系统提供的一对原语来对信号量（Semaphore）进行操作，从而很方便的实现了进程互斥、进程同步。信号量其实就是一个变量，可以用一个信号量（可以是一个整数，也可以是更复杂的记录型变量）来表示系统中某种资源的数量，比如：系统中只有一台打印机，就可以设置一个初值为 1 的信号量。原语是一种特殊的程序段，其执行只能一气呵成，不可被中断。原语是由关中断/开中断指令实现的。软件解决方案的主要问题是由“进入区的各种操作无法一气呵成”，因此如果能把进入区、退出区的操作都用“原语”实现，使这些操作能“一气呵成”就能避免问题。一对原语：wait(S) 原语和 signal(S) 原语，可以把原语理解为我们自己写的函数，函数名分别为 wait 和 signal，括号里的信号量 S 其实就是函数调用时传入的一个参数。wait、signal 原语常简称为 P、V操作（来自荷兰语 proberen 和 verhogen）。因此常把wait(S)、signal(S) 两个操作分别写为 P(S)、V(S)。2. 整型信号量用一个整数型的变量作为信号量，用来表示系统中某种资源的数量。与普通整数变量的区别：对信号量的操作只有三种，即初始化、P操作、V操作。int S = 1; // 初始型整型信号量s，表示当前系统中可用的打印机资源数

void wait (int S) // wait 原语，相当于“进入区”

{

while (S <= 0); // 循环检查，是否当前资源已经不够了

S--; // 如果资源数够，则占用一个资源

}

void signal (int S) // signal 原语，相当于“退出区”

{

S++; // 使用完资源后，在退出区释放资源

}进程 P_0 ：// ...

wait (S); // 进入区，申请资源

// 使用打印机资源... // 临界区，访问资源

signal(S); // 退出区，释放资源

// ...进程 P_1 ：// ...

wait (S); // 进入区，申请资源

// 使用打印机资源... // 临界区，访问资源

signal(S); // 退出区，释放资源

// ...... 进程 P_n ：// ...

wait (S); // 进入区，申请资源

// 使用打印机资源... // 临界区，访问资源

signal(S); // 退出区，释放资源

// ...在任何一个进程开始执行的时候，进入程序内部执行检查操作，检查信号量资源是否被完全占据，如果被占据，就一直忙等待，等有空闲信号量资源的时候，再占据这个信号量。“检查”和“上锁”一气呵成，避免了并发、异步导致的问题。存在的问题：不满足“让权等待”原则，会发生“忙等”（忙等，busy wait，当一个进程正处在某临界区内，任何试图进入其临界区的进程都必须进入代码连续循环，陷入忙等状态，连续测试一个变量直到某个值出现为止）。3. 记录性信号量整型信号量的缺陷是存在“忙等”问题，因此人们又提出了“记录型信号量”，即用记录型数据结构表示的信号量。/* 记录型信号量的定义 */

typedef struct {

int value; // 剩余资源数

struct process *L; // 等待队列

} Semaphore;

/* 某进程需要使用资源时，通过wait原语申请 */

void wait(Semaphore S)

{

S.value--;

if (S.value < 0) {

block (S.L);

}

}如果剩余资源数不够，使用block原语使进程从运行态进入阻塞态，并把挂到信号量 S 的等待队列（即阻塞队列）中。/*进程使用完资源后，通过signal 原语释放*/

void signal (Semaphore S)

{

s.value++;

if (S.value <= 0) {

wakeup(S.L);

}

}释放资源后，若还有别的进程在等待这种资源，则使用wakeup原语唤醒等待队列中的一个进程，该进程从阻塞态变为就绪态。注意理解信号量背后的含义，一个信号量对应一种资源。信号量的值 = 这种资源的剩余数量（信号量的值如果小于0，说明此时有进程在等待这种资源） P( S ) —— 申请一个资源S，如果资源不够就阻塞等待； V( S ) —— 释放一个资源S，如果有进程在等待该资源，则唤醒一个进程。对信号量 S 的一次 P 操作意味着进程请求一个单位的该类资源，因此需要执行 S.value--，表示资源数减1，当S.value < 0 时表示该类资源已分配完毕，因此进程应调用 block 原语进行自我阻塞（当前运行的进程从运行态 -> 阻塞态），主动放弃处理机，并插入该类资源的等待队列 S.L 中。可见，该机制遵循了“让权等待”原则，不会出现“忙等”现象。对信号量 S 的一次 V操作意味着进程释放一个单位的该类资源，因此需要执行S.value++，表示资源数加1，若加1后仍是 S.value <= 0，表示依然有进程在等待该类资源，因此应调用wakeup 原语唤醒等待队列中的第一个进程（被唤醒进程从阻塞态 -> 就绪态）。[24] 用信号量实现进程互斥、同步、前驱关系1. 信号量机制实现进程互斥实现方法分析并发进程的关键活动，划定临界区（如：对临界资源打印机的访问就应放在临界区）设置互斥信号量 mutex，初值为 1在进入区 P(mutex) —— 申请资源在退出区 V(mutex) —— 释放资源信号量 mutex 表示“进入临界区的名额”。/*记录型信号量的定义*/

typedef struct {

int value; // 剩余资源数

struct process *L; // 等待队列

} Semaphore;

/* 信号量机制实现互斥 */

Semaphore mutex = 1;

P1()

{

// ...

P(mutex); // 使用临界区前加锁

// 临界区代码段

V(mutex); // 使用临界区后解锁

// ...

}

P2()

{

// ...

P(mutex);

// 临界区代码段

V(mutex);

// ...

}★注意：对不同的临界资源需要设置不同的互斥信号量。 P、V操作必须成对出现。缺少P(mutex) 就不能保证临界资源的互斥访问。缺少 V(mutex) 会导致资源永不被释放，等待进程永不被唤醒。2. 信号量机制实现进程同步进程同步：要让各并发进程按要求有序地推进。P1()

{

代码 1;

代码 2;

代码 3;

}

P2()

{

代码 4;

代码 5;

代码 6;

}比如: P_1、P_2 并发执行，由于存在异步性，因此二者交替推进的次序是不确定的。若 P_2 的“代码4”要基于 P_1 的“代码1”和“代码2”的运行结果才能执行，那么我们就必须保证“代码4”一定是在“代码2”之后才会执行。这就是进程同步问题，让本来异步并发的进程互相配合，有序推进。用信号量实现进程同步：分析什么地方需要实现“同步关系”，即必须保证“一前一后”执行的两个操作（或两句代码）；设置同步信号量 S, 初始为 0；在“前操作”之后执行 V(S)；在“后操作”之前执行 P(S)；/* 信号量机制实现同步 */

Semaphore S = 0;

P1()

{

代码 1;

代码 2;

V(S);

代码 3;

}

P2() // P2 的执行需要依赖一种信号量资源S，而这种资源只能由P1 释放，因此保证必须 P1 后再 P2

{

P(S);

代码 4;

代码 5;

代码 6;

}若先执行到 V(S) 操作，则 S++ 后 S = 1。之后当执行到 P(S) 操作时，由于 S = 1，表示有可用资源，会执行 S--，S 的值变回 0，P2 进程不会执行 block 原语，而是继续往下执行代码4。执行顺序 1、2、4、5、6。保证代码4在代码2之后执行若先执行到 P(S) 操作，由于 S = 0，S-- 后 S = -1，表示此时没有可用资源，因此P操作中会执行 block 原语，主动请求阻塞。之后当处理机交还处理进程P1，执行完代码2，继而执行 V(S) 操作，S++，使 S 变回 0，由于此时有进程在该信号量对应的阻塞队列中，因此会在 V 操作中执行 wakeup 原语，唤醒 P2 进程。这样 P2 就可以继续执行代码4 了。前V后P信号量S代表“某种资源”，刚开始是没有这种资源的。P2需要使用这种资源，而又只能由P1产生这种资源。3. 信号量机制实现前驱关系有如下几个进程，必须满足如图的程序执行顺序：其中进程 P1 中有句代码 S1，P2 中有句代码 S2 ，P3中有句代码S3 …… P6 中有句代码 S6。这些代码要求按如下前驱图所示的顺序来执行：其实每一对前驱关系都是一个进程同步问题（需要保证一前一后的操作）因此： 1. 要为每一对前驱关系各设置一个同步信号量； 2. 在“前操作”之后对相应的同步信号量执行 V 操作； 3. 在“后操作”之前对相应的同步信号量执行 P 操作；代码实现：// 为每一个前驱关系各设置一个同步信号量，途中一共是7对前驱关系

// 分配7个相应的同步信号量：a、b、c、d、e、f、g

// P1 会导致P2 和 P3程序，所以需要先使用 V操作释放a、b

P1()

{

...

S1;

V(a);

V(b);

...

}

// 由于P1 对a的释放，才可以使得P2 执行，因此在这里执行 P操作，占用a

P2()

{

...

P(a);

S2;

V(c); // 释放c、d资源

V(d);

...

}

P3()

{

...

P(b); // 占用b 资源

S3;

V(g); // 释放g 资源

...

}

P4()

{

...

P(c); // 占用c 资源

S4;

V(e); // 释放e 资源

...

}

P5()

{

...

P(d); // 占用d 资源

S5;

V(f); // 释放f 资源

...

}

P6()

{

...

P(e); // 占用e 资源

P(f); // 占用f 资源

P(g); // 占用g 资源

S6;

...

}编辑于 2023-11-19 23:39・IP 属地江苏操作系统国产操作系统操作系统原理赞同 55 条评论分享喜欢收藏申请

操作系统原理教程：进程同步与互斥_4在一个系统中有两个过程,p1和p2。它们都需要三种资源,如r1、r2和r3。如果p1-CSDN博客

操作系统原理教程：进程同步与互斥

最新推荐文章于 2023-11-27 21:42:06 发布

王山山

最新推荐文章于 2023-11-27 21:42:06 发布

阅读量2.4k

点赞数

分类专栏：

Interview

文章标签：

操作系统原理教程

进程同步与互斥

临界区

本文链接：https://blog.csdn.net/Watkins_OS/article/details/101001025

版权

Interview

专栏收录该内容

67 篇文章

1 订阅

订阅专栏

在一个进程使用这些变量尚未结束期间，另一个进程也开始使用，这种错误通常称为“与时间有关的错误”。导致出错的原因有两个：共享了变量、同时使用了这些共享变量。较好的解决办法是允许共享，但不允许同时使用。

互斥与同步的概念

在多道程序环境下，系统中可能有许多并发的进程，在这些进程之间存在以下两种关系：间接相互制约关系、直接相互制约关系。

间接相互制约关系

多个进程彼此无关，它们并不知道其他进程的存在。由于各进程要求共享资源，而有些资源需要互斥使用，因此各个进程间竞争使用这些资源，进程间的这种关系称为进程的互斥(Mutual Exclusion)。进程的互斥会产生两个额外的控制问题：

死锁。考虑两个进程P1和P2，以及两个资源R1和R2。假设每个进程都需要访问这两个资源，那么就有可能出现这样的情况：操作系统把R1分配给P2，把R2分配给P1，每个进程都在等待对方占有自己需要的另一个资源，并且各自在获得对方的资源以完成需要的功能之前，谁都不会释放自己已经拥有的资源。结果，这两个进程就发生了“死锁”。饥饿。假设有三个进程P1、P2和P3，每个进程都周期性地访问互斥资源R。考虑这种情况：P1首先拥有资源R，P2和P3都在等待这个资源。当P1访问完毕，操作系统把访问权授予P3，并且在P3完成访问之前，P1又需要访问资源R，如果在P3结束后操作系统又把访问权授予P1，如此轮流将访问权授予P1和P3，将导致P2无限期地等待。把此时P2的状态称为“饥饿”。

直接相互制约关系

多个进程间知道对方的存在，表现出来的是一种相互合作的关系。此时要保证相互合作的各个进程在执行次序上的协调，不会出现与时间有关的差错。系统中多个进程中发生的事件存在某种时序关系，需要相互合作，共同完成一项任务，进程间的这种关系称为进程的同步(Synchronism)。进程的同步同样存在“死锁”和“饥饿”的问题。例如，有两个阻塞的进程，相互都在等待来自对方的通信，就会发生“死锁”。考虑三个进程P1、P2和P3，它们都有如下特性：P1不断地试图与P2或P3通信，P2和P3都试图与P1通信。如果P1和P2不断地交换信息，而P3一直被阻塞，等待与P1通信，那么由于P1一直是活跃的，因此虽不存在“死锁”，但P3处于“饥饿”状态。

从某种意义上讲，互斥也是一种同步，因为它也是进程之间如何使用共享资源的一种协调。

临界资源与临界区

系统中某些资源一次只允许一个进程使用，这样的资源称为临界资源(Critical Resource)，多个进程必须互斥地对它进行访问。在每个进程中访问临界资源的那段代码称为临界区(Critical Section)。

几个进程共享同一临界资源，它们必须以互斥的方式使用临界资源，即当一个进程正在使用临界资源且尚未使用完毕时，其他进程必须延迟对该资源的进一步操作，在当前的进程使用完毕之前，不能从中插入使用这个临界资源，否则将会造成信息混乱的操作错误。因此，必须在临界区前面增加一段用于进行检测的代码，把这段代码称为进入区(Entry Section)。相应地，在临界区后面也要加上一段称为退出区(Exit Section)的代码，用于将临界区正被访问的标志恢复为未被访问标志。进程中的除上述进入区、临界区及退出区之外的其他部分代码，称为剩余区(Remainder Section)。

# 进程访问临界区的一般结构

while(true)

{

进入区

临界区

退出区

剩余区

}

为实现进程互斥，可在系统中设置专门的同步机制来协调各个进程间的运行。

空闲让进。当无进程处于临界区时，相应的临界资源处于空闲状态，因而可允许一个请求进入临界区的进程立即进入自己的临界区，以有效地利用临界资源。忙则等待。当已有进程进入临界区时，意味着相应的临界资源正被访问，因而所有其他试图进入临界资源的进程必须等待，以保证各个进程互斥地访问临界资源。有限等待。对要求访问临界资源的进程，应保证该进程在有效的时间内进入临界区，以免陷入“死等”状态。这一“死等”的现象或称为“饥饿”(若一个进程无限地等待)，或称为“死锁”(若两个以上进程相互无限地等待)。让权等待。当进程不能进入临界区，则立即释放处理机，避免进程出现“忙等”现象。

互斥实现的硬件方法

为了解决进程互斥进入临界区的问题，需要采取有效措施。利用硬件实现互斥的方法有禁止中断和专用机器指令两种方法。

禁止中断

在单处理机环境中，并发执行的进程不能在CPU上同时执行。另外，对一个进程而言，它将一直运行，直至被中断。因此，为了保证互斥，只要保证一个进程不被中断就可以了，这可以通过系统内核开启、禁止中断来实现。

while(true)

{

禁止中断;

临界区;

启用中断;

其余部分;

}

由于在临界区内进程不能被中断，故保证了互斥。但该方法的代价很高，进程被限制只能接替执行。另外，在多处理机环境中，禁止中断仅对执行本指令的CPU起作用，对其他CPU不起作用，也就不能保证对临界区的互斥进入。

专用机器指令

在很多计算机(特别是多处理机)中设有专用指令来解决互斥问题。依据所采用指令的不同，硬件方法分为TS指令和Swap指令两种。

TS指令

TS(Test and Set)指令的管理思想与日常生活中互斥进入房间某种管理机制类似，为了保证一个房间只让一个人进入使用，开始房间是开着的，且锁头和钥匙都挂在房门上，先到者看到房门开着，于是取下锁头和钥匙，进入房间后反锁，这样后到者看到房门反锁，见不到锁头和钥匙，只能在门外等候，一直等到房间内的那个人开锁出来并把锁和钥匙挂在房门原处，这时门外等待队列中的第一个人以同样的操作方法进入房间，如此往复…这样保证了多个人互斥使用同一房间。

int ts(static int lock)

{

int ts = lock; // 将锁原来的状态赋予函数名ts

lock = 1; // 把锁锁上

return(ts); // 返回锁原来的状态

}

while(true)

{

...

while(ts(lock)) // 测试锁是否已锁上？如果已锁上，继续循环测试等待

No-op;

; // 如果未锁上，进入临界区

lock = 0; // 完成执行临界区，退出来后开锁

...

}

这里，ts函数作为一个原语执行(即执行时不存在中断)；lock有两种状态，当lock=0时(未锁上)，表示该资源空闲；当lock=1时(已锁上)，表示该资源正在被使用。

Swap指令

Swap指令的管理思想与日常生活中互斥进入房间的某种管理机制类似，首先一把锁头配n把钥匙，每一人一把钥匙，房门外有一个守门的老头，又聋又哑，只能完成交换手中一样物品(锁头或钥匙)的工作，开始守门老头手上只有一把锁头，想进入房间者先用自己的钥匙与守门老头交换，如果换出的是锁头，则请求进入者就可以拿着锁头进入房间然后反锁，保证自己一个人在房间内，这样后来者想进入房间也要用自己的钥匙跟守门老头手中的物品交换，但此时换出来的只能是钥匙，拿不到锁头就只能在门外等候，直到房间内的那个人出来，用锁头跟老头交换回钥匙为止，后来者才能换到锁头，进入房间…

void swap(static int a, b)

{

int temp;

temp = a;

a = b;

b = temp;

}

while(true)

{

...

keyi = 1

{

swap(lock, keyi);

}

while(keyi); // 循环交换锁和钥匙，直到keyi=0

; // 如果拿到锁头，即keyi=0，进入临界区

swap(lock, keyi); // 完成执行临界区，交回锁头换回钥匙

...

}

在利用Swap实现进程互斥时，可为临界资源设置一个全局变量lock，其初值为0，在每个进程中再利用一个局部变量key。然后通过Swap指令实现互斥。在进入区利用Swap指令交换lock与key的内容，然后检查key的状态；有进程在临界区时，循环交换和检查过程，直到其他进程退出时检查通过，进入临界区。

硬件方法由于采用硬件处理器指令能很好地把修改和检查操作结合在一起而具有明显的优点：适用范围广、简单、支持多个临界区。但是硬件方法也有无法克服的缺点：不能做到“让权等待”、有可能产生“饥饿”、有可能产生“死锁”。

互斥实现的软件方法

基本思路是在进入区检查和设置一些标志，如果已有进程在临界区，则在进入区通过循环检查进行等待，在退出区修改标志。

算法1：单标志算法

# 单标志算法

P0: P1

while(true) while(true)

{ {

... ...

while(turn != 0) while(turn != 1)

No-op; No-op;

critical section; critical section;

turn = 1; turn = 1;

... ...

} }

对单标志算法的评价：

该算法可确保每次只允许一个进程进入临界区 2个进程轮流进入临界区不能保证实现“空闲让进”的准则。如当进程P1暂时并未要求访问该临界资源，而P0又想再次访问该资源，但它却无法进入临界区。

算法2：双标志、先检查算法

基本思想：在每一个进程访问临界资源之前，先查看一下临界资源是否正被访问。若正被访问，该进程需等待；否则进入自己的临界区。为此，设置一个标志数组flag[2]，使其中每个元素的初值为false，表示所有进程都未进入临界区。如flag[0]=true时，表示进程P0正在临界区内执行；若flag[1]=true时，表示进程P1正在临界区内执行。

# 双标志、先检查算法

P0: P1

while(true) while(true)

{ {

... ...

while(flag[1]) while(flag[0])

No-op; No-op;

flag[0] = true; flag[1] = true;

critical section; critical section;

flag[0] = false; flag[1] = false;

... ...

} }

对双标志、先检查算法的评价：

该算法解决了“空闲让进”的问题违背了“忙则等待”的准则。即当P0和P1都未进入临界区

算法3：双标志、先修改后检查算法

算法2的问题是，当进程P0观察到进程P1的标志为false便将自己的标志flag改为true，这需要极短的一段时间，而正是在此期间，进程P1观察进程P0的标志为false，而进入临界区，因而造成了两个进程同时进入的问题。解决该问题的方法是先修改后检查，这时标志flag的含义是进程想进入临界区。

# 双标志、先修改后检查算法

P0: P1

while(true) while(true)

{ {

... ...

flag[0] = true; flag[1] = true;

while(flag[1]) while(flag[0])

No-op; No-op;

critical section; critical section;

flag[0] = false; flag[1] = false;

... ...

} }

对双标志、先修改后检查算法的评价：

造成最终谁都不能进入临界区的后果。因而它既违背了“空闲让进”的准则，又违背了“有限等待”的准则。例如，当P1和P2几乎在同时要进入临界区，双方都在“谦让”，结果谁也进不了临界区。

算法4：先修改、后检查、后修改者等待算法

结合算法1和算法3的概念，标志数组flag[0]为true标志进程P0想进入临界区，标志turn表示要在进入区等待的进程标识。在进入区先修改、后检查，通过修改同一标志turn来描述标志修改的先后；检查对方标志flag，如果对方不想进入，自己再进入。如果对方想进入，则检查标志turn，由于turn中保存的是较晚的一次赋值，因此较晚修改标志的进程等待，较早修改标志的进程进入临界区。

# 先修改、后检查、后修改者等待算法

P0: P1

while(true) while(true)

{ {

... ...

flag[0] = true; flag[1] = true;

turn = 1; turn = 0;

while(flag[1] && turn==1) while(flag[0] && turn==0)

No-op; No-op;

critical section; critical section;

flag[0] = false; flag[1] = false;

... ...

} }

算法4可以正常工作，即实现了同步机制中前两条：“空闲让进”和“忙则等待”。

但从以上软件方法中可以发现，对于三个以上进程的互斥又要区别对待。因此用软件方法解决进程互斥的问题有一定的难度，且有很大的局限性。

总之，无论是硬件方法实现互斥，还是软件方法实现互斥，它们都是基于繁忙等待的策略。从本质上来说，它们都可以被归纳为同一种形式，即当一个进程想要进入它的临界区时，首先检查一下是否允许进入，如果允许，就直接进入；如果不允许，就在那里循环地等待。这种基于繁忙等待的策略，虽然能够满足我们的需要，实现进程之间的互斥访问，但它们有两个缺点：

浪费CPU时间。因为当一个进程暂时无法进入临界区的时候，是在那里不断地循环等待，此时CPU一直处于运行状态，但又没做什么有价值的事情。可能会导致系统“死锁”。例如，假设系统采用优先级调度算法，有一个低优先级的进程正在临界区中，此时，有一个高优先级的进程也就绪了，并试图进入临界区。解决方法就是：当一个进程无法进入临界区时，应该把它阻塞起来，从而把CPU让出来，而当一个进程离开临界区时，如果此时有其他的进程正在等待进入临界区，那么还需要去唤醒被阻塞的进程。

另外，还有一个新的问题：两个或多个进程都想进入各自的临界区，但是在任何时刻，只能允许N个进程同时进入临界区，这个N大于1。

（最近更新：2019年09月18日）

优惠劵

王山山

关注

踩

觉得还不错?

一键收藏

知道了

操作系统原理教程：进程同步与互斥

在一个进程使用这些变量尚未结束期间，另一个进程也开始使用，这种错误通常称为“与时间有关的错误”。导致出错的原因有两个：共享了变量、同时使用了这些共享变量。较好的解决办法是允许共享，但不允许同时使用。互斥与同步的概念在多道程序环境下，系统中可能有许多并发的进程，在这些进程之间存在以下两种关系：间接相互制约关系、直接相互制约关系。间接相互制约关系多个进程彼此无关，它们并不知道其他进程的存在。由...

复制链接

扫一扫

专栏目录

操作系统大作业一同步与互斥算法

01-24

一个理发店，由一间等候室W和一间工作室B组成，理发店环境和运作示意图如下图所示。顾客可以从外面大街上进入W，等候理发。两个房间的入口是并排的且共享一扇日本式可滑动的推拉门（门总是挡住一个入口）。顾客在工作室内理完发，可由B的旁门出去。（图中箭头是顾客运动方向）。W中有N把椅子，顾客必须坐着等候。理发师可由门上小窗查看W中无人就睡觉，否则开门，并叫一位顾客入内理发。顾客每进入一位，都拉铃通知理发师。

1）试问：若把顾客和理发师都视为进程，须写几个控制程序？各程序与进程的对应关系如何？

2）请用P、V操作写出这些进程的同步控制算法。

操作系统实训报告进程同步和互斥

12-24

操作系统实训报告进程同步和互斥通过实现哲学家进餐问题的同步深入了解和掌握进程同步和互斥的原理。哲学家有N个，也定全体到达后开始讨论：在讨论的间隙哲学家进餐，每人进餐时都需使用刀、叉各一把，所有哲学家刀和叉都拿到后才能进餐。哲学家的人数、餐桌上的布置自行设定，实现刀和叉的互斥使用算法的程序实现。

参与评论

您还未登录，请先

后发表或查看评论

操作形同实验——进程同步和互斥

06-01

操作形同实验——进程同步和互斥

（1）通过编写程序实现进程同步和互斥，掌握有关进程（线程）同步与互斥的原理，以及解决进程（线程）同步和互斥的算法，从而进一步巩固进程（线程）同步和互斥等有关的内容。

（2）了解Windows2000/XP中多线程的并发执行机制，线程间的同步和互斥。

（3）学习使用Windows2000/XP中基本的同步对象，掌握相应的API函数。

操作系统原理进程管理进程同步互斥与通信、死锁.pptx

11-03

操作系统原理进程管理进程同步互斥与通信、死锁.pptx

操作系统进程同步和互斥的实验报告

12-17

操作系统进程同步和互斥的实验报告。。。关于操作系统进程的同步与互斥问题的实验报告。

浅谈两种方法实现进程互斥的原理

那些年

12-25

3629

浅谈两种方法实现进程互斥的原理

对临界资源的使用通过量种方法实现：

管程机制和信号量机制（记录性信号量和AND信号量）；

记录性信号量机制：

在记录性信号机制里面有Ｓ.value : 记录的是资源的信号的量，通过去验证每次这个值是否大于0 ，来判断是否让进程来使用此资源，但是，一旦这个值s.v

软考笔记——2.1进程管理、同步互斥、死锁、线程

weixin_47940048的博客

07-08

741

操作系统的作用：通过资源管理提高计算机系统的效率；改善人机界面向用户提供友好的工作环境操作系统的特征：并发性、共享性、虚拟性、不确定性操作系统的功能：进程管理、存储管理、文件管理、设备管理、作业管理操作系统的分类：批处理操作系统、分时操作系统（轮流使用CPU工作片）、实时操作系统（快速响应）、网络操作系统、分布式操作系统（物理分散的计算机互联系统）、微机操作系统（Windows）、嵌入式操作系统计算机启动的基本流程为：BIOS -> 主引导记录 ->操作系统 1、进程的组成和状态进程的组成：进程控制块PCB

【进程间通信】——认识同步与互斥，了解生产者消费者原理。

daboluo521的博客

04-23

3556

临界资源

在操作系统中，进程是占有资源的最小单位（线程可以访问其所在进程内的所有资源，但线程本身并不占有资源或仅仅占有一点必须资源）。但对于某些资源来说，其在同一时间只能被一个进程所占用。这些一次只能被一个进程所占用的资源就是所谓的临界资源。典型的临界资源比如物理上的打印机，或是存在硬盘或内存中被多个进程所共享的一些变量和数据等(如果这类资源不被看成临界资源加以保护，那么很有可能造成丢数据的问题...

系统架构设计笔记（2）—— 操作系统进程管理

读万卷书，行万里路

03-08

791

操作系统基本原理包含以下 5 大管理。

我们先来说说进程管理。

因为处理机是计算机系统的核心资源，所以整个操作系统的重心是处理机管理。

处理机管理中最基本的、最重要的概念是进程。进程是系统并发执行的体现。

不同观点

操作系统

静态

是一组程序和表格集合的操作系统。

动态

是进程动态和并发执行的操作系统。

不同观点

进程

静态

进程是由程序、数据和进程控...

《操作系统》速成

aiqq136的博客

03-29

9683

《操作系统》速成

操作系统课件进程与处理机原理同步互斥

10-23

进程与处理机原理同步互斥，操作系统刘腾红版

操作系统复习资料

qq_45854377的博客

01-21

4697

题型分布与分值

1.选择题 25*1=25分

2.判断题 5*1=5分

3.简答题 5*5=25分

4.分析题 45分

英译中

分析题：

调度算法：先来先服务FCFS、短作业优先SJF、优先级调度算法PSA、时间片轮转调度RR、高响应比HRRN，平均周转时间，平均带权周转时间等

周转时间=完成时间-到达时间

带权周转时间=周转时间÷运行时间

例1 假定在单CPU条件下,有A,B,C,D四个作业依次到达(后面的作业依次比前一作业迟到一个时间单位)。四个作业分别需要运行1...

操作系统选择题期末试题考研真题 + 参考答案

最新发布

Skyeeee_W的博客

11-27

3753

操作系统期末试题考研真题选择题

操作系统基本原理---进程管理

hu19930613的博客

08-02

6957

处理机：计算机系统中存储程序和数据，并按照程序规定的步骤执行指令的部件。程序是描述处理机完成某项任务的指令序列。指令则是处理机能直接解释、执行的信息单位。处理机包括中央处理器，主存储器,输入-输出接口。

处理器cpu：中央处理器（Central Processing Unit）的缩写，即CPU，CPU是电脑中的核心配件，只有火柴盒那么大，几十张纸那么厚，但它却是一台计算机的运算核心和控制核心。...

操作系统 —— 处理机调度与死锁

qq_63976098的博客

10-18

1440

操作系统课后习题精析版

操作系统练习题（2）第三章存储器管理

VAN

06-17

2737

第三章处理机调度与死锁

本章学习要点

【1】掌握调度的类型与方式

【2】掌握常用的进程调度算法

【3】掌握死锁的相关知识

【4】深入领会银行家算法

本章学习重点和难点

【1】进程调度算法

【2】银行家算法

习题分析

一.判断改错题（判断由下划线标明的关键词的叙述是否正确，正确的打√，错误的打×并改正。）

1.产生死锁的原因之一是对计算机操作不当，造成计算机死机。（）

2.死锁产生，必须要满足四个必要条件，所以，为避免死锁产生，主要注意如何不让这四个必要条件成立，并打破循环等待资源的环路。（

操作系统习题（有一个具有两道作业的批处理系统）

热门推荐

scarificed的博客

03-25

3万+

题目描述：

有一个具有两道作业的批处理系统，作业调度采用短作业优先的调度算法，进程调度采用以优先数为基础的抢占式调度算法，在下表所示的作业序列，作业优先数即为进程优先数，优先数越小优先级越高。（1）列出所有作业进入内存时间及结束时间。（2）计算平均周转时间。

解析：

首先我们来分析题意，第一句话很重要，一个具有两道作业的批处理系统，这句话是什么意思呢？在引入了多道程序设计计数后，内存可以同时存放多个用户作业，并使它们交替运行，轮流使用cpu和I/O设备，使系统资源利用率提高。题目告诉我们是两道作业的批处

操作系统原理 —— 什么是进程互斥？以及进程互斥的实现方式（十四）

贱男

05-15

1400

在操作系统中，有两种资源共享方式，一种是互斥共享方式，一种是同时共享方式。互斥共享方式就是指在系统中的某些资源，虽然可以提供给多个进程使用，但一个时间段内只允许一个进程访问该资源。这里就会有一个互斥的概念，一个时间段只允许一个进程访问，这就是进程互斥，还有一个概念就是，我们把一个时间段内只允许一个进程使用的资源称之为临界资源，比如说摄像头、打印机都属于临界资源。对于临界资源的访问，必须互斥的进行。指当一个进程访问某些临界资源时，另一个想要访问该临界资源的进程必须等待。

进程同步 | 进程互斥 | 实现方法

weixin_55026246的博客

03-28

493

2.10 进程同步和进程互斥

进程同步

eg：

并发性带来了异步性，有时需要通过进程同步解决这种异步问题。让各并发进程按要求有序地推进。同步亦称直接制约关系。

进程互斥

对临界资源的访问，需要互斥的进行。即同一时间段内只能允许一个进程访问该资源。互斥亦称间接制约关系。

四个部分

对临界资源的互斥访问，可以在逻辑上分为如下四部分：

注意：

临界区是进程中访问临界资源的代码段

进入区和退出区是负责实现互斥的代码段。

临界区也可称为“临界段”

进程互斥遵循的原则

为了实现对临界资源的互斥

基于java语言对操作系统的读者与写者的进程同步与互斥问题编写程序测试并注释

06-03

好的，下面是一份基于Java语言的读者与写者进程同步与互斥问题的代码示例，以供测试和参考。代码注释中会详细解释每个部分的作用和原理。

```java

import java.util.concurrent.locks.Lock;

import java.util.concurrent.locks.ReentrantReadWriteLock;

public class ReaderWriterExample {

private final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(); // 创建读写锁

private final Lock readLock = lock.readLock(); // 获取读锁

private final Lock writeLock = lock.writeLock(); // 获取写锁

private int value = 0; // 共享变量

public void write(int newValue) {

writeLock.lock(); // 获取写锁

try {

System.out.println("Writer " + Thread.currentThread().getName() + " is writing");

value = newValue; // 写入新的值

Thread.sleep(1000); // 模拟写入操作需要一定时间

} catch (InterruptedException e) {

e.printStackTrace();

} finally {

writeLock.unlock(); // 释放写锁

System.out.println("Writer " + Thread.currentThread().getName() + " finished writing");

}

public int read() {

readLock.lock(); // 获取读锁

try {

System.out.println("Reader " + Thread.currentThread().getName() + " is reading");

Thread.sleep(500); // 模拟读取操作需要一定时间

return value; // 返回共享变量的值

} catch (InterruptedException e) {

e.printStackTrace();

return -1;

} finally {

readLock.unlock(); // 释放读锁

System.out.println("Reader " + Thread.currentThread().getName() + " finished reading");

}

```

上面的代码使用了Java并发包中的`ReentrantReadWriteLock`类，它提供了读写锁的机制，可以让多个读操作并发地进行，而写操作是互斥的。在此示例中，我们创建了一个`ReaderWriterExample`类，其中包含一个`value`变量，它可以被读者和写者进行读写操作。

在`write()`方法中，我们首先获取写锁，然后进行写入操作，最后释放写锁。在`read()`方法中，我们首先获取读锁，然后进行读取操作，最后释放读锁。这样就能够实现读操作的并发，写操作的互斥了。

为了验证代码的正确性，我们可以编写一个测试类，使用多个线程进行读写操作，如下所示：

```java

public class ReaderWriterTest {

public static void main(String[] args) {

ReaderWriterExample example = new ReaderWriterExample();

// 创建3个读线程，2个写线程

for (int i = 0; i < 3; i++) {

new Thread(() -> {

System.out.println(example.read());

}).start();

}

for (int i = 0; i < 2; i++) {

new Thread(() -> {

example.write((int) (Math.random() * 100));

}).start();

}

```

在测试类中，我们创建了3个读线程和2个写线程，它们会不断地进行读写操作。我们可以观察到，多个读线程可以并发地读取共享变量的值，而写线程在写入操作时会互斥。这样就能够保证共享变量的正确性和一致性。

需要注意的是，读写锁的机制并不能完全解决并发访问问题，因此在实际使用中还需要考虑其他的并发控制机制，如信号量、条件变量等。

“相关推荐”对你有帮助么？

非常没帮助

没帮助

一般

有帮助

非常有帮助

提交

王山山

CSDN认证博客专家

CSDN认证企业博客

码龄10年

暂无认证

216

原创

4万+

周排名

194万+

总排名

20万+

访问

等级

3969

积分

162

粉丝

获赞

427

私信

关注

热门文章

数据库：数据库的物理设计

13431

数据库：数据库系统的体系结构

9254

招银网络：笔试题（20190906）

8860

数据库：逻辑结构设计

6162

数据库：概念结构设计

5836

分类专栏

行走中的蒸汽机

27篇

PROGRAM

97篇

Interview

67篇

ALITAN

11篇

CONFIG

12篇

最新评论

图解HTTP：编码提升传输效率

殇余:

你好，有这部分提高传输速率的代码吗，有偿

Windows安装LabelImg的几种方式

一块蒙脱石:

SyntaxError: Non-UTF-8 code starting with '\xce' in file C:\Users\用户名\AppData\Local\Programs\Python\Python310\Scripts\labelImg-script.py on line 2, but no encoding declared; see https://python.org/dev/peps/pep-0263/ for details

基于opencv-python实现视频集逐帧提取为图片格式

weixin_52144083:

厉害！

Python基础教程：生成器

ctotalk:

thanks

LINTCODE：204 计数质数（Python语言实现）

ctotalk:

good.

您愿意向朋友推荐“博客详情页”吗？

强烈不推荐

不推荐

一般般

最新文章

分析H5下Android与iOS中input的disabled样式

基于BOW和SVM的目标检测

基于PIL批量修改图片JPG格式为PGM格式

2020年4篇

2019年209篇

2018年3篇

分类专栏

行走中的蒸汽机

27篇

PROGRAM

97篇

Interview

67篇

ALITAN

11篇

CONFIG

12篇

被折叠的条评论

为什么被折叠?

到【灌水乐园】发言

查看更多评论

添加红包

祝福语

请填写红包祝福语或标题

红包数量

个

红包个数最小为10个

红包总金额

元

红包金额最低5元

余额支付

当前余额3.43元

前往充值 >

需支付：10.00元

取消

确定

下一步

知道了

成就一亿技术人!

领取后你会自动成为博主和红包主的粉丝

规则

hope_wisdom 发出的红包

实付元

使用余额支付

点击重新获取

扫码支付

钱包余额

抵扣说明：

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

余额充值

Linux基础：swap基础知识与常用操作_sysctl -a 2> /dev/null | grep vm.swappiness-CSDN博客

Linux基础：swap基础知识与常用操作

最新推荐文章于 2022-10-05 19:45:56 发布

VIP文章

淼叔

最新推荐文章于 2022-10-05 19:45:56 发布

阅读量3.1k

点赞数

分类专栏：

Unix/Linux

文章标签：

swap

swapoff

swapon

交换分区

linux

本文链接：https://blog.csdn.net/liumiaocn/article/details/86614006

版权

本文以CentOS7.4为例，介绍交换（Swap）分区相关的基础知识和常用操作。

为什么要使用交换（Swap）分区

回答这个问题首先要需要知道交换分区的作用，使用Swap可以在物理内存不够的情况下，将一部分不经常使用的内存临时保存到一个特定的分区中，然后将此部分内存释放出来，而这个特殊的分区就是Swap分区。需要用到这部分数据的时候再将内容从Swap分区中恢复到内存中即可，类似Windows下的虚拟内存的概念。

优点

节省成本是Swap分区采用的重要原因

缺点

虽然在设计上已经尽量避免频繁的交换，但会带来特定情况下的性能恶化。

原则

交换分区与物理内存以一定比例进行创建，比如一般可采用如下比例：

物理内存：Swap分区 = 1 ：2

环境准备

CentOS7.4 ：最小安装即可

[root@host131 ~]# cat /etc/redhat-release

CentOS Linux release 7.4.1708 (Core)

[root@host131 ~]#

常见操作

在本节将结合见命令对交换分区进行操作

查询交换分区

可以使用如下命令进行交换分区信息的查询

free命令

使用free命令可以查看交换分区的信息如下

[root@host131 ~]# free

total used free shared buff/cache available

Mem: 4046744 801868 2438688 22148 806188 2804156

Swap: 4063228 0 4063228

[root@host131 ~]

最低0.47元/天解锁文章

优惠劵

淼叔

关注

踩

觉得还不错?

一键收藏

知道了

Linux基础：swap基础知识与常用操作

本文以CentOS7.4为例，介绍交换（Swap）分区相关的基础知识和常用操作。

复制链接

扫一扫

专栏目录

Linux服务器配置与管理：swap交换分区管理.pptx

05-02

在Linux系统中,swap交换分区的作用类似于Windows系统中“虚拟内存”,当有程序被调入内存后,但是该程序又不是常被CPU所取用时,那么这些不常被使用的程序将会被放到硬盘的swap交换分区当中,而将速度较快的内存空间释放...

Linux系统中swap分区的设置与增加/删除

09-15

我们都知道在安装Linux系统时在分区时可以分配swap分区，而系统安装后（在运行中）如何建立或调整swap分区...下面这篇文章主要给大家介绍了关于Linux系统中swap分区的设置与增加/删除的相关资料，需要的朋友可以参考下

参与评论

您还未登录，请先

后发表或查看评论

Linux内核参数vm.swappiness

Q先生

07-31

2104

1 内核参数vm.swappiness作用

内核参数vm.swappiness控制swap使用积极程度.Centos8.4默认为30

[12:05:14 root@centos8 ~]#sysctl -a|grep vm.swappiness

vm.swappiness = 30

标识,当内存剩余30%时开始使用swap交换空间.

2 临时修改vm.swappiness

[12:10:55 root@centos8 ~]#sysctl vm.swappiness=10

vm.swappiness = 10

Linux虚拟内存（swap）调优篇-“swappiness”,“vm.dirty_background_ratio”和“vm.dirty_ratio”...

weixin_34290390的博客

11-21

967

　　　　　　　Linux虚拟内存（swap）调优篇-“swappiness”,“vm.dirty_background_ratio”和“vm.dirty_ratio”

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　作者：尹正杰

　　我的kafka集群在上线一段时间后，发现内存使用达到峰值时系统开始...

Linux系统中sysctl命令详解 sysctl -p、sysctl -a、sysctl -w

热门推荐

phymat.nico的专栏

12-31

17万+

sysctl命令用于运行时配置内核参数，这些参数位于/proc/sys目录下。sysctl配置与显示在/proc/sys目录中的内核参数．可以用sysctl来设置或重新设置联网功能，如IP转发、IP碎片去除以及源路由检查等。用户只需要编辑/etc/sysctl.conf文件，即可手工或自动执行由sysctl控制的功能。

命令格式：

sysctl [-n] [-e] -w v

Linux交换分区Swappiness配置

miracleshl的博客

10-05

1817

swappiness的大小影响swap分区的使用。该值只是一个指标，虚拟内存的使用还受限于其他指标！

Linux系统swappiness参数在内存与交换分区之间优化作用

qq_42303254的博客

04-18

391

swappiness的值的大小对如何使用swap分区是有着很大的联系的。

swappiness=0的时候表示最大限度使用物理内存，然后才是 swap空间；

swappiness＝100的时候表示积极的使用swap分区，并且把内存上的数据及时的搬运到swap空间里面。

linux的基本默认设置为30，具体如下：

[root@server1 ~]# cat /proc/sys/v...

swap知识点

weixin_39523456的博客

09-29

2603

结合了两篇文章copy下来的,转载记得附上文章原文地址

linux开启swap（磁盘缓存）操作_阳光梦的专栏-CSDN博客_kib swap系统内存还有很多的情况下为何swap使用很高了 - 程序员大本营linux开启swap（磁盘缓存）操作_阳光梦的专栏-CSDN博客_kib swap

一、Swap是什么

Swap就是把一块磁盘空间或者一个本地文件，当成内存来使用。

换出，就是把进程暂时不用的内存数据存储到磁盘中

换入，就是在进程再次访问这些内存的时候，从磁盘中读取到内存

Swap其实是把系统

Linux top命令的用法详解

XWForever的专栏

03-10

3659

概述

top命令是Linux下常用的性能分析工具，常用来监控Linux的系统状况，比如cpu、内存的使用等。相当于Windows下的资源管理器，能够动态实时的显示系统中进程的资源占用情况。

top使用方法

top [-] [d] [p] [q] [c] [C] [S] [s] [n]

参数说明：

d 指定每两次屏幕信息刷新之间的时间间隔。当然用户可以使用回车(Enter)交互命令来改变之。

p 通过指定监控进程ID来仅仅监控某个进程的状态。

q 该选项将使top没有任何延迟的进行刷新。如果调用

Linux中top命令参数详解

小太阳~

02-15

3万+

本篇博文主要讲解有关top命令，top命令的主要功能是查看进程活动状态以及一些系统状况。TOP是一个动态显示过程,即可以通过用户按键来不断刷新当前状态.如果在前台执行该命令,它将独占前台,直到用户终止该程序为止.比较准确的说,top命令提供了实时的对系统处理器的状态监视.下面是使用top命令来进行性能检测的截图：各参数含义一、top前5行统计信息第1行：top - 05:43:27 up 4:52

阿里云的Centos服务器设置交换空间(swap)

王百林的博客

06-16

785

1、使用top命令查看当前系统是否有交换分区。

运行top命令后，可以在KiB Swap打头的那一行，看到交换分区相关信息。如果显示KiB Swap: 0 total 就说明没有交换分区。从top命令中退出使用“q”键。

2、首先创建用户交换分区的文件。

[root@wbl~]# dd if=/dev/zero of=/mnt/swap bs=1M count=1024 //创建一个G得交换空间

3、init初始化分区文件

[root@wbl~]# mkswap /mnt/swap

4、启...

Linux top、VIRT、RES、SHR、SWAP(S)、DATA Memory Parameters Detailed

weixin_34320159的博客

04-23

198

catalog

1. Linux TOP指令

2. VIRT -- Virtual Image (KB)

3. RES -- Resident size (KB)

4. SHR -- Shared Memory size (KB)

5. SWAP -- Swapped size (KB)

6. DATA -- Data+Stack size (KB)

7. 进程内存...

Linux基础知识与系统管理视频.rar

01-09

5.1 文本编辑器Vim-Vim常用操作 5.2 文本编辑器Vim-Vim使用技巧 6 软件包管理 6.1 软件包管理-简介 6.2.1 软件包管理-rpm命令管理-包命名与依赖性 6.2.2 软件包管理-rpm命令管理-安装升级与卸载 6.2.3 软件包管理-...

Linux网络操作系统基础：交换分区.pptx

06-16

文件系统基础概念;;系统交换空间 ;swap分区配置;谢谢

Linux基础知识与系统管理教学课件-pdf.rar

01-09

Vmware添加磁盘的方法：扩展磁盘

知行合一止于至善

12-23

3万+

这篇文章介绍了一下如何在Vmare下添加或扩展磁盘并使之有效。场景创建Linux时分配磁盘空间随着使用的增加，使用率逐渐升高，此时需要在添加或者扩展一下磁盘。

git操作基础：删除文件夹

知行合一止于至善

02-15

2万+

git中删除文件夹的方法简单整理如下

Linux基础：timedatectl命令使用介绍

知行合一止于至善

03-11

2万+

timedatectl是Linux下的一条命令，用于控制系统时间和日期。可以用来查询和更改系统时钟于设定，同时可以设定和修改时区信息。这篇文章简单介绍一下如何使用timedatectl进行常见操作。

NFS Mout错误对应：clnt_create: RPC: Program not registered

知行合一止于至善

03-19

2万+

本文记录了常见的NFS Mount时出现的Program not registered的对应方法。

c++ std::swap

最新发布

08-31

std::swap 有多个重载版本，可以用于不同类型的变量交换操作。基本用法如下： ```cpp #include int main() { int a = 10; int b = 20; std::swap(a, b); // 现在 a 的值为 20，b 的值为 10 return 0; } ...

“相关推荐”对你有帮助么？

非常没帮助

没帮助

一般

有帮助

非常有帮助

提交

淼叔

CSDN认证博客专家

CSDN认证企业博客

码龄8年

暂无认证

1348

原创

6834

周排名

127万+

总排名

873万+

访问

等级

8万+

积分

1万+

粉丝

2582

获赞

1075

6297

私信

关注

热门文章

Docker CE 还是 Docker EE

78959

Kubernetes之kubectl常用命令使用指南:1:创建和删除

76863

LDAP基础：6：使用ldapsearch进行数据查询

70197

Robot Framework基础入门：（1）：简介

69900

数学基础：积分中值定理

67363

分类专栏

趋势洞察

2篇

C++基础

11篇

Subversion Edge

15篇

OpenEuler

2篇

GitLab

1篇

SVN

18篇

算法基础

26篇

MinIO

7篇

C语言基础

7篇

PostgreSQL

9篇

云IDE

8篇

数学基础

1篇

DevOps

35篇

自动化工具

126篇

需求与缺陷管理

17篇

版本管理

77篇

自动化测试

8篇

性能测试

13篇

持续构建

98篇

持续监控

16篇

镜像私库

16篇

理论基础

33篇

人工智能

35篇

TensorFlow入门教程

34篇

容器化

2篇

深入浅出Docker

149篇

深入浅出kubernetes

132篇

K3S

18篇

云原生

7篇

Consul

12篇

Traefik

Helm

8篇

Prometheus

22篇

加密算法与证书

40篇

编程基础

1篇

spring快速入门

37篇

go语言快速入门

29篇

Angular快速入门

65篇

设计模式

4篇

实例学习Ansible系列

50篇

持久层框架快速入门

9篇

Spring

27篇

编程语言

61篇

YAML

4篇

Hibernate

8篇

Shell脚本编程

26篇

Groovy

6篇

前端

43篇

Unix/Linux

33篇

Systemd使用介绍

9篇

CentOS故障排除专题

3篇

Linux基础

22篇

MacOS基础

18篇

HP-UX基础

11篇

中间件

3篇

数据库

4篇

MySQL

40篇

Oracle

14篇

系统架构

3篇

工具

118篇

Kong

2篇

tmux使用指南

7篇

Redis

8篇

gradle

24篇

Node-Red

29篇

Scrapy

3篇

Maven

10篇

Nginx

11篇

Vagrant

2篇

LDAP

12篇

SonarQube

31篇

Jira

1篇

Jenkins

71篇

Jenkins插件

7篇

Rundeck

11篇

Redmine

1篇

ElasticSearch

10篇

Grafana

11篇

随笔

16篇

开源许可

4篇

专利申请

1篇

最新评论

tmux使用指南：5 :滚动与鼠标支持

TerryBlog:

tmux set mouse on在某些版本会触发鼠标右键自动分裂屏幕，慎用。

macOS上自带的ftp的使用方法

Ashley_Young9:

想请问一下，同一个FTP地址下，如何切换到另一个账号呢？比如，刚用账号1登录上了FTP，现在需要用账号2（不同账号、不同密码，但是是同一个FTP地址）登录，该如何操作呢？谢谢答主。

Alpine镜像中not found引出的gnu libc和musl libc的争论

白兔·:

cf1e70f126f7:/tmp/hsperfdata_root# apk add glibc-2.35-r1.apk

fetch https://dl-cdn.alpinelinux.org/alpine/v3.18/main/x86_64/APKINDEX.tar.gz

fetch https://dl-cdn.alpinelinux.org/alpine/v3.18/community/x86_64/APKINDEX.tar.gz

(1/1) Installing glibc (2.35-r1)

OK: 176 MiB in 135 packages

改成2.35-r1 解决冲突问题

Alpine镜像中not found引出的gnu libc和musl libc的争论

白兔·:

wget https://github.com/sgerrand/alpine-pkg-glibc/releases/download/2.35-r1/glibc-2.35-r1.apk

b01 commented on Dec 17, 2023

@huqingcn Yea, the work-a-round is above. But here it is in practice, not ideal. But this glibc implementation is worth it: https://github.com/kohirens/docker-alpine-glibc/blob/059ea7f865953ca2c23fb6ea9b77845b7c86dbb2/Dockerfile#L19

This was referenced on Jan 5

upgrade glibc from 2.34-r0 to 2.35-r1 to resolve nsswitch cannot be overwrriten issue CircleCI-Public/aws-cli-orb#188

Open

[TAL-696] Customize Dockerfile heyjobs/ecs-deploy-multiple-images#1

Merged

CentOS7上pip的安装方式

BeibiKissU:

大家不要用第一种yum安装，安装出来踩坑，一直提示pip版本太旧，安装总是出错，用get-pip.py安装可以

您愿意向朋友推荐“博客详情页”吗？

强烈不推荐

不推荐

一般般

最新文章

ng-alain新版尝试

zsh下brew安装

Mac基础：启用root

2021年3篇

2020年363篇

2019年475篇

2018年199篇

2017年142篇

2016年168篇

分类专栏

趋势洞察

2篇

C++基础

11篇

Subversion Edge

15篇

OpenEuler

2篇

GitLab

1篇

SVN

18篇

算法基础

26篇

MinIO

7篇

C语言基础

7篇

PostgreSQL

9篇

云IDE

8篇

数学基础

1篇

DevOps

35篇

自动化工具

126篇

需求与缺陷管理

17篇

版本管理

77篇

自动化测试

8篇

性能测试

13篇

持续构建

98篇

持续监控

16篇

镜像私库

16篇

理论基础

33篇

人工智能

35篇

TensorFlow入门教程

34篇

容器化

2篇

深入浅出Docker

149篇

深入浅出kubernetes

132篇

K3S

18篇

云原生

7篇

Consul

12篇

Traefik

Helm

8篇

Prometheus

22篇

加密算法与证书

40篇

编程基础

1篇

spring快速入门

37篇

go语言快速入门

29篇

Angular快速入门

65篇

设计模式

4篇

实例学习Ansible系列

50篇

持久层框架快速入门

9篇

Spring

27篇

编程语言

61篇

YAML

4篇

Hibernate

8篇

Shell脚本编程

26篇

Groovy

6篇

前端

43篇

Unix/Linux

33篇

Systemd使用介绍

9篇

CentOS故障排除专题

3篇

Linux基础

22篇

MacOS基础

18篇

HP-UX基础

11篇

中间件

3篇

数据库

4篇

MySQL

40篇

Oracle

14篇

系统架构

3篇

工具

118篇

Kong

2篇

tmux使用指南

7篇

Redis

8篇

gradle

24篇

Node-Red

29篇

Scrapy

3篇

Maven

10篇

Nginx

11篇

Vagrant

2篇

LDAP

12篇

SonarQube

31篇

Jira

1篇

Jenkins

71篇

Jenkins插件

7篇

Rundeck

11篇

Redmine

1篇

ElasticSearch

10篇

Grafana

11篇

随笔

16篇

开源许可

4篇

专利申请

1篇

被折叠的条评论

为什么被折叠?

到【灌水乐园】发言

查看更多评论

添加红包

祝福语

请填写红包祝福语或标题

红包数量

个

红包个数最小为10个

红包总金额

元

红包金额最低5元

余额支付

当前余额3.43元

前往充值 >

需支付：10.00元

取消

确定

下一步

知道了

成就一亿技术人!

领取后你会自动成为博主和红包主的粉丝

规则

hope_wisdom 发出的红包

实付元

使用余额支付

点击重新获取

扫码支付

钱包余额

抵扣说明：

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

余额充值

Linux Swap详解 - 钟桂耀 - 博客园

会员

周边

新闻

博问

AI培训

云市场

所有博客

当前博客

我的博客

我的园子

账号设置

简洁模式 ...

退出登录

钟桂耀

博客园

首页

新随笔

联系

管理

Linux Swap详解

什么是Linux swap space呢？我们先来看看下面两段关于Linux swap space的英文介绍资料:

Linux divides its physical RAM (random access memory) into chucks of memory called pages. Swapping is the process whereby a page of memory is copied to the preconfigured space on the hard disk, called swap space, to free up that page of memory. The combined sizes of the physical memory and the swap space is the amount of virtual memory available.

Swap space in Linux is used when the amount of physical memory (RAM) is full. If the system needs more memory resources and the RAM is full, inactive pages in memory are moved to the swap space. While swap space can help machines with a small amount of RAM, it should not be considered a replacement for more RAM. Swap space is located on hard drives, which have a slower access time than physical memory.Swap space can be a dedicated swap partition (recommended), a swap file, or a combination of swap partitions and swap files.

Linux内核为了提高读写效率与速度，会将文件在内存中进行缓存，这部分内存就是Cache Memory(缓存内存)。即使你的程序运行结束后，Cache Memory也不会自动释放。这就会导致你在Linux系统中程序频繁读写文件后，你会发现可用物理内存变少。当系统的物理内存不够用的时候，就需要将物理内存中的一部分空间释放出来，以供当前运行的程序使用。那些被释放的空间可能来自一些很长时间没有什么操作的程序，这些被释放的空间被临时保存到Swap空间中，等到那些程序要运行时，再从Swap分区中恢复保存的数据到内存中。这样，系统总是在物理内存不够时，才进行Swap交换。

在Linux下，SWAP的作用类似Windows系统下的“虚拟内存”。当物理内存不足时，拿出部分硬盘空间当SWAP分区（虚拟成内存）使用，从而解决内存容量不足的情况。

SWAP意思是交换，顾名思义，当某进程向OS请求内存发现不足时，OS会把内存中暂时不用的数据交换出去，放在SWAP分区中，这个过程称为SWAP OUT。当某进程又需要这些数据且OS发现还有空闲物理内存时，又会把SWAP分区中的数据交换回物理内存中，这个过程称为SWAP IN。

当然，swap大小是有上限的，一旦swap使用完，操作系统会触发OOM-Killer机制，把消耗内存最多的进程kill掉以释放内存

数据库系统为什么嫌弃swap？

显然，swap机制的初衷是为了缓解物理内存用尽而选择直接粗暴OOM进程的尴尬。但坦白讲，几乎所有数据库对swap都不怎么待见，无论MySQL、Oracal、MongoDB抑或HBase，为什么？这主要和下面两个方面有关：

1. 数据库系统一般都对响应延迟比较敏感，如果使用swap代替内存，数据库服务性能必然不可接受。对于响应延迟极其敏感的系统来讲，延迟太大和服务不可用没有任何区别，比服务不可用更严重的是，swap场景下进程就是不死，这就意味着系统一直不可用……再想想如果不使用swap直接oom，是不是一种更好的选择，这样很多高可用系统直接会主从切换掉，用户基本无感知。

2. 另外对于诸如HBase这类分布式系统来说，其实并不担心某个节点宕掉，而恰恰担心某个节点夯住。一个节点宕掉，最多就是小部分请求短暂不可用，重试即可恢复。但是一个节点夯住会将所有分布式请求都夯住，服务器端线程资源被占用不放，导致整个集群请求阻塞，甚至集群被拖垮。

从这两个角度考虑，所有数据库都不喜欢swap还是很有道理的！

swap的工作机制

既然数据库们对swap不待见，那是不是就要使用swapoff命令关闭磁盘缓存特性呢？非也，大家可以想想，关闭磁盘缓存意味着什么？实际生产环境没有一个系统会如此激进，要知道这个世界永远不是非0即1的，大家都会或多或少选择走在中间，不过有些偏向0，有些偏向1而已。很显然，在swap这个问题上，数据库必然选择偏向尽量少用。HBase官方文档的几点要求实际上就是落实这个方针：尽可能降低swap影响。知己知彼才能百战不殆，要降低swap影响就必须弄清楚Linux内存回收是怎么工作的，这样才能不遗漏任何可能的疑点。

先来看看swap是如何触发的？

简单来说，Linux会在两种场景下触发内存回收，一种是在内存分配时发现没有足够空闲内存时会立刻触发内存回收；一种是开启了一个守护进程（swapd进程）周期性对系统内存进行检查，在可用内存降低到特定阈值之后主动触发内存回收。第一种场景没什么可说，来重点聊聊第二种场景，如下图所示：

Linux swap相关命令：

swapoff -a //停止所有的swap分区

sudo swapoff -v /swapfile //关闭某个分区

swapoff -a //关闭所有swap空间（包含磁盘、文件）

swapon -a //开启所有swap空间（已经配置到/etc/fstab文件中的）

swapon -s // 显示交换分区的简要信息

free -m //查看swap空间大小

sysctl -q vm.swappiness //查询swap优先级

sudo sysctl vm.swappiness=10 //修改swap优先级，注：即使将值设为0，也并不会禁用swap，只是尽可能少用swap，多用实际内存。

查看Swap分区大小

查看Swap分区的大小以及使用情况，一般使用free命令即可，如下所示，Swap大小为2015M，目前没有使用Swap分区

[root@DB-Server ~]# free -m

total used free shared buffers cached

Mem: 1000 855 145 0 28 296

-/+ buffers/cache: 530 470

Swap: 2015 0 2015

另外我们还可以使用swapon命令查看当前swap相关信息：例如swap空间是swap partition，Swap size，使用情况等详细信息

[root@DB-Server ~]# swapon -s

Filename Type Size Used Priority

/dev/sda3 partition 2064344 0 -1

[root@DB-Server ~]# cat /proc/swaps

Filename Type Size Used Priority

/dev/sda3 partition 2064344 0 -1

[root@DB-Server ~]#

如图：

Swap分区大小设置

系统的Swap分区大小设置多大才是最优呢？关于这个问题，应该说只能有一个统一的参考标准，具体还应该根据系统实际情况和内存的负荷综合考虑，像ORACLE的官方文档就推荐如下设置，这个是根据物理内存来做参考的。

RAM

Swap Space

Up to 512 MB

2 times the size of RAM

Between 1024 MB and 2048 MB

1.5 times the size of RAM

Between 2049 MB and 8192 MB

Equal to the size of RAM

More than 8192 MB

0.75 times the size of RAM

另外在其它博客中看到下面一个推荐设置，当然我不清楚其怎么得到这个标准的。是否合理也无从考证。可以作为一个参考。

4G以内的物理内存，SWAP 设置为内存的2倍。

4-8G的物理内存，SWAP 等于内存大小。

8-64G 的物理内存，SWAP 设置为8G。

64-256G物理内存，SWAP 设置为16G。

上下两个标准确实也很让人无所适从。我就有一次在一台ORACLE数据库服务器（64G的RAM），按照官方推荐设置了一个很大的Swap分区，但是我发现其实这个Swap几乎很少用到，其实是浪费了磁盘空间。所以如果根据系统实际情况和内存的负荷综合考虑，其实应该按照第二个参考标准设置为8G即可。当然这个只是个人的一些认知。

释放Swap分区空间

[root@testlnx ~]# free -m

total used free shared buffers cached

Mem: 64556 55368 9188 0 926 51405

-/+ buffers/cache: 3036 61520

Swap: 65535 13 65522

[root@testlnx ~]# swapon -s

Filename Type Size Used Priority

/dev/mapper/VolGroup00-LogVol01 partition 67108856 14204 -1

使用swapoff关闭交换分区

[root@testlnx ~]# swapoff /dev/mapper/VolGroup00-LogVol01

使用swapon启用交换分区，此时查看交换分区的使用情况，你会发现used为0了

[root@testlnx ~]# swapon /dev/mapper/VolGroup00-LogVol01

[root@testlnx ~]# free -m

total used free shared buffers cached

Mem: 64556 55385 9171 0 926 51406

-/+ buffers/cache: 3052 61504

Swap: 65535 0 65535

[root@testlnx ~]#

wap分区空间什么时候使用

系统在什么情况或条件下才会使用Swap分区的空间呢？其实是Linux通过一个参数swappiness来控制的。当然还涉及到复杂的算法。

这个参数值可为 0-100，控制系统 swap 的使用程度。高数值可优先系统性能，在进程不活跃时主动将其转换出物理内存。低数值可优先互动性并尽量避免将进程转换处物理内存，并降低反应延迟。默认值为 60。注意：这个只是一个权值，不是一个百分比值，涉及到系统内核复杂的算法。关于该参数请参考这篇文章[转载]调整虚拟内存，在此不做过多赘述。下面是关于swappiness的相关资料

The Linux 2.6 kernel added a new kernel parameter called swappiness to let administrators tweak the way Linux swaps. It is a number from 0 to 100. In essence, higher values lead to more pages being swapped, and lower values lead to more applications being kept in memory, even if they are idle. Kernel maintainer Andrew Morton has said that he runs his desktop machines with a swappiness of 100, stating that "My point is that decreasing the tendency of the kernel to swap stuff out is wrong. You really don't want hundreds of megabytes of BloatyApp's untouched memory floating about in the machine. Get it out on the disk, use the memory for something useful."

Swappiness is a property of the Linux kernel that changes the balance between swapping out runtime memory, as opposed to dropping pages from the system page cache. Swappiness can be set to values between 0 and 100 inclusive. A low value means the kernel will try to avoid swapping as much as possible where a higher value instead will make the kernel aggressively try to use swap space. The default value is 60, and for most desktop systems, setting it to 100 may affect the overall performance, whereas setting it lower (even 0) may improve interactivity (by decreasing response latency.

有两种临时修改swappiness参数的方法，系统重启后失效

方法1：

[root@DB-Server ~]# more /proc/sys/vm/swappiness

[root@DB-Server ~]# echo 10 > /proc/sys/vm/swappiness

[root@DB-Server ~]# more /proc/sys/vm/swappiness

方法2

[root@DB-Server ~]#sysctl vm.swappiness=10

永久修改swappiness参数的方法就是在配置文件/etc/sysctl.conf里面修改vm.swappiness的值，然后重启系统

echo 'vm.swappiness=10' >>/etc/sysctl.conf

如果有人会问是否物理内存使用到某个百分比后才会使用Swap交换空间，可以明确的告诉你不是这样一个算法，如下截图所示，及时物理内存只剩下8M了，但是依然没有使用Swap交换空间，而另外一个例子，物理内存还剩下19G，居然用了一点点Swap交换空间。

如图：

外调整/proc/sys/vm/swappiness这个参数，如果你没有绝对把握，就不要随便调整这个内核参数，这个参数符合大多数情况下的一个最优值。

Swap交换分区对性能的影响

我们知道Linux可以使用文件系统中的一个常规文件或独立分区作为Swap交换空间，相对而言，交换分区要快一些。但是和RAM比较而言，Swap交换分区的性能依然比不上物理内存，目前的服务器上RAM基本上都相当充足，那么是否可以考虑抛弃Swap交换分区，是否不需要保留Swap交换分区呢？这个其实是我的疑问之一。在这篇What Is a Linux SWAP Partition, And What Does It Do?博客中，作者给出了swap交换空间的优劣

Advantages:

Provides overflow space when your memory fills up completely

Can move rarely-needed items away from your high-speed memory

Allows you to hibernate

Disadvantages:

Takes up space on your hard drive as SWAP partitions do not resize dynamically

Can increase wear and tear to your hard drive

Does not necessarily improve performance (see below)

其实保留swap分区概括起来可以从下面来看：

首先，当物理内存不足以支撑系统和应用程序（进程）的运作时，这个Swap交换分区可以用作临时存放使用率不高的内存分页，把腾出的内存交给急需的应用程序（进程）使用。有点类似机房的UPS系统，虽然正常情况下不需要使用，但是异常情况下， Swap交换分区还是会发挥其关键作用。

其次，即使你的服务器拥有足够多的物理内存，也有一些程序会在它们初始化时残留的极少再用到的内存分页内容转移到 swap 空间，以此让出物理内存空间。对于有发生内存泄漏几率的应用程序（进程），Swap交换分区更是重要，因为谁也不想看到由于物理内存不足导致系统崩溃。

最后，现在很多个人用户在使用Linux，有些甚至是PC的虚拟机上跑Linux系统，此时可能常用到休眠（Hibernate），这种情况下也是推荐划分Swap交换分区的。

其实少量使用Swap交换空间是不会影响性能，只有当RAM资源出现瓶颈或者内存泄露，进程异常时导致频繁、大量使用交换分区才会导致严重性能问题。另外使用Swap交换分区频繁，还会引起kswapd0进程（虚拟内存管理中, 负责换页的）耗用大量CPU资源，导致CPU飙升。

关于Swap分区的优劣以及是否应该舍弃，我有点恶趣味的想到了这个事情：人身上的两个器官，阑尾和扁桃体。切除阑尾或扁桃体是否也是争论不休。另外，其实不要Swap交换分区，Linux也是可以正常运行的（有人提及过这个问题）

调整Swap分区的大小

如下测试案例所示，Swap分区大小为65535M，我现在想将Swap分区调整为8G，那么我们来看看具体操作吧

1：查看Swap的使用情况以及相关信息

[root@getlnx14uat ~]# swapon -s

Filename Type Size Used Priority

/dev/mapper/VolGroup00-LogVol01 partition 67108856 878880 -1

[root@getlnx14uat ~]# free -m

total used free shared buffers cached

Mem: 3957 3920 36 0 39 3055

-/+ buffers/cache: 825 3132

Swap: 65535 858 64677

2：关闭Swap交换分区

[root@getlnx14uat ~]# swapoff /dev/mapper/VolGroup00-LogVol01

[root@getlnx14uat ~]# swapon -s

Filename Type Size Used Priorit

3：这里是缩小Swap分区大小，如果是增大Swap分区大小，那么就需要扩展正在使用的swap分区的逻辑卷,此处使用lvreduce命令收缩逻辑卷。

[root@getlnx14uat ~]# lvreduce -L 8G /dev/mapper/VolGroup00-LogVol01

WARNING: Reducing active logical volume to 8.00 GB

THIS MAY DESTROY YOUR DATA (filesystem etc.)

Do you really want to reduce LogVol01? [y/n]: y

Reducing logical volume LogVol01 to 8.00 GB

Logical volume LogVol01 successfully resized

4：格式化swap分区

Setting up swapspace version 1, size = 8589930 kB

5:启动swap分区,并增加到/etc/fstab自动挂载

Filename Type Size Used Priority

[root@getlnx14uat ~]# swapon -s

/dev/mapper/VolGroup00-LogVol01 partition 8388600 0 -1

如图：

linux swap空间的swappiness=0

linux 会使用硬盘的一部分做为SWAP分区，用来进行进程调度--进程是正在运行的程序--把当前不用的进程调成‘等待（standby）‘，甚至‘睡眠（sleep）’，一旦要用，再调成‘活动（active）’，睡眠的进程就躺到SWAP分区睡大觉，把内存空出来让给‘活动’的进程。　　

如果内存够大，应当告诉

linux 不必太多的使用 SWAP 分区，可以通过修改 swappiness

的数值。swappiness=0的时候表示最大限度使用物理内存，然后才是

swap空间，swappiness＝100的时候表示积极的使用swap分区，并且把内存上的数据及时的搬运到swap空间里面。

在linux里面，默认设置swappiness这个值等于60。

现在一般1个G的内存可修改为10， 2个G的可改为5，甚至是0。具体这样做：

　　1.查看你的系统里面的swappiness

　　$ cat /proc/sys/vm/swappiness

　　不出意外的话，你应该看到是 60

　　2.修改swappiness值为10

　　$ sudo sysctl vm.swappiness=10

　　但是这只是临时性的修改，在你重启系统后会恢复默认的60，为长治久安，还要更进一步：

　　$ sudo gedit /etc/sysctl.conf

　　在这个文档的最后加上这样一行:

　　vm.swappiness=10

　　然后保存，重启。ok，你的设置就生效了。

一般来说，Linux的虚拟内存会根据系统负载自动调整。内存页（page）swap到磁盘会显著的影响Kafka的性能，并且Kafka重度使用page cache，如果VM系统swap到磁盘，那说明没有足够的内存来分配page cache。

避免swap的一种方式是设置swap空间为0。但是，swap会在系统崩溃时提供安全机制，或者会在out of memory的情况下阻止操作系统 kill 掉进程。由于这个原因，推荐 vm.swappiness参数设置为一个非常低的值：1 。这个参数表示 VM系统中的多少百分比用来作为swap空间。

另外一种方式是通过内核调节“脏页”（注：“脏页”会被刷到磁盘上）。Kafka依赖磁盘I/O性能来提高producer的响应时间。这也是为什么通常优先把log segment功能放在可以快速响应的磁盘中（比如SSD）。这样使得flush进程把“脏数据”写入磁盘前，“脏页”数目就减少了，可以设置vm.dirty_background_ratio（表示占用系统内存的百分比）参数的值为10 以下。大部分应用场景下，vm.dirty_background_ratio设置为 5 就够用了，要注意了：这个参数值不能设置为 0 ，因为设置为 0 后会引起内核持续刷“脏页”，使得内核的buffer write功能没法施展。

“脏页”的总量可以通过vm.dirty_ratio 来改变，默认值是 20 （此处也是百分比），这个值的设置范围较大，一般建议设置 60 到 80 为合理的值。但是vm.dirty_ratio 参数也引来了不小的风险，会造成大量unflush的数据在硬刷到磁盘时产生较长的I/O停顿。如果vm.dirty_ratio 值设置的较大时，强烈建议Kafka开启备份功能，以备系统崩溃。

在设置了这些参数后，需要监控Kafka集群运行时“脏页”的数量，当前“脏页”数量可由如下方式查看（/proc/vmstat文件）：

#cat /proc/vmstat | egrep "dirty|writeback"

nr_dirty 3875

nr_writeback 29

nr_writeback_temp 0

临时生效：sysctl -w vm.swappiness=0

永久生效：

echo "vm.swappiness = 0">> /etc/sysctl.conf （尽量不使用交换分区，注意不是禁用）

刷新SWAP

可以执行命令刷新一次SWAP（将SWAP里的数据转储回内存，并清空SWAP里的数据）

swapoff -a && swapon -a

sysctl -p (执行这个使其生效，不用重启)

参考：

https://www.cnblogs.com/kerrycode/p/5246383.html

https://www.cnblogs.com/pipci/p/11399250.html

https://www.cnblogs.com/augusite/p/10784416.html

posted @

2020-11-12 15:05

钟桂耀

阅读(9506)

编辑

会员力量，点亮园子希望

刷新页面返回顶部

公告

Linux swap命令-CSDN博客

Linux swap命令

最新推荐文章于 2023-05-19 16:24:47 发布

韩湘

最新推荐文章于 2023-05-19 16:24:47 发布

阅读量4.2k

点赞数

分类专栏：

Linux

文章标签：

linux

swap

本文链接：https://blog.csdn.net/qq_38228254/article/details/78565656

版权

Linux

专栏收录该内容

28 篇文章

2 订阅

订阅专栏

swapoff :关闭系统交换分区参数 -a 关闭所有交换设备选择参数 -h 帮助信息 -V 版本信息

显示分区信息：

sfdisk -l

关闭交换分区：

swapoff /交换分区swap文件路径/swap文件

一关一开可以刷新swap设置

swapoff -a swapon -a

查询swap优先级：

sysctl -q vm.swappiness

修改swap优先级：

sudo sysctl vm.swappiness=10

若想持久生效，需要更改 sysctl.conf 文件：

vim /etc/sysctl.conf

添加：vm.swappiness=10 重启。注：即使将值设为0，也并不会禁用swap，只是尽可能少用swap，多用实际内存。

优惠劵

韩湘

关注

踩

觉得还不错?

一键收藏

知道了

Linux swap命令

swapoff :关闭系统交换分区参数 -a 关闭所有交换设备选择参数 -h 帮助信息 -V 版本信息显示分区信息： sfdisk -l关闭交换分区： swapoff /交换分区swap文件路径/swap文件一关一开可以刷新swap设置 swapoff -a swapon -a 查询swap优先级： sysctl -q vm.swappiness修改swa

复制链接

扫一扫

专栏目录

Linux top 命令详解

Nicolege678的博客

07-01

2996

上图为top命令执行后返回的参数，接下来我们会逐行去分析解释。第一行：top - 21:31:26 up 15:16, 5 users, load average: 0.61, 0.82, 0.75第二行：（进程数据）Tasks: 240 total, 2 running, 238 sleeping, 0 stopped, 0 zombie第三行：（CPU数据）%Cpu(s): 13.7 us, 1.5 sy, 0.0 ni, 84.2 id, 0.6 wa, 0.0 hi, 0.

linux配置选项详解

YGguang的专栏

04-16

2295

原文：http://linux.chinaitlab.com/kernel/890397.html

内核的配置选项有很多，一般情况下大部分选项都可以使用默认值，因此并不需要了解它们所代表的意义；但是某些应用场合需要将内核剪裁的足够小，这就需要我们知道各个选项的意义了。

即使不考虑内核剪裁的因素，当我们打算深入了解某一个子系统时，也需要从该子系统的配置选项入手（可以从该

参与评论

您还未登录，请先

后发表或查看评论

Linux系统设置swap大小,创建swap,top虚拟内存，VIRT RES SH

码农崛起

05-19

3166

swap 分区通常被称为交换分区，这是一块特殊的硬盘空间，即当实际内存不够用的时候，操作系统会从内存中取出一部分暂时不用的数据，放在交换分区中，从而为当前运行的程序腾出足够的内存空间。最后，交换空间的页面在使用时会首先被交换到物理内存，如果此时没有足够的物理内存来容纳这些页面，它们又会被马上交换出去，如此一来，虚拟内存中可能没有足够的空间来存储这些交换页面，最终会导致 Linux 出现假死机、服务异常等问题。当然，频繁地读写硬盘，会显著降低操作系统的运行速率，这也是使用 swap 交换分区最大的限制。

【linux】详解TOP命令

带你去吃小豆花的博客

09-16

2200

linux系统中用到的top命令得到的参数，都是什么意思呢？

linux swap

jackjiangjin的博客

08-15

1469

linux swap

linux 禁止swap交换

z_Biner 的博客

11-09

572

linux 禁止swap交换

1.禁用命令 sudo swapoff -a

2.启用命令 sudo swapon -a

3.查看交换分区的状态 sudo free -m

swap脚本命令

weixin_33893473的博客

04-26

240

要求：自动建立新的swap分区，且开机自动激活命令：vim /bin/swap.sh ##编写脚本脚本内容命令：echo /dev/vdb$2 swap swap defualts 0 0 >>/etc/fstab ##设置开机自动激活测试 **开机重启测试

转载于:https://blog.51cto.com/123...

【Linux】SWAP 深度解读（必须收藏）

zclinux的博客

12-27

4207

本文讨论的swap基于Linux4.4内核代码。Linux内存管理是一套非常复杂的系统，而swap只是其中一个很小的处理逻辑。希望本文能让读者了解Linux对swap的使用大概是什么样子。阅读完本文，应该可以帮你解决以下问题：1、swap到底是干嘛的？2、swappiness到底是用来调节什么的？3、kswapd什么时候会进行swap操作？4、什么是内存水位标记？5、swap分区的优先级（priority）有啥用？我们一般所说的swap，指的是一个交换分区或文件。

Linux SWAP 深度解读

weixin_33728268的博客

06-06

2346

概述

本文讨论的swap基于Linux4.4内核代码。Linux内存管理是一套非常复杂的系统，而swap只是其中一个很小的处理逻辑。

希望本文能让读者了解Linux对swap的使用大概是什么样子。阅读完本文，应该可以帮你解决以下问题：

1、swap到底是干嘛的？2、swappiness到底是用来调节什么的？3、kswapd什么时候会进行swap操作？4、什么是内存水位标记？5、swap分...

linux下swap指令,Linux swapoff命令

weixin_33901087的博客

05-12

240

Linux swapoff命令Linux swapoff命令用于关闭系统交换区(swap area)。swapoff实际上为swapon的符号连接，可用来关闭系统的交换区。语法swapoff [设备]参数：-a 将/etc/fstab文件中所有设置为swap的设备关闭-h 帮助信息-V 版本信息实例显示分区信息:# sfdisk -l //显示分区信息Disk /dev/sda: 1305 cy...

swap分区命令

经验之谈，不做搬运工

09-17

522

从网上总结的方法，步骤如下所示，请在root权限下操作命令：

1、检查当前的分区情况（使用free －m或cat /proc/swaps ）：

# free –m

通过这个命令，你可以得到mem和swap以及buffer/cache的信息。

2、增加交换分区文件及大小：

判定新交换文件的大小，将大小乘以1024来判定块的大小。例如，大小为64MB的交换文件的块大小为65...

swap文件创建命令(简单记录)

Gary,Done的专栏

06-28

2757

安利一篇我翻译的国外大牛的神经网络入门文章

创建一个10G的swap文件，放在home下面，给当前用户和root使用(由文件权限决定)

cd ~/

dd if=/dev/zero of=swapfile bs=1G count=10

chmod 600 swapfile

mkswap swapfile

sudo swapon swapfile

Linux 磁盘维护 : swapon & swapoff 命令详解

yexiangCSDN的专栏

10-19

1万+

swapon命令用于激活Linux系统中交换空间，Linux系统的内存管理必须使用交换区来建立虚拟内存。

语法

swapon(选项)(参数)

选项

-a：将/etc/fstab文件中所有设置为swap的设备，启动为交换区；

-h：显示帮助；

-p<优先顺序>：指定交换区的优先顺序；

-s：显示交换区的使用状况；

-V：显示版本信息。

参数

交换空间：指定需要激活的交换空...

linux 查看哪些进程用了swap

良玉的博客

11-22

4万+

如果系统的物理内存用光了，则会用到swap。系统就会跑得很慢，但仍能运行;如果Swap空间用光了，那么系统就会发生错误。通常会出现“application is out of memory”的错误，严重时会造成服务进程的死锁。所以要高度重视。

swap查看有很多种方法，一一介绍下：

free

free -m

就能看出当前系统所使用的swap了。那么如何查看哪些进程使用了

LINUX学习基础篇（二十六）swap分区

qq_29021545的博客

02-04

2861

LINUX学习基础篇（二十六）swap分区

Linux学习笔记

简要介绍了swap分区以及分区大小调整。

Linux的swap空间需要设置多大？

热门推荐

李向东的专栏

11-07

4万+

无论是windows系统还是linux系统，除了物理内存外，都还有一个虚拟内存。在linux上，虚拟内存被称为swap space。过去以来，虚拟内存的大小应该是物理内存的两倍，但是最近几年来，物理内存的大小至少都有了好几个GB，如果16G内存用32G的swap岂不是太占用硬盘空间？下图是虚拟内存和交换空间的映射关系，虚拟内存的存在，可以提高电脑的运行速度，所以其存在很有意义。我们看看redhat

设置swap

静室

05-08

338

linux系统会用内存做很多的buffer和cache，所以经常会看到内存用完了，其实这里面可能只有很少的一部分是程序用到的。当内存不足的时候，系统有两种选择，一是减少缓存的量，另一种是把部分程序使用的内存换到swap中。如果是mysql使用的内存被转移到swap中了会对性能有很大的影响，所以应该尽量保持 mysql使用的部分在内存中不被转移出去。可以使用memlock启动mysql是mysq...

如何在Ubuntu 16.04上增加Swap分区

蚁人的博客

01-31

2万+

翻译自：How To Add Swap Space on Ubuntu 16.04

前言

提高服务器响应速度和防止应用程序内存不足错误的最简单方法之一是添加一些交换空间。在本指南中，我们将介绍如何将交换文件添加到Ubuntu 16.04服务器。

但是，请注意：

尽管swap区通常建议用于使用传统旋转硬盘驱动器的系统，但使用与SSD交换可能会导致随着时间的推移硬件退化问题。由于这个考虑，

郝健: Linux内存管理学习笔记-第4节课

Linux阅码场

04-24

577

前序文章：郝健: Linux内存管理学习笔记-第1节课郝健: Linux内存管理学习笔记-第2节课郝健: Linux内存管理学习笔记-第3节课摘要page cachefr...

Linux swap减少

最新发布

01-26

你可以通过以下步骤来减小Linux swap分区的大小： 1. 确认当前的swap分区大小和使用情况。可以使用`free -h`命令查看swap分区的大小和使用情况。 2. 禁用swap分区。可以使用`swapoff`命令禁用swap分区。例如，如果...

“相关推荐”对你有帮助么？

非常没帮助

没帮助

一般

有帮助

非常有帮助

提交

韩湘

CSDN认证博客专家

CSDN认证企业博客

码龄7年

暂无认证

104

原创

2万+

周排名

138万+

总排名

148万+

访问

等级

9525

积分

338

粉丝

505

获赞

213

1650

私信

关注

热门文章

空间统计：Moran's I（莫兰指数）

134989

Android用户登录注册界面

104822

Ubuntu开启或重启ssh服务

80842

Windows使用CMD命令查看进程和终止进程

58153

Android设置TextView文字居中

53685

分类专栏

算法之图论

1篇

算法之数学问题

3篇

alg

4篇

java

1篇

随时可能改名字的专栏

Linux

28篇

android-studio

84篇

Windows

6篇

C/C++

8篇

Python

10篇

Tensorflow

1篇

markdown

11篇

sql

7篇

HTML

12篇

LaTeX

2篇

GitHub

1篇

其他

30篇

数据处理

2篇

嵌入式基础概念讨论

10篇

计算机网络基础

6篇

最新评论

VMware清理Linux虚拟机硬盘

啦巴巴小魔仙:

引用「sudo cat /dev/zero > zero;sync;sleep 1」

这一条命令很卡很卡而且为什么最后空间更小了。。是咋回事呀

SQL中ALL、Any、Some的区别

gxy410225:

懂了,明白

Fragment中OnCreate与OnCreateView区别

kkktttvvvv:

onCreate()只会创建一次，onCreateView()在销毁唤醒之后会调用

Linux ln -sf 的用法

sangshushu:

f是force

统计vector中重复元素的个数

bec666:

头文件都没加，

最新文章

单源最短路径算法

拓展CRT算法

乘法逆元、更相减损术与辗转相除法、欧几里得算法和拓展欧几里得算法

2021年4篇

2020年6篇

2019年53篇

2018年109篇

2017年51篇

分类专栏

算法之图论

1篇

算法之数学问题

3篇

alg

4篇

java

1篇

随时可能改名字的专栏

Linux

28篇

android-studio

84篇

Windows

6篇

C/C++

8篇

Python

10篇

Tensorflow

1篇

markdown

11篇

sql

7篇

HTML

12篇

LaTeX

2篇

GitHub

1篇

其他

30篇

数据处理

2篇

嵌入式基础概念讨论

10篇

计算机网络基础

6篇

被折叠的条评论

为什么被折叠?

到【灌水乐园】发言

查看更多评论

添加红包

祝福语

请填写红包祝福语或标题

红包数量

个

红包个数最小为10个

红包总金额

元

红包金额最低5元

余额支付

当前余额3.43元

前往充值 >

需支付：10.00元

取消

确定

下一步

知道了

成就一亿技术人!

领取后你会自动成为博主和红包主的粉丝

规则

hope_wisdom 发出的红包

实付元

使用余额支付

点击重新获取

扫码支付

钱包余额

抵扣说明：

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

余额充值

操作系统之进程管理(下)，同步互斥死锁问题，看看操作系统怎么解决的-腾讯云开发者社区-腾讯云

之进程管理(下)，同步互斥死锁问题，看看操作系统怎么解决的-腾讯云开发者社区-腾讯云阿甘的码路操作系统之进程管理(下)，同步互斥死锁问题，看看操作系统怎么解决的关注作者腾讯云开发者社区文档建议反馈控制台首页学习活动专区工具TVP最新优惠活动文章/答案/技术大牛搜索搜索关闭发布登录/注册首页学习活动专区工具TVP最新优惠活动返回腾讯云官网阿甘的码路首页学习活动专区工具TVP最新优惠活动返回腾讯云官网社区首页 >专栏 >操作系统之进程管理(下)，同步互斥死锁问题，看看操作系统怎么解决的操作系统之进程管理(下)，同步互斥死锁问题，看看操作系统怎么解决的阿甘的码路关注发布于 2022-09-22 12:00:256200发布于 2022-09-22 12:00:25举报文章被收录于专栏：阿甘的码路2阿甘的码路2目录：

进程同步，进程互斥进程同步进程互斥临界区的互斥访问进程互斥的软件实现方法（很多，可跳过）进程互斥的硬件实现-中断屏蔽方法进程互斥的硬件实现-TestAndSet指令进程互斥的硬件实现-Swap指令JAVA 并发包 CAS 实现信号量机制管程synchronized 底层原理-管程死锁什么是死锁死锁、饥饿、死循环的区别死锁产生的必要条件死锁的处理策略预防死锁避免死锁-银行家算法死锁的检测和恢复进程同步，进程互斥进程同步进程具有异步性的特征。异步性是指，各并发执行的进程以各自独立的、不可预知的速度向前推进。看一个例子:进程通信——管道通信。进程通信-管道通信读进程和写进程并发地运行，由于并发必然导致异步性，因此“写数据”和“读数据”两个操作执行的先后顺序是不确定的。而实际应用中，又必须按照“写数据->读数据”的顺序来执行的。如何解决这种异步问题，就是 “进程同步”所讨论的内容。同步亦称直接制约关系，它是指为完成某种任务而建立的两个或多个进程，这些进程因为需要在某些位置上协调它们的工作次序而产生的制约关系。进程间的直接制约关系就是源于它们之间的相互合作。进程互斥进程的“并发”需要“共享”的支持。各个并发执行的进程不可避免的需要共享一些系统资源(比如内存，又比如打印机、摄像头这样的I/O设备)。有两种共享方式：互斥共享方式：系统中的某些资源，虽然可以提供给多个进程使用，但一个时间段内只允许一个进程访问该资源；同时共享方式：系统中的某些资源，允许一个时间段内由多个进程“同时”对它们进行访问.我们把一个时间段内只允许一个进程使用的资源称为临界资源。许多物理设备(比如摄像头、打印机)都属于临界资源。此外还有许多变量、数据、内存缓冲区等都属于临界资源。对临界资源的访问，必须互斥地进行。互斥，亦称间接制约关系。进程互斥指当一个进程访问某临界资源时，另一个想要访问该临界资源的进程必须等待。当前访问临界资源的进程访问结束，释放该资源之后，另一个进程才能去访问临界资源。临界区的互斥访问对临界资源的互斥访问，可以在逻辑上分为如下四个部分:临界区的互斥访问临界区是进程中访问临界资源的代码段。进入区和退出区是负责实现互斥的代码段。临界区也可称为“临界段”。有个问题：如果一个进程暂时不能进入临界区，那么该进程是否应该一直占着处理机?该进程有没有可能一直进不了临界区?为了实现对临界资源的互斥访问，同时保证系统整体性能，需要遵循以下原则:空闲让进。临界区空闲时，可以允许一个请求进入临界区的进程立即进入临界区;忙则等待。当已有进程进入临界区时，其他试图进入临界区的进程必须等待;有限等待。对请求访问的进程，应保证能在有限时间内进入临界区(保证不会饥饿);让权等待。当进程不能进入临界区时，应立即释放处理机，防止进程忙等待。小结进程互斥的软件实现方法（很多，可跳过）进程互斥的软件实现「单标志法」算法思想:两个进程在访问完临界区后会把使用临界区的权限转交给另一个进程。也就是说每个进程进入临界区的权限只能被另一个进程赋予。单标志法解释：turn 的初值为 0，即刚开始只允许 0 号进程进入临界区。若 P1 先上处理机运行，则会一直卡在 5。直到 P1 的时间片用完，发生调度，切换 P0 上处理机运行。代码 1 不会卡住 P0，P0 可以正常访问临界区，在 P0 访问临界区期间即时切换回 P1，P1依然会卡在 5。只有 P0 在退出区将 turn 改为 1 后，P1才能进入临界区。缺点：只能按 P0 -〉 P1 -〉 P0 -〉 P1 -〉......这样轮流访问。这种必须“轮流访问”带来的问题是，如果此时允许进入临界区的进程是 P0，而 P0 一直不访问临界区，那么虽然此时临界区空闲，但是并不允许 P1 访问。因此，单标志法存在的主要问题是:违背“空闲让进”原则。「双标志检查法」算法思想:设置一个布尔型数组 flag[]，数组中各个元素用来标记各进程想进入临界区的意愿，比如 “flag[0] = ture”意味着 0 号进程 P0 现在想要进入临界区。每个进程在进入临界区之前先检查当前有没有别的进程想进入临界区，如果没有，则把自身对应的标志 flag[i] 设为 true，之后开始访问临界区。双标志法缺点：若按照 152637....的顺序执行，P0 和 P1 将会同时访问临界区。因此，双标志先检查法的主要问题是:违反“忙则等待”原则。原因在于，进入区的“检查”和“上锁” 两个处理不是一气呵成的。“检查”后，“上锁”前可能发生进程切换。「双标志后检查法」算法思想:双标志先检查法的改版。前一个算法的问题是先“检查”后“上锁”，但是这两个操作又无法一气呵成，因此导致了两个进程同时进入临界区的问题。因此，人们又想到先“上锁”后“检查”的方法，来避免上述问题。双标志后检查法若按照 1526....的顺序执行，P0 和 P1 将都无法进入临界区因此，双标志后检查法虽然解决了“忙则等待”的问题，但是又违背了“空闲让进”和“有限等待” 原则，会因各进程都长期无法访问临界资源而产生“饥饿”现象。两个进程都争着想进入临界区，但是谁也不让谁，最后谁都无法进入临界区。「Peterson 算法」算法思想:结合双标志法、单标志法的思想。如果双方都争着想进入临界区，那可以让进程尝试“孔融让梨”(谦让)。做一个有礼貌的进程。Peterson算法❝谁最后说了“客气话”，谁就失去了行动的优先权。

Eg: 过年了，某阿姨给你发压岁钱。阿姨: 乖，收下阿姨的心意~

你: 不用了阿姨，您的心意我领

阿姨:对阿姨来说你还是个孩子，你就收下吧结局...

❞Peterson 算法用软件方法解决了进程互斥问题，遵循了空闲让进、忙则等待、有限等待三个原则，但是依然未遵循让权等待的原则。Peterson 算法相较于之前三种软件解决方案来说，是最好的，但依然不够好。进程互斥软件实现小结进程互斥的硬件实现-中断屏蔽方法进程互斥的硬件实现方法「中断屏蔽方法」中断屏蔽方法优点:简单、高效缺点:不适用于多处理机;只适用于操作系统内核进程，不适用于用户进程(因为开/关中断指令只能运行在内核态，这组指令如果能让用户随意使用会很危险)进程互斥的硬件实现-TestAndSet指令「TestAndSet指令」简称 TS 指令，也有地方称为 TestAndSetLock 指令，或 TSL 指令 TSL 指令是用硬件实现的，执行的过程不允许被中断，只能一气呵成。以下是用C语言描述的逻辑：TestAndSet指令解释：若刚开始 lock 是 false，则 TSL 返回的 old 值为 false，while 循环条件不满足，直接跳过循环，进入临界区。若刚开始 lock 是 true，则执行 TLS 后 old 返回的值为 true，while 循环条件满足，会一直循环，直到当前访问临界区的进程在退出区进行“解锁”。相比软件实现方法，TSL 指令把“上锁”和“检查”操作用硬件的方式变成了一气呵成的原子操作。优点:实现简单，无需像软件实现方法那样严格检查是否会有逻辑漏洞;适用于多处理机环境缺点:不满足“让权等待”原则，暂时无法进入临界区的进程会占用CPU并循环执行TSL指令，从而导致“忙等”。进程互斥的硬件实现-Swap指令「Swap指令」有的地方也叫 Exchange 指令，或简称 XCHG 指令。Swap 指令是用硬件实现的，执行的过程不允许被中断，只能一气呵成。以下是用C语言述的逻辑：Swap指令逻辑上来看 Swap 和 TSL 并无太大区别，都是先记录下此时临界区是否已经被上锁(记录在 old 变量上)，再将上锁标记 lock 设置为 true，最后检查 old，如果 old 为 false 则说明之前没有别的进程对临界区上锁，则可跳出循环，进入临界区。优点:实现简单，无需像软件实现方法那样严格检查是否会有逻辑漏洞;适用于多处理机环境缺点:不满足“让权等待”原则，暂时无法进入临界区的进程会占用CPU并循环执行TSL指令，从而导致“忙等”。进程互斥的硬件实现JAVA 并发包 CAS 实现「JAVA 并发包CAS实现，对Swap指令的利用」java.util.concurrent.atomic 包下有个原子类 AtomicInteger，其中的 compareAndSet 方法即 CAS。CAS 全称是 compare and swap，是一种用于在多线程环境下实现同步功能的机制。代码如下：public class AtomicInteger extends Number implements java.io.Serializable {

// setup to use Unsafe.compareAndSwapInt for updates

private static final Unsafe unsafe = Unsafe.getUnsafe();

private static final long valueOffset;

static {

try {

// 计算变量 value 在类对象中的偏移

valueOffset = unsafe.objectFieldOffset

(AtomicInteger.class.getDeclaredField("value"));

} catch (Exception ex) { throw new Error(ex); }

}

private volatile int value;

public final boolean compareAndSet(int expect, int update) {

* compareAndSet 实际上只是一个壳子，主要的逻辑封装在 Unsafe 的

* compareAndSwapInt 方法中

return unsafe.compareAndSwapInt(this, valueOffset, expect, update);

}

// ......

}

public final class Unsafe {

// compareAndSwapInt 是 native 类型的方法，继续往下看

public final native boolean compareAndSwapInt(Object o, long offset,

int expected,

int x);

// ......

}

复制在 Java 中，Java 并没有直接实现 CAS，CAS 相关的实现是通过 C++ 内联汇编的形式实现的。Java 代码需通过 JNI 才能调用，compareAndSwapInt 是 native 类型的方法。CAS 底层的实现离不开处理器的支持。C++底层代码，其实核心代码就是一条带 lock 前缀的 cmpxchg 指令，即lock cmpxchg dword ptr [edx], ecx.交换指令：CMPXCHG、XCHGCPMXCHG用于比较并交换操作数，CPU对CAS的原语支持非原子性，最早用于单核CPUXCHG用于交换两个操作数具备原子性，CPU会自动加LOCK前缀LOCK前缀:作用 CPU保证被其修饰的指令的原子性。实现方式依赖内存有序模型，来保证读取指令有序；通过总线锁或缓存一致性，保证被修饰指令操作的数据一致性：当访问的数据在系统内存时，通过在总线锁实现原子性；当访问的数据在处理器的缓存时，通过缓存一致性协议实现原子性；举个栗子:volatile 关键字有两个作用，一个是保证线程可见性，一个是禁止指令重排。Java的DCL中若返回的变量不加volatile修饰，则可能会由于指令重排导致另一个线程获取到一个非完全初始化的对象。当volatile修饰的变量所在的代码段成为热点，被JIT编译为汇编代码后，会增加LOCK前缀来禁止指令重排和来保证数据一致；具体的详细的，可以移步一篇博客文“https://www.cnblogs.com/ITPower/p/13580691.html”信号量机制这个信号量，非常的抽象，他到底是什么？「什么是信号量」❝信号量就是在一个叫做互斥区的门口放一个盒子，盒子里面装着固定数量的小球，每个线程过来的时候，都从盒子里面摸走一个小球，然后去互斥区里面浪，浪开心了出来的时候，再把小球放回盒子里。如果一个线程走过来一摸盒子，得，一个球都没了，不拿球不让进啊，那就只能站在门口等一个线程出来放回来一个球，再进去。这样由于小球的数量是固定的，那么互斥区里面的最大线程数量就是固定的，不会出现一下进去太多线程把互斥区给挤爆了的情况。这是用信号量做并发量限制。

另外一些情况下，小球是一次性的，线程拿走一个进了门，就把小球扔掉了，这样用着用着小球就没了，不过有另外一些线程（一般叫做生产者）会时不时过来往盒子里再放几个球，这样就可以有新的线程（一般叫做消费者）进去了，放一个球进一个线程，这是信号量做同步功能。这种就是生产者消费者模型。

❞信号量其实就是一个变量 (可以是一个整数，也可以是一个结构体)，可以用一个信号量来表示系统中某种资源的数量，比如:系统中只有一台打印机，就可以设置一个初值为 1 的信号量。「信号量实现」我们前面说到进程控制的时候，花了大篇的篇幅来讲原语，信号量机制就是利用了原语操作。前面看进程互斥的软件实现方式的时候，各种的编码方式，各种的名称，其实主要是因为读和写操作不是一个原子操作，即然原语可以保证原子操作，利用在这里再好不过了。一对原语:wait(S) 原语和 signal(S) 原语，可以把原语理解为我们自己写的函数，函数名分别为 wait 和 signal，括号里的信号量 S 其实就是函数调用时传入的一个参数。wait、signal 原语常简称为 P、V操作(来自荷兰语 proberen 和 verhogen)。信号量（Semaphore）也称为信号灯，典故来源于荷兰：火车根据旗标来决定是否通行。其实就是红绿灯的作用。「信号量作用」信号量可以实现进行互斥，进程同步，进程的前驱关系一个信号量对应一种资源信号量的值 = 这种资源的剩余数量(信号量的值如果小于0，说明此时有进程在等待这种资源);P( S ) —— 申请一个资源S，如果资源不够就阻塞等待;V( S ) —— 释放一个资源S，如果有进程在等待该资源，则唤醒一个进程;信号量可以实现进行互斥，进程同步，进程的前驱关系。以实现前驱关系举例：进程 P1 中有句代码 S1，P2 中有句代码 S2 ，P3中有句代码S3 ...... P6 中有句代码 S6。这些代码要求按如下前驱图所示的顺序来执行:信号量控制进程的前驱关系代码实现如下图：信号量控制进程的前驱关系代码实现每个进程都需要申请和释放自己对应的资源。信号量解决生产者-消费者问题信号量解决多生产者-多消费者问题信号量解决哲学家进餐问题信号量解决读者-写这问题管程「为什么要引入管程」信号量机制存在的问题: 编写程序困难、易出错；进程自备同步操作，P(S)和V(S)操作大量分散在各个进程中，不易管理，易发生死锁。.能不能设计一种机制，让程序员写程序时不需要再关注复杂的PV操作，让写代码更轻松呢?1973年，Brinch Hansen 首次在程序设计语言 (Pascal) 中引入了“管程”成分：一种高级同步机制。「管程定义和基本特征」❝引用一段专业书里对管程的介绍:

在利用管程实现进程同步时，当某进程通过管程请求获得临界资源而未能满足时，管程便调用wait原语使该进程等待，并将其排在等待队列上。仅当另一个进程访问完成并释放该资源后，管程才又调用signal原语，唤醒等待队列中的队首进程。但是，考虑这样一种情况：当一个进程调用了管程后，在管程中时被阻塞或挂起，直到阻塞或挂起的原因解除；在此期间，如果该进程不释放管程，则其它进程就无法进入管程，被迫长时间等待。

为了解决这个问题，引入条件变量condition。通常，一个进程被被阻塞或挂起的条件（原因）可有多个，因此在管程中设置了多个条件变量，对这些条件变量的访问智能在管程中进行。

❞❝wiki百科的简单定义:

管程 (英语：Monitors，也称为监视器) 是一种程序结构，结构内的多个子程序（对象或模块）形成的多个工作线程互斥访问共享资源。

这些共享资源一般是硬件或一群变量。管程实现了在一个时间点，最多只有一个线程在执行管程的某个子程序。

与那些通过修改数据结构实现互斥访问的并发程序设计相比，管程实现很大程度上简化了程序设计。

❞管程提供了一种机制，线程可以临时放弃互斥访问，等待某些条件得到满足后，重新获得执行权恢复它的互斥访问。管程(monitor)只是保证了同一时刻只有一个进程在管程内活动,即管程内定义的操作在同一时刻只被一个进程调用(由编译器实现).但是这样并不能保证进程以设计的顺序执行,因此需要设置condition变量,让进入管程而无法继续执行的进程阻塞自己.管程是一种特殊的软件模块，有这些部分组成:局部于管程的共享数据结构说明;对该数据结构进行操作的一组过程;对局部于管程的共享数据设置初始值的语句;管程有一个名字。管程的基本特征:局部于管程的数据只能被局部于管程的过程所访问;一个进程只有通过调用管程内的过程才能进入管程访问共享数据;每次仅允许一个进程在管程内执行某个内部过程。「管程如何解决互斥和同步问题」管程如何解决互斥和同步问题：互斥问题：管程是互斥进入，管程提供了入口等待队列：存储等待进入同步代码块的线程;管程的互斥性是由编译器负责保证的。同步问题:管程中设置条件变量，等待/唤醒操作，以解决同步问题。条件变量（java里理解为锁对象自身）等待操作:可以让进程、线程在条件变量上等待（此时，应先释放管程的使用权，不然别其它线程、进程拿不到使用权）；将线程存储到条件变量的等待队列中。发信号操作:也可以通过发送信号将等待在条件变量上的进程、线程唤醒（将等待队列中的线程唤醒）synchronized 底层原理-管程synchronized是语法糖，会被编译器编译成：1个monitorenter 和 2个monitorexit（一个用于正常退出，一个用于异常退出）。monitorenter 和正常退出的monitorexit中间是synchronized包裹的代码.调用代码java 对象和 monitor 关联图synchronized是重量级锁，存储了是指向monitor的指针。monitor(又称管程)，在Java中是ObjectMonitor(JVM源码中C++实现)来实现管程。synchronized的底层synchronized 内部实现流程：想要获取monitor的线程先进入monitor的_EntryList队列阻塞等待。即遇到synchronized关键字时。如果monitor的_owner为空，则从队列中移出并赋值与_owner。如果在程序里调用了wait()方法，则该线程进入_WaitSet队列。注意wait方法我们之前讲过，它会释放monitor锁，即将_owner赋值为null并进入_WaitSet队列阻塞等待。这时其他在_EntryList中的线程就可以获取锁了。当程序里其他线程调用了notify/notifyAll方法时，就会唤醒_WaitSet中的某个线程，这个线程就会再次尝试获取monitor锁。如果成功，则就会成为monitor的owner。当程序里遇到synchronized关键字的作用范围结束时，就会将monitor的owner设为null，退出。调用的方法自然也是管程提供的方法，如下图：管程提供的方法死锁什么是死锁在并发环境下，各进程因竞争资源而造成的一种互相等待对方手里的资源，导致各进程都阻塞，都无法向前推进的现象，就是“死锁”。发生死锁后若无外力干涉，这些进程都将无法向前推进。死锁、饥饿、死循环的区别死锁、饥饿、死循环的区别死锁产生的必要条件产生死锁必须同时满足一下四个条件，只要其中任一条件不成立，死锁就不会发生。互斥条件:只有对必须互斥使用的资源的争抢才会导致死锁(如哲学家的筷子、打印机设备)。像内存、扬声器这样可以同时让多个进程使用的资源是不会导致死锁的(因为进程不用阻塞等待这种资源)。不剥夺条件:进程所获得的资源在未使用完之前，不能由其他进程强行夺走，只能主动释放。请求和保持条件:进程已经保持了至少一个资源，但又提 3 出了新的资源请求，而该资源又被其他进程占有，此时请求进程被阻塞，但又对自己已有的资源保持不放。循环等待条件:存在一种进程资源的循环等待链，链中的每一个进程已获得的资源同时被下一个进程所请求。死锁的处理策略三个策略：预防死锁。破坏死锁产生的四个必要条件中的一个或几个。避免死锁。用某种方法防止系统进入不安全状态，从而避免死锁(银行家算法)死锁的检测和解除。允许死锁的发生，不过操作系统会负责检测出死锁的发生，然后采取某种措施解除死锁。预防死锁预防死锁用SPOOLing技术将打印机改造为共享设备...打印机-破坏互斥条件核心就是破坏死锁产生的四个必要条件中的一个或几个。避免死锁-银行家算法先看一个借钱的例子：❝你是一位成功的银行家，手里掌握着100个亿的资金...

有三个企业想找你贷款，分别是企业B、企业A、企业T，为述方便，简称BAT。

B 表示:“大哥，我最多会跟你借70亿...”

A 表示:“大哥，我最多会跟你借40亿...”

T 表示:“大哥，我最多会跟你借50亿...”

然而...江湖中有个不成文的规矩:如果你借给企业的钱总数达不到企业提出的最大要求，那么不管你之前给企业借了多少钱，那些钱都拿不回来了...

刚开始，BAT三个企业分别从你这儿借了 20、10、30 亿 ...

❞最开始第二步，假如，再给B借30亿，这样是不安全的...之后手里只剩10亿，如果BAT都提出再借20亿的请求，那么任何一个企业的需求都得不到满足...如下：第二步这样肯定不行，这不是银行家，这是马大哈。「安全序列」这种场景，涉及到一个安全序列。所谓安全序列，就是指如果系统按照这种序列分配资源，则每个进程都能顺利完成。只要能找出一个安全序列，系统就是安全状态。当然，安全序列可能有多个。如下图，借钱就达到了一个安全序列：安全借钱第二步，给A借 20 亿是安全的，因为存在 T-〉B-〉A 这样的安全序列。「银行家算法」银行家算法是荷兰学者 Dijkstra 为银行系统设计的，以确保银行在发放现金贷款时，不会发生不能满足所有客户需要的情况。后来该算法被用在操作系统中，用于避免死锁。核心思想:在进程对资源申请时，先预判此次分配是否会导致系统进入不安全状态。如果会进入不安全状态，就暂时不答应这次请求，让该进程先阻塞等待。BAT 的例子中，只有一种类型的资源——钱，但是在计算机系统中会有多种多样的资源，应该怎么把算法拓展为多种资源的情况呢?举例：可以把单维的数字拓展为多维的向量。比如:系统中有5个进程 P0~P4，3 种资源 R0~R2，初始数量为 (10, 5, 7)，则某一时刻的情况可表示如下:银行家算法此时总共已分配 (7, 2, 5)，还剩余 (3, 3, 2) 可把最大需求、已分配的数据看作矩阵，两矩阵相减，就可算出各进程最多还需要多少资源了。经对比发现，(3, 3, 2)可满足 P1、P3，说明无论如何，这两个进程的资源需求一定是可以依次被满足的，因此P1、P3 一定可以顺利的执行完，并归还资源。可把 P1、P3 先加入安全序列。银行家算法-资源需求(2, 0, 0) + (2, 1, 1) + (3, 3, 2) = (7, 4, 3)，剩下的 P0、P2、P4 都可被满足。同理，这些进程都可以加入安全序列。于是，5个进程全部加入安全序列，说明此时系统处于安全状态，暂不可能发生死锁。银行家算法步骤:检查此次申请是否超过了之前声明的最大需求数检查此时系统剩余的可用资源是否还能满足这次请求试探着分配，更改各数据结构用安全性算法检查此次分配是否会导致系统进入不安全状态安全性算法步骤:检查当前的剩余可用资源是否能满足某个进程的最大需求，如果可以，就把该进程加入安全序列，并把该进程持有的资源全部回收。不断重复上述过程，看最终是否能让所有进程都加入安全序列。死锁的检测和恢复不试图阻止死锁，而是当检测到死锁发生时，采取措施进行恢复。检测为了能对系统是否已发生了死锁进行检测，必须:用某种数据结构来保存资源的请求和分配信息;提供一种算法，利用上述信息来检测系统是否已进入死锁状态。每种类型一个资源的死锁类型上图为资源分配图，其中方框表示资源结点，圆圈表示进程结点，进程结点向资源结点请求资源；资源指向进程表示该资源已经分配给该进程，进程指向资源表示进程请求获取该资源。图 a 可以抽取出环，如图 b，它满足了环路等待条件，因此会发生死锁。每种类型一个资源的死锁检测算法是通过检测有向图是否存在环来实现，从一个节点出发进行深度优先搜索，对访问过的节点进行标记，如果访问了已经标记的节点，就表示有向图存在环，也就是检测到死锁的发生。使用类似于这种的算法来进行检测，当然实际实现还会有比这个更加牛的算法来进行检测。解除解除死锁的主要方法有:资源剥夺法。挂起(暂时放到外存上)某些死锁进程，并抢占它的资源，将这些资源分配给其他的死锁进程。但是应防止被挂起的进程长时间得不到资源而饥饿。撤销进程法(或称终止进程法)。强制撤销部分、甚至全部死锁进程，并剥夺这些进程的资源。这种方式的优点是实现简单，但所付出的代价可能会很大。因为有些进程可能已经运行了很长时间，已经接近结束了，一旦被终止可谓功亏一篑，以后还得从头再来。进程回退法。让一个或多个死锁进程回退到足以避免死锁的地步。这就要求系统要记录进程的历史信息，设置还原点。❝往期推荐：

1.操作系统之内存管理，高能预警！！！

2.操作系统之文件管理，一切皆文件!!!

3.操作系统之进程管理(上)，研究再多高并发，都不如啃一下操作系统进程！！！

❞文章参考：王道老师操作系统先赞后看，养成习惯。有收获的欢迎点赞，分享，在看，喜欢的话可以关注我公主号《小龙飞》，文章首发均在这～～～本文参与腾讯云自媒体分享计划，分享自微信公众号。原始发表：2021-07-15，如有侵权请联系 cloudcommunity@tencent.com 删除数据分析编程算法本文分享自小龙飞微信公众号，前往查看如有侵权，请联系 cloudcommunity@tencent.com 删除。本文参与腾讯云自媒体分享计划，欢迎热爱写作的你一起参与！数据分析编程算法评论登录后参与评论0 条评论热度最新登录后参与评论推荐阅读LV.关注文章0获赞0目录进程同步，进程互斥进程同步进程互斥临界区的互斥访问进程互斥的软件实现方法（很多，可跳过）进程互斥的硬件实现-中断屏蔽方法进程互斥的硬件实现-TestAndSet指令进程互斥的硬件实现-Swap指令JAVA 并发包 CAS 实现信号量机制管程synchronized 底层原理-管程死锁什么是死锁死锁、饥饿、死循环的区别死锁产生的必要条件死锁的处理策略预防死锁避免死锁-银行家算法死锁的检测和恢复领券社区专栏文章阅读清单互动问答技术沙龙技术视频团队主页腾讯云TI平台活动自媒体分享计划邀请作者入驻自荐上首页技术竞赛资源技术周刊社区标签开发者手册开发者实验室关于社区规范免责声明联系我们友情链接腾讯云开发者扫码关注腾讯云开发者领取腾讯云代金券热门产品域名注册云服务器区块链服务消息队列网络加速云数据库域名解析云存储视频直播热门推荐人脸识别腾讯会议企业云CDN加速视频通话图像分析MySQL 数据库SSL 证书语音识别更多推荐数据安全负载均衡短信文字识别云点播商标注册小程序开发网站监控数据迁移Copyright © 2013 - 2024 Tencent Cloud. All Rights Reserved. 腾讯云版权所有深圳市腾讯计算机系统有限公司 ICP备案/许可证号：粤B2-20090059 深公网安备号 44030502008569腾讯云计算（北京）有限责任公司京ICP证150476号 | 京ICP备11018762号 | 京公网安备号11010802020287问题归档专栏文章快讯文章归档关键词归档开发者手册归档开发者手册 Section 归档Copyright © 2013 - 2024 Tencent Cloud.All Rights Reserved. 腾讯云版权所有登录后参与评论00

Follow

imToken安卓版官方网址|swap指令

imToken安卓版官方网址|swap指令

【转载】Linux SWAP 深度解读 - 知乎

操作系统中的Swap指令实现互斥(java实现)-CSDN博客

Linux 中 Swap 交换分区设置教程，以及 Swap 大小与内存的关系 - 知乎

百度知道 - 信息提示

【OS 操作系统】047 | 进程同步与互斥 - 知乎

操作系统原理教程：进程同步与互斥_4在一个系统中有两个过程,p1和p2。它们都需要三种资源,如r1、r2和r3。如果p1-CSDN博客

Linux基础：swap基础知识与常用操作_sysctl -a 2> /dev/null | grep vm.swappiness-CSDN博客

Linux Swap详解 - 钟桂耀 - 博客园

Linux swap命令-CSDN博客

操作系统之进程管理(下)，同步互斥死锁问题，看看操作系统怎么解决的-腾讯云开发者社区-腾讯云

最近的新闻

您可能喜欢的文章

imtoken钱包下载安装版|最小的质数

imtoken网址链接|laugh

数字货币深圳何时落地？

如何使用TP钱包购买TRX，针对新手的详细教程

狗狗币电子钱包攻略

区块链与以太坊钱包的对接方法及步骤

如何解决TP钱包交易所提币不到账问题