标签: Linux系统

linux系统中内存爆满之后会如何?

在使用python写程序的时候,发现一个可以无限迭代的迭代器,从而可以直接将系统中的内存占满,那么占满之后会发生什么呢?

1、 创建无限迭代,生成列表,如下:

  1. [root@python ~]# python
  2. Python 2.7.11 (default, Mar 20 2016, 14:21:08)
  3. [GCC 4.4.6 20110731 (Red Hat 4.4.6-3)] on linux2
  4. Type “help”, “copyright”, “credits” or “license” for more information.
  5. >>> import itertools
  6. >>> r = map(lambda x :x*x,itertools.count(1))

2、监控使用命令vmstat

[root@python ~]# vmstat 1 -S m  #每隔一秒采集一次信息,单位为Mb

3、系统使用情况如下

procs -----------memory---------- ---swap-- -----io---- --system-- -----cpu-----
 r  b   swpd   free   buff  cache   si   so    bi    bo   in   cs us sy id wa st
 1  0      0    851     15     52    0    0     0     0  414   69 34  3 63  0  0	
 1  0      0    610     15     52    0    0     0     0  995    7 83 17  0  0  0	
 1  0      0    458     15     52    0    0     0     0  616   13 70 30  0  0  0	
 1  0      0    345     15     52    0    0     0     0  489    9 70 30  0  0  0	
 1  0      0    187     15     52    0    0     0     0  694   11 77 23  0  0  0	
 3  2     29     50      2     18    0    0   220 41400 1154  190 71 23  0  6  0	
 1  2    238     65      1     13    0    0   580 191392 1232  261 49 25  0 26  0	
 1  2    375     50      0     12    0    0  1720 134264 1360  284 64 25  0 11  0	
 0  3    452     50      0     11    0    0   768 75212  758  150 38 13  0 49  0	
 1  1    528     62      0      9    0    0   192 74668  972  134 52 18  0 30  0	
 1  1    700     50      0      9    0    0     0 167244 1084  150 55 23  0 22  0	
 0  3    767     50      0      9    0    0     0 66068  456   48 17 12  0 71  0	
 1  1    808     60      0      9    0    0  1652 39688  505  191 17  9  0 74  0	
 0  3    952     50      0      7    0    0   504 141228 1078  191 57 20  0 23  0	
 0  2   1068     58      0      7    0    0   288 113176  860  127 40 21  0 40  0	
 2  2   1136     50      0      7    0    0  1584 66656  939  279 46 17  0 37  0	
 0  4   1252     50      0      7    0    0   276 113460  679   90 31 14  0 55  0	
 0  6   1266     53      0      8    0    0   904 13332  267  116  8  4  0 88  0	
 1  0   1339     63      0      7    0    0   216 71196  957  116 43 19  0 38  0	
 0  2   1549     52      0      7    0    0     0 205896 1196  194 49 31  0 20  0	
 1  0   1666     71      0      6    0    0     0 114372  948   57 43 19  0 37  0	
 0  2   1799     51      0      5    0    0     0 130104 1101  214 57 24  0 20  0	
 1  1   1922     61      0      5    0    0     0 119856 1092  132 51 23  0 26  0	
 0  2   2002     50      0      5    0    0     0 77788  662  103 31 17  0 52  0	
 2  0   2093     51      0      5    0    0    32 89104 1054  257 49 25  0 26  0	
 0  2     16    990      0      1    0    0  3824 19836  786 1639 21 17  0 62  0	

从上面可以看出,swap使用的越来越多,free的空间越来越少,到*后达到swap的*大值之后,开始恢复内存空间。

系统的内存如下:

[root@python ~]# free -m
             total       used       free     shared    buffers     cached
Mem:           996         64        932          0          1         10
-/+ buffers/cache:         52        943
Swap:         2015         14       2001

4、 结论

当内存使用太多,没有剩余的内存的时候,操作系统会直接将进程杀死,如下所示:

  1. [root@python ~]# python
  2. Python 2.7.11 (default, Mar 20 2016, 14:21:08)
  3. [GCC 4.4.6 20110731 (Red Hat 4.4.6-3)] on linux2
  4. Type “help”, “copyright”, “credits” or “license” for more information.
  5. >>> import itertools
  6. >>> r = map(lambda x :x*x,itertools.count(1))
  7. Killed

*后一个killed表示杀死进程,开始回收空间。

Linux系统下如何运行.sh文件

在Linux系统下运行.sh文件有两种方法,比如我在root目录下有个datelog.sh文件

*种(这种办法需要用chmod使得文件具备执行条件(x): chmod u+x datelog.sh):

1、在任何路径下,输入该文件的*对路径/root/datelog.sh就可执行该文件(当然要在权限允许情况下)

%title插图%num

2、cd到datelog.sh文件的目录下,然后执行./datelog.sh

%title插图%num

第二种(这种办法不需要文件具备可执行的权限也可运行):

1、在该文件路径下sh加上文件名字即可,sh datelog.sh

%title插图%num

2、在任意路径下,sh 加上文件路径及文件名称:sh /root/ datelog.sh

%title插图%num

三大操作系统比较,为什么开发要用Linux系统?

交流学习java大数据加QQ群460570824.

windows, macOS,linux是当今主流三大操作系统,普通用户一般是选择windows或macOS, linux主要是占据服务器领域市场。这三个操作系统给人的感觉是:windows经济适用,档次较低; macOS高端大气上档次; Linux是*客专用,一个黑乎乎的窗口,各种花花绿绿的指令在闪烁,对着键盘噼里啪啦一通乱敲,就能窃取各种机密…

普通用户对于操作系统的选择很简单,经济实用选windows,钱多讲究格调选macOS, 毕竟普通用户切换操作系统的成本并不大。而程序员就不一样了,换一个操作系统,就意味着所有开发环境都要一并更换。而且在程序员群体中,操作系统有以下的鄙视链:macOS–>linux–>windows。

其实操作系统的比较并不是简单粗暴的单一维度比较,用windows并不意味着low,用linux也不等同于你就是一个*客。关键在于你是如何使用。就好比编程语言的选择,php是*招人黑的语言(没有之一), 但黑php的人中有不少人写的代码同样不堪入目。

不过作为一个程序员,你很有必要学会linux,如果你的程序*终是跑在线上的Linux服务器上,那么你就更应该从现在开始投入linux的怀抱中,早日从windows脱坑。至于macOS,在命令行上与linux*大部分相同,都是类unix的操作系统。简单地说,macOS是一个比windows界面更加美观,同时又兼备linux强大命令行的操作系统. 要说macOS的缺点,那就是贵…

windows与linux的根本区别:自由
%title插图%num

windows与linux的设计理念有根本性的区别:

windows:用户不知道自己想要什么,也不明白自己在做什么,更不打算为自己的行为负责。

因此windows将所有操作都隐藏起来,只给用户提供封装好的功能,用户只能在操作系统限制的范围内操作,如果是普通用户,会觉得很windows很舒服,因为不需要思考。只需要按照指示去操作。但对于开发人员而言,这种设计理念是无法接受的,一旦要做出一些超越封装好的功能之外的事情,就会出现各种难以意料的情况,而且很多情况下,这些问题是无解的。或者只能用*其蹩脚扭曲的方式去勉强处理,然后瑟瑟发抖地期待着程序能正常运行。因为一旦程序崩溃,你也会为之崩溃。在windows下作开发,那种体验就好比在陪伴一个任性的女朋友,虽然长得清秀靓丽,但喜怒无常,她开心时,彼此相安无事,她不开心时,就直接哭闹,你问她:怎么了?她也不说原因,只是一直哭。你只能试着用各种方式去哄她开心,即使这次能哄好她,并不意味着下次同样的方法能奏效。这样的相处方式,很累。不是她不好,而是彼此不适合。即使终日相伴,却依然对其一无所知。

linux:用户知道自己想要什么,也明白自己在做什么,并且会为自己的行为负责。

linux将所有操作权都交给了用户,她相信用户是理性的聪明的,忠实地执行用户的指令,向用户暴露所有的细节。用户在拥有自主权的同时也拥有了破坏力,因此普通用户根本无法驾驭,可能一个指令就把操作系统弄崩溃了。对于开发者而言,linux的开放与自由给了我们无限的可能性,我们能看到程序是如何运行的,运行报错也会有友好的提示。根据报错指引往往能将问题解决。与之相处,好比与一个成熟的女性相处,历经风雨,已经不再关注浮夸的外表,而是关注内在的涵养。刚接触时,可能会觉得她高冷,慢慢地,会发现她很善解人意,心情不好时她会跟你说是什么原因造成的,彼此商量如何解决这个问题,而不是无来由地崩溃。与之相处,会感到很舒服,彼此坦诚,无需套路,你在想什么,我都知道。我在念什么,你也明白。

因此,我选择linux的原因在于自由、舒服,简言之:爽!

至于win10自带的WSL(linux子系统), 说起来都是泪,几个月前,我兴冲冲地折腾,以为windows可以完美地支持linux,结果,连个nginx都跑不起来,去wsl的github源码查看issue,才知道这就是wsl的一个bug!此外,还有其他各种坑,这感觉就像:分手后的任性前女友画风突变:善解人意,人情练达。你欣喜万分地准备复合,她马上又原形毕露。咱能不能多些真诚,少些套路…

迅哥说过:生命是以时间为单位的,浪费别人的时间等于谋财害命,浪费自己的时间等于慢性自杀。对于程序员而言,开发环境远离windows,就是珍惜生命的表现(开发windows程序的除外)

选择哪个发行版的linux

redhat,suse, Debian等各个发行版的linux都有各自的忠实拥护者,无法判断这些发行版孰优孰劣,毕竟“存在即合理”。我从实用的角度来看,选择的是redhat(红帽)系列的centos。

因为线上的服务器大多数是ceotos,我们的程序*终是在线上运行的,如果能将本地环境配置得跟线上一致,就可以减少很多莫名其妙的环境问题。而且熟悉使用centos,基础的运维能力也都掌握了

至于版本选择,肯定是要选择*新的centos7, centos7与centos6存在很多差异,性能有很大的提升

如何学linux

工作中,看到不少工作好几年的程序员,在操作linux时特别生疏,只会*基本的几个命令:cdls mkdir 等。vim编辑器的操作更是让人看了很着急,被誉为编辑器之神的vim在他们手中,完全没有半点灵气,感觉就像是编辑器之屎。

之所以会出现这种现象,很大原因在于他们的学习方式错了,不少人都知道linux很重要,不掌握linux,基本上就只能停留在*基本的增删改查功能上。他们学linux的方式可能是看书,也可能是看视频,甚至有些还会去背命令,但由于他们的操作环境是windows,linux的应用场景很少。根本没办法将所学的知识运用,更加感受不到linux的魅力。

学linux*好地方式,就是直接去用!直接将自己的开发环境都改成linux,一开始很蹩脚,很不适应,这很正常。如果你一直感到很舒服,只能说明你一直没有进步。想想我们学了那么多年英语,*大多数人还是无法掌握英语,看到英语文档就直接自动屏蔽。其原因都是:一直在学,但从来没在用。只学而不用,没有半点用。

 

什么时候用linux系统多

什么时候用linux系统多【199cloud-艾娜】

kvm

Kernel-based Virtual Machine的简称,是基于内核的开源虚拟化,在Linux2.6.20之后集成在各个主要的发行版本。KVM的虚拟化需要硬件支持(如Intel VT技术或者AMD V技术)。是基于硬件的完全虚拟化。在2008年的时候,红帽发言人表示,KVM相比Xen有着更好的可管理性以及更高的性能。因此RHEL6以及之后的版本,默认支持KVM,而放弃了Xen。

Xen

Xen 是一个开放源代码虚拟机监视器,由剑桥大学开发。Xen通过一种叫做半虚拟化的技术获得高效能的表现(较少的效能损失, 典型的情况下大约损失 2%, 在*糟的情况下会有 8% 的效能耗损; 与其它使用完全的虚拟化却造成*高到 20% 损耗的其他解决方案形成一个明显的对比),甚至在某些与传统虚拟技术*度不友好的架构上(x86),Xen也有*佳的表现。但是Xen的操作比较复杂,维护成本比较高。不支持windows虚拟机。

VirtualBox

VirtualBox 是一款开源虚拟机软件。VirtualBox 是由德国 Innotek 公司开发,由Sun Microsystems公司出品的软件,使用Qt编写,在 Sun 被 Oracle 收购后正式更名成 Oracle VM VirtualBox。VirtualBox号称是*强的免费虚拟机软件,它不仅具有丰富的特色,而且性能也很优异!VirtualBox 是由 qemu 改写而成,包含大量 qemu 代码。可以使用于不支持虚拟化的cpu。值得说的一点:VirtualBox 在图形方面比较好,能进行2D 3D加速。操作上有独立的图形界面,易于上手。但对CPU的控制不是很好,比较适合有桌面需要的虚拟机。

VMware Workstation

VMware Workstation 是一款功能强大的桌面虚拟计算机软件,提供用户可在单一的桌面上同时运行不同的操作系统,和进行开发、测试 、部署新的应用程序的*佳解决方案。

嵌入式系统的内存管理

嵌入式系统的内存管理

摘要:实时性、可靠性的要求,使得许多嵌入式应用使用自己的内存管理程序。本文探讨嵌入式系统中对内存管理的要求、存在的问题以及可能的解决策略;介绍一种“一次分配,多次使用”的动态内存分配方法,并给出2个例子。
关键词:嵌入式系统 内存管理 一次分配多次使用
1 嵌入式系统中对内存分配的要求
①快速性。嵌入式系统中对实时性的保证,要求内存分配过程要尽可能地快。因此在嵌入式系统中,不可能采用通用操作系统中复杂而完善的内存分配策略,一般都采用简单、快速的内存分配方案。当然,对实性要求的程序不同,分配方案也有所不同。例如,VxWorks采用简单的*先匹配如立即聚合方法;VRTX中采用多个固定尺寸的binning方案。
②可靠性。也就是内存分配的请求必须得到满足,如果分配失败可能会带来灾难性的后果。嵌入式系统应用的环境千变万化,其中有一些是对可靠性要求*高的。比如,汽车的自动驾驶系统中,系统检测到即将撞车,如果因为内存分配失败而不能相应的操作,就会发生车毁人亡的事故,这是不能容忍的。
③高效性。内存分配要尽可能地少浪费。不可能为了保证满足所有的内存分配请求而将内存配置得无限大。一方面,嵌入式系统对成本的要求使得内存在其中只是一种很有限的资源;另一方面,即使不考虑成本的因素,系统有限的空间和有限的板面积决定了可配置的内存容量是很限的。
2 静态分配与动态分配 究竟应用使用静态分配还是动态分配,一直是嵌入式系统设计中一个争论不休的总是。当然,*合适的答案是对于不同的系统采用不同的方案。如果是系统对于实时性和可靠性的要求*高(硬实时系统),不能容忍一点延时或者一次分配失败,当然需要采用静态分配方案,也就是在程序编译时所需要的内存都已经分配好了。例如,火星探测器上面的嵌入式系统就必须采用静态分配的方案。另外,WindRiver公司的一款专门用于汽车电子和工业自动化领域的实时操作系统OSEKWorks中就不支持内存的动态分配。在这样的应用场合,成本不支持内存的动态分配。在这样的应用场合,成本不是优先考虑的对象,实时性和可靠性才是必须保证的。当然,采用静态分配一个不可避免的总是就是系统失去了灵活性,必须在设计阶段就预先知道所需要的内存并对之作出分配;必须在设计阶段就预先考虑到所有可能的情况,因为一旦出现没有考虑到的情况,系统就无法处理。这样的分配方案必须导致很大的浪费,因为内存分配必须按照*坏情况进行*大的配置,而实际上在运行中可能使用的只是其中的一小部分;而且在硬件平台不变的情况下,不可能灵活地为系统添加功能,从而使得系统的升级变得困难。 大多数的系统是硬实时系统和软实时系统的综合。也就是说,系统中的一部分任务有严格的时限要求,而另一部分只是要求完成得越快越好。按照RMS(Rate Monotoin Scheduling)理论,这样的系统必须采用抢先式任务调度;而在这样的系统中,就可以采用动态内存分配来满足那一部分可靠性和实时性要求不那么高的任务。采用动态内存分配的好处就是给设计者很大的灵活性,可以方便地将原来运行于非嵌入式操作系统的程序移植到嵌入式系统中,比如,许多嵌入式系统中使用的网络协议栈。如果必须采用静态内存分配,移植这样的协议栈就会困难得多。另外,采用动态内存分配可以使设计者在不改变基本的硬件平台的情况下,比较灵活地调整系统的功能,在系统中各个功能之间作出权衡。例如,可以在支持的VLAN数和支持的路由条目数之间作出调整,或者不同的版本支持不同的协议。说到底,动态内存分配给了嵌入式系统的程序设计者在比较少的限制和较大的自由。因此,大多数实时操作系统提供了动态内存分配接口,例如malloc和free函数。
3 RTOS提供的内存分配接口 不同的RTOS由于其不同的定位,采用不同的内存分配策略。
例如VRTX中,采用类似于GNU C中由Doug Lea开发的内存分配方案,即Binning算法,系统内存被分成了一些固定尺寸的内存块的算法,系统内存被分成了一些固定尺寸的内存块的集合。这种方法的优点是查找速度快而且不会产生内存碎片。但是,它的缺点也很明显,就是容易造成浪费,因为内存块的尺寸只有有限个,分配时只能取较大的内存块来满足一个较小的需求,累积起来,浪费就很大了;而且操作系统管理这样一个内存分配表也是一个很大的负担。 下面详细介绍一下我们常用的RTOS——美国风河公司(WindRiver)的VxWorks中采用的内存分配策略。VxWorks的前身就是VRTX,据说VxWorks的名称来自make vrtx work。 VxWorks的内存管理函数存在于2个库中;memPartLib(紧凑的内存分区管理器)和memLib(完整的内存分区管理器)。前者(memPartLib)提供的工具用于从内存分区中分配内存块。该库包含两类程序,一类是通用工具创建和管理内存分区并从这些分区中分配和管理内存块;另一类是标准的malloc/free程序提供与内存分区的接口。系统内存分区(其ID为memSysPartId是一个全局变量)在内核初始化时由usrRoot调用memInit创建。其开始地址为RAM中紧接着VxWorks的BSS段之后,大小为所有空闲内存,如图1所示。 当创建其它分区时,一般需要先调用malloc从系统内存分区中分配一段内存才能创建。内存分区的结构定义为mem_part,包含1个对象标记,1个双向链表管理空闲块,1个信号量保护该分区及一些统计信息,如总尺寸、*大块尺寸、调试选项、已分配的块数、已分配的尺寸等。其语句如下:
typedef struct mem_part
{ OBJ_CORE objCore; /*对象标志*/
DL-LIST freeList; /*空闲链表*/
SEMAPHORE sem; /*保护分区的信号量*/
Unsigned totalWords; /*分区中字(WORD)数*/
Unsigned minBlockWords; /*以字为单位的*小块尺寸*/
Unsigned options; /*选项,用于调试或统计*/ /*分配统计*/
unsigned curBlocksAllocated; /*当前分配的块数*/
unsigned curWorkdAllocated; /*当前分配的字数*/
unsigned cumBlockAllocated; /*累积分配的块数*/
unsigned cumWordsAllocated; /*累积分配的字数*/
}PARTITION;
一般系统中只有1个内存分区,即系统分区,所有任务所需要的内存直接调用malloc从其中分配。分配采用First-Fit算法(注意这种算法容易导致大量碎片),通过free释放的内存将被聚合以形成更大的空闲块。这就是VxWorks的内存分配机理。分配时可以要求一定的对齐格式。注意,不同的CPU架构有不同的对齐要求。为了优化性能,malloc返回的指针是经过对齐的,为此的开销随构不同而不同。例如,68K为4字节对齐,开销8字节;SPARC为8字节对齐,开销12字节;MIPS为16字节对齐,开销12字节;I960为16字节对齐,开销16字节。 MemLib库中提供了增强的内存分区管理工具,并且增加了一些接口,而且可以设置调试选项。可以检测2类错误:①尝试分配太大的内存;②释放内存时发现坏块。有4种错误处理选项,当发生错误时记录消息或挂起任务。 但是,使用动态内存分配malloc/free时要注意到以下几方面的限制。①因为系统内存分区是一种临界资源,由信号量保护,使用malloc会导致当前调用挂起,因此它不能用于中断服务程序;②因为进行内存分配需要执行查找算法,其执行时间与系统当前的内存使用情况相关,是不确定的,因此对于有规定时限的操作它是不适宜的;③由于采用简单的*先匹配算法,容易导致系统中存在大量的内存碎片,降低内存使用效率和系统性能。 针对这种情况,一般在系统设计时采用静态分配与动态分配相结合的方法。也就是对于重要的应用,在系统初始化时分配好所需要的内存。在系统运行过程中不再进行内存的分配/释放,这样就避免了因内存的分配释放带来的总是。而且在系统初始化,因为没有内存碎片,对于大的内存块的需求容易满足。对于其它的应用,在运行时进行动态内存分配。尤其是某些应用所要求的大量固定尺寸的小内存块,这时就可以采用一次分配多次使用的内存分配方案。下面详细介绍这种内存分配方案及其应用场合。
4 一次分配多次使用的内存分配方案 在嵌入式系统设计中,经常有一些类似于内存数据库的应用。这些应用的特点是在内存中管理一些树,比如以太网交换机中的MAC地址表、VLAN表等,或者路由器中的路由表。这些树是由许多相同尺寸的节点组成的。这样,就可以每次分配一个大的缓冲池,比如包含多个内存单元的数组,每个内存单元用于1个节点。我们用一个空闲链表来管理该数组中的空闲内存单元。每次程序需要分配内存以创建1个新的节点时,就从空闲链表中取1个单元给调用者。程序删除节点并释放内存时,将释放的内存单元返还给空闲链表。如果链表中的空闲内存单元取空了,就再次调用malloc从系统内存中分配一个大的内存块作为新的缓冲池。采用这样一种方案主要有如下优点:①减少了malloc/free的调用次数,从而降低了风险,减少了碎片;②因为从缓冲池中取一个内存单元是时间确定的(当然,如果缓冲池耗尽从而需要重新调用malloc分配除外),因此它可以用于严格时限的场合从而保证实时性;③它给用户以自由来添加一些用于内存分配和释放的调试函数以及一些统计功能,更好地监测系统中内存的使用情况。 这种方案必然涉及到一个缓冲池的结构。一般缓冲池的结构由以下几部分组成:单元尺寸、块尺寸(或者单元数目)、缓冲池指针、空闲链表、用于统计和调试的参数等。对缓冲池的操作包括创建缓冲池、释放缓冲池、从缓冲池中分配1个内存单元、释放内存单元回缓冲池等。下面举2个例子说明一下该方案的具体使用情况。
4.1 Intel交换机驱动程序中内存分配 在以Intel的交换芯片为基础的交换机方案中,因为采用的是软件地址学习的方式,需要在内存中维护许多数据,如MAC地址表的软拷贝、VLAN表、静态单播地址表、组播地址表等。这些表都是由一些树组成,每个树由一些固定尺寸的节点组成。一般每个节点几十个字节,每棵树的节点数是可增长的,少则几十,*多可到16K个节点。因此,很适合于采用该方案,具体的实现如下:
(1)缓冲池结构BlockMemMgr typedef struct{ MemSize data_cell_size; /*数据单元的尺寸*/ MemSize block_size; /*块尺寸*/ /*下面的变量为预定义的每个管理器*多包含的块数,如64 MAX_BLOCKS_OF_MEM_SIZE*/ Unsigned short blocks_being_used;/*已使用的块数*/ Void mem_ptr[PAX_BLOCKS_OF_MEM_SIZE]; /*块数组*/ SLList free_data_cells_list; /*空闲链表*/ }BlockMemMgr; 结构中的参数包括:单元尺寸、块尺寸、已用块数、所有块的地址、空闲链表(单向链表)。
(2)缓冲池的管理函数
◆block_mem_create:创建块内存管理器,参数包括内存指针(如为NULL,表示自己分配)、块尺寸、单元尺寸、返回管理器指针。 过程如下: ①检验参数合法性。 ②单元尺寸4字节对齐,计算每个块中的单元数。对内存指针进行4字节对齐或者分配内存指针。 ③初始化结构BlockMemMgr,包括单元尺寸和块尺寸。设置第1个内存块的指针。如果内存是外来的,设置块已用标志(已用为0),表示不能增加块;否则,已用块数设为1。 ④创建空闲链表,将块内所有单元添加到链表中,*后一个单元处于链表的*前面。 ⑤返回BlockMemMgr。
◆block_mem_destroy:解构一个块内存管理器,释放它所分配的所有内存,调用者负责外部内存的释放。参数为BlockMemMgr。返回成功失败标志。 ①参数合法性检测。 ②删除单向链表(设链表指针为NULL)。 ③如果块是动态分配的,释放它们。 ④释放结构BlockMemMgr。
◆block_malloc:从块内存管理器中分配1个单元。参数为BlockMemMgr,返回数据单元指针。 ①参数合法性检测。 ②判断空闲链表是否为空(是否为NULL)。如果为空,判断是否可以动态分配块,如果不能,返回失败;如果可以动态分配块,则分配1个块,执行与block_mem_create一样的操作。 ③从空闲链表中分配第1个单元,返回其指针。 注意这里有一个小技巧,即数据单元在空闲时其中存放空闲链表的节点信息,而分配后则存放数据内容。
◆block_free:释放1个数据单元,返回块内存管理器。小心不要对1个单元释放2次。参数为BlockMemMgr和单元指针。 ①参数合法性检测。 ②地址比较,判断数据单元属于哪个块。 ③判断数据单元的内容是否为空闲链表节点信息(也就是块内某单元的地址),从而确定是否为2次释放。 ④将该数据单元插入到空闲链表的前面。 ⑤引用该单元的指针设为NULL。
内存管理代码遵守如下约定:①管理的内存是实际可写的内存;②分配内存是4字节或32位对齐;③block_malloc、block_free在中断级调用是部分安全的,除非BLOCK中已经没有空闲CELL,需要重新调用malloc分配新的BLOCK(而malloc和free就不是安全的,因为其中使用了信号量和搜索算法,容易引起中断服务程序阻塞)。当然,block_mem_create和block_mem_destroy必须在进程级调用。 4.2 TMS中的内存分配 TMS是WindRiver公司为可管理式交换机推出的开发包。它用用IDB来管理各种协议的数据,比如STP和GVRP等。为了支持IDB,它建立了自己的缓冲池管理方案,程序在bufPoolLib.c中。该程序包含用于缓冲池管理的函数,这些函数允许从1个池中分配固定数目和大小的缓冲区。通过预先分配一定数目固定大小的缓冲区,避免了反复的小的内存块分配/释放相关联的内存碎片和浪费。既然它从1个单一的块中分配缓冲池,也比对每一个缓冲区执行1次分配有更高的空间效率。模块对每个缓冲区加上1个标记(MAGIC),释放时会检查标记。模块给用户提供分配和释放操作定义回调函数的能力。这样可以做到自动的对象创建和解构,同时允许由多个缓冲池分配的成员组成的对象做为1个单一的实体删除。这类似于C++中自动的对象构建和解构,不过是用C语言并且没有堆栈分配的负担。模块既允许从堆栈中分配缓冲池(通过calloc),也可以在用户分配的空间中创建它们。模块用1个单向链表来维护未分配的缓冲区,但不跟踪已分配的缓冲区。模块并不是任务安全的,用户需要用信号时来保护缓冲池。
(1)缓冲池结构
typedef struct
{ ulong_t magic; /*用于一致性检测的特殊标记*/
Boolean localAlloc; /*内存是否在创建缓冲区时分配*/
SL_LIST freeList; /*空闲链表*/
Void store; /*缓冲区指向的内存指针*/
STATUS(*createFn)(void*,ulong_t argl); /*创建缓冲区时的回调函数指针*/
STATUS(*destroyFn)(void*,ulong_targl);/*释放缓冲区时的回调函数指针*/
Ulong_t argVal;/*回调函数的参数*/
} buf_pool_t;
结构中的参数包括检查标记MAGIC、是否本地分配、空闲链表、内存指针、创建缓冲池的回调函数指针、释放时的回调函数指针、回调函数参数。
(2)相关函数
◆BufPoolInitializeStorage:分配和初始化存储区。参数包括存储区地址(如为NULL,则本地分配)、缓冲区大小、缓冲区个数。 ①根据缓冲区大小和个数获得所需的内存大小。 ②如果指针为NULL,则调用calloc分配内存。设置本地分配标志。 ③初始化内存为0。 ④初始化指针。分配的内存块*前面为缓冲池结构buf_pool_t。实际的存储区紧随其后。Buf_pool_t包含参数检查标记、是否本地分配、存储区地址、分配时回调函数、释放时回调函数、回调函数变量。此时只设置存储区指针。
◆BufPoolCreate:创建缓冲池。参数为内存制止。缓冲区尺寸和个数,创建时回调函数、释放时回调函数、回调函数参数。 ①尺寸对齐。 ②调用bufPoolInitializeStorage初始化内存区和buf_pool_t结构。 ③用传入参数填充buf_pool_t结构。 ④将缓冲区添加到空闲链表中,*后的缓冲区在*前面。
◆BufPoolDestroy:删除缓冲池。参数为buf_pool_t指针。 ①检查缓冲池结构中的MAGIC字段是否被个性。 ②如果是本地分配的则翻放内存区。
◆BufPoolAlloc:从缓冲池中分配一个缓冲区,参数为缓冲池结构指针。如果存在空闲缓冲区,则从空闲链表中除并提供给调用者,执行创建时回调函数。如果回调函数返回错误,则将缓冲区返还给空闲链表。 ①检查缓冲池结构中的MAGIC标记是否完好。 ②从空闲链表中取出头一个节点。 ③如果节点不为空,清空节点,以其地址为参数调用回调函数。 ④如果回调函数返回错误,则将节点还给空闲链表。 ⑤返回得到空闲缓冲区地址。
◆BufPoolFree:将缓冲区返回给缓冲池。如果定义了回调函数,将在归还缓冲之间调用回调函数。参数为缓冲池结构和缓冲区指针。 ①缓冲池MAGIC标记是否完好。 ②如果定义回调函数、调用之。如果返回错误,则设置错误号。 ③将缓冲区添加到空闲链表中头部。 注意该函数有2点:①回调函数返回错误,照样归还缓冲区。②没有检查缓冲区是否二次释放,这一点与Intel的驱动程序不同。 另外,TMS的缓冲池没有BLOCK要领,不需要判断哪个CELL属于哪个BLOCK,简化 了操作。 5 小结 许多嵌入式应用在RTOS提供的malloc/free的基础上编写自己的内存管理方案。编写这样的内存管理方案,目的无非有两个:一是减少对malloc/free的依赖,从而避免由之带来的内存碎片、时间不确定等总是;另一个是增强程序的查错能力,送还内存使用错误。对于在嵌入式系统中广泛存在的数据库类型的内存需求,即分配多个固定尺寸的内存单元的要求,“一闪分配,多次使用”的方案无疑是一种很好的解决之道。文中介绍的2个例子很好地体现了它的优越性。

把windows里面的文件复制到linux系统中

把windows里面的文件复制到linux系统中

方法一:

(1)安装lrzsz的包:

<span style=”font-size:14px;”>yum install lrzsz</span>
(2)登录到Linux系统,执行“rz”命令进行上传文件;执行“sz 文件名”命令进行下载。

方法二:
使用Xshell登录系统,然后进入要上传文件的目录下,点击Xshell提供的工具(Ctrl+Alt+F)。
%title插图%num

linux系统访问NAS网络存储

测试环境:

(1)     公司内部一台NAS存储,共享存储目录share 共享,访问路径为 \\10.1.7.29

(2)Window 8测试如下图

174804_GBR8_997894.png

然后在其share共享目录创建一个测试目录aa并上传多个测试文件,E如下图所示1;2:

174957_Hgcj_997894.jpg

175146_CkhH_997894.png

Linux(Redhat5.7)系统访问NAS存储中的共享目录:

(1)     安装相关服务samba(smb)使用下面命令:

yum  install  samba*     (yum配置可用)

(2)     通过命令可以查看当前网络共享主机

Smbclient  –L  主机名(或主机ip地址) ,看到共享服务器中德共享目录

命令输入如下图:

175253_6hPY_997894.jpg

(3)     使用命令行模式查看共享目录中有那些文件,如下图

175359_Xu6H_997894.jpg

(4)     使用命令将共享服务器映射到Linux系统主机,命令如下

mount  //主机名(或服务器Ip地址)/共享目录  /挂载目录/   (备注:相当于映射网络驱动,可设置每次重启自动挂载)。

mount //10.1.7.29/share  /mnt/NASshare/

175452_uQwh_997894.png

(5)     然后就可以当相应挂载点/mnt/NASshare/目录下看到共享服务器share共享目录中的aa文件目录,点击目录就可看到目录中的文件,如下图所示:

175606_0atU_997894.jpg

如需要打开相应的办公文件知道Linux主机中有相应的应用程序即可。

Linux系统打开Pdf文档如图所示:

175706_2Tm5_997894.png

Linux系统中Raid完全攻略

RAID 0

RAID 0 也叫 Stripe 或 Striping(带区卷),是 RAID 级别中存储性能*好的一个。RAID 0 *好由相同容量的两块或两块以上的硬盘组成。如果组成 RAID 0 的两块硬盘大小不一致,则会影响 RAID 0 的性能。

这种模式下会先把硬盘分隔出大小相等的区块,当有数据需要写入硬盘时,会把数据也切割成相同大小的区块,然后分别写入各块硬盘。这样就相当于把一个文件分成几个部分同时向不同的硬盘中写入,数据的读/写速度当然就会非常快。

从理论上讲,由几块硬盘组成 RAID 0,比如由 3 块硬盘组成 RAID 0,数据的写入速度就是同样的数据向一块硬盘中写入速度的3倍。我们画一张 RAID 0 的示意图,如图 1 所示。

%title插图%num
图 1 RAID 图

解释一下这张示意图。我们准备了 3 块硬盘组成了 RAID 0,每块硬盘都划分了相等的区块。当有数据要写入 RAID 0 时,首先把数据按照区块大小进行分割,然后再把数据依次写入不同的硬盘。每块硬盘负责的数据写入量都是整体数据的 1/3,当然写入时间也只有原始时间的 1/3。所以,从理论上讲,由几块硬盘组成 RAID 0,数据的写入速度就是数据只写入一块硬盘速度的几倍。

RAID 0 的优点如下:

  • 通过把多块硬盘合并成一块大的逻辑硬盘,实现了数据跨硬盘存储。
  • 通过把数据分割成等大小的区块,分别存入不同的硬盘,加快了数据的读写速度。数据的读/写性能是几种 RAID 中*好的。
  • 多块硬盘合并成 RAID 0,几块小硬盘组成了更大容量的硬盘,而且没有容量损失。RAID 0 的总容量就是几块硬盘的容量之和。

RAID 0 有一个明显的缺点,那就是没有数据冗余功能,RAID 0 中的任何一块硬盘损坏,RAID 0 中所有的数据都将丟失。也就是说,由几块硬盘组成 RAID 0,数据的损毁概率就是只写入一块硬盘的几倍。

我们刚刚说了,组成 RAID 0 的硬盘的大小*好都是一样的。那有人说我只有两块不一样大小的硬盘,难道就不能组成 RAID 0 吗?

答案是可以的。假设有两块硬盘,一块大小是 100GB,另一块大小是 200GB。由这两块硬盘组成 RAID 0,那么当*初的 200G 数据写入时,是分别存放在两块硬盘当中的;但是当数据大于 200GB 之后,*块硬盘就写满了,以后的数据就只能写入第二块硬盘中,读/写性能也就随之下降了。

一般不建议企业用户使用 RAID 0,因为数据损毁的概率更高。如果对数据的读/写性能要求非常高,但对数据安全要求不高时,RAID 0 就非常合适了。

RAID 1

RAID 1也叫 Mirror 或 Mirroring(镜像卷),由两块硬盘组成。两块硬盘的大小*好一致,否则总容量以容量小的那块硬盘为主。RAID 1 就具备了数据冗余功能,因为这种模式是把同一份数据同时写入两块硬盘。

比如有两块硬盘,组成了 RAID 1,当有数据写入时,相同的数据既写入硬盘 1,也写入硬盘 2。这样相当于给数据做了备份,所以任何一块硬盘损坏,数据都可以在另一块硬盘中找回。RAID 1 的示意图如图 2 所示。

%title插图%num
图 2 RAID 1示意图

RAID 1 具有了数据冗余功能,但是硬盘的容量却减少了 50%,因为两块硬盘当中保存的数据是一样的,所以两块硬盘际上只保存了一块硬盘那么多的数据,这也是我们把 RAID 1 称作镜像卷的原因。

RAID 1 的优点如下:

  • 具备了数据冗余功能,任何一块硬盘出现故障,数据都不会丟失。
  • 数据的读取性能虽然不如RAID 0,但是比单一硬盘要好,因为数据有两份备份在不同的硬盘上,当多个进程读取同一数据时,RAID会自动分配读取进程。

RAID 1 的缺点也同样明显:

  • RAID 1 的容量只有两块硬盘容量的 50%,因为每块硬盘中保存的数据都一样。
  • 数据写入性能较差,因为相同的数据会写入两块硬盘当中,相当于写入数据的总容量变大了。虽然 CPU 的速度足够快,但是负责数据写入的芯片只有一个。

RAID 10 或 RAID 01

我们发现,RAID 0 虽然数据读/写性能非常好,但是没有数据冗余功能;而 RAID 1 虽然具有了数据冗余功能,但是数据写入速度实在是太慢了(尤其是软 RAID)。

那么,我们能不能把 RAID 0 和 RAID 1 组合起来使用?当然可以,这样我们就即拥有了 RAID 0 的性能,又拥有了 RAID 1 的数据冗余功能。

我们先用两块硬盘组成 RAID 1,再用两块硬盘组成另一个 RAID 1,*后把这两个 RAID 1组成 RAID 0,这种 RAID 方法称作 RAID 10。那先组成 RAID 0,再组成 RAID 1 的方法我们作 RAID 01。我们通过示意图 3 来看看 RAID 10。

%title插图%num
图 3 RAID 10示意图

我们把硬盘 1 和硬盘 2 组成了*个 RAID 1,把硬盘 3 和硬盘 4 组成了第二个 RAID 1,这两个 RAID 1组成了 RAID 0。因为先组成 RAID 1,再组成 RAID 0,所以这个 RAID 是 RAID 10。

当有数据写入时,首先写入的是 RAID 0(RAID 0 后组成,所以数据先写入),所以数据 1 和数据 3 写入了*个 RAID 1,而数据 2 和数据 4 写入了第二个 RAID 1。当数据 1 和数据 3 写入*个 RAID 1 时,

因为写入的是 RAID 1,所以在硬盘 1 和硬盘 2 中各写入了一份。数据 2 和数据 4 也一样。

这样的组成方式,既有了 RAID 0 的性能优点,也有了 RAID 1 的数据冗余优点。但是大家要注意,虽然我们有了 4 块硬盘,但是由于 RAID 1 的缺点,所以真正的容量只有 4 块硬盘的 50%,另外的一半是用来备份的。

RAID 5

RAID 5 *少需要由 3 块硬盘组成,当然硬盘的容量也应当一致。当组成 RAID 5 时,同样需要把硬盘分隔成大小相同的区块。当有数据写入时,数据也被划分成等大小的区块,然后循环向 RAID 5 中写入。

每次循环写入数据的过程中,在其中一块硬盘中加入一个奇偶校验值(Parity),这个奇偶校验值的内容是这次循环写入时其他硬盘数据的备份。当有一块硬盘损坏时,采用这个奇偶校验值进行数据恢复。通过示意图来看看 RAID 5 的存储过程,如图 4 所示。

%title插图%num
图 4 RAID 5 示意图

在这张示意图中,我们使用三块硬盘组成了 RAID 5。当有数据循环写入时,每次循环都会写入一个奇偶校验值(Parity),并且每次奇偶校验值都会写入不同的硬盘。这个奇偶校验值就是其他两块硬盘中的数据经过换算之后产生的。因为每次奇偶校验值都会写入不同的硬盘,所以任何一块硬盘损坏之后,都可以依赖其他两块硬盘中保存的数据恢复这块损坏的硬盘中的数据。

需要注意的是,每次数据循环写入时,都会有一块硬盘用来保存奇偶校验值,所以在 RAID 5 中可以使用的总容量是硬盘总数减去一块的容量之和。

比如,在这张示意图中,由三块硬盘组成了 RAID 5,但是真正可用的容量是两块硬盘的容量之和,也就是说,越多的硬盘组成 RAID 5,损失的容量占比越小,因为不管由多少块硬盘组成 RAID 5,奇偶校验值加起来只占用一块硬盘。而且还要注意,RAID 5 不管是由几块硬盘组成的,只有损坏一块硬盘的情况才能恢复数据,因为奇偶校验值加起来只占用了一块硬盘,如果损坏的硬盘超过一块,那么数据就不能再恢复了。

RAID 5 的优点如下:

  • 因为奇偶校验值的存在,RAID 5 具有了数据冗余功能。
  • 硬盘容量损失比 RAID 1 小,而且组成 RAID 5 的硬盘数量越多,容量损失占比越小。
  • RAID 5的数据读/写性能要比 RAID 1 更好,但是在数据写入性能上比 RAID 0 差。

RAID 5 的缺点如下:

  • 不管由多少块硬盘组成 RAID 5,只支持一块硬盘损坏之后的数据恢复。
  • RAID 5 的实际容量是组成 RAID 5 的硬盘总数减去一块的容量之和。也就是有一块硬盘用来保存奇偶校验值,但不能保存数据。

从总体上来说,RAID 5 更像 RAID 0 和 RAID 1 的折中,性能比 RAID 1 好,但是不如 RAID 0;数据冗余比 RAID 0 好,而且不像 RAID 1 那样浪费了 50% 的硬盘容量。

软 RAID 和硬 RAID

我们要想在服务器上实现 RAID,可以采用磁盘阵列卡(RAID 卡)来组成 RAID,也就是硬 RAID。RAID 卡上有专门的芯片负责 RAID 任务,因此性能要好得多,而且不占用系统性能,缺点是 RAID 卡比较昂贵。

如果我们既不想花钱又想使用 RAID,那就只能使用软 RAID 了。软 RAID 是指通过软件实现 RAID 功能,没有多余的费用,但是更加耗费服务器系统性能,而数据的写入速度比硬 RAID 慢。

Linux系统下安装Apache服务器

Linux系统下安装Apache服务器
1.*步命令安装apache:

yum install httpd httpd-devel -y
1
2.第二步执行命令:
开启服务器

systemctl start httpd.service
1
执行下面命令,使服务器随Linux的启动而启动:

systemctl enable httpd.service
1
3.做到这里还是不行的,因为Linux系统中的防火墙会没有给Apache开放端口,所以需要做以下操作:

firewall-cmd –zone=public –add-port=80/tcp –permanent
1
firewall-cmd –reload
1
4.此时就可以在浏览器地址栏输入服务器的ip地址访问了,可以看到这样的界面:
%title插图%num

这样apache服务器就成功安装完成!
5.安装完成以后apache默认的安装地址为 etc/httpd/conf/httpd.conf
我们可以自定义apache的默认路径
首先在一个目录下面创建一个文件夹如:在home文件下架创建一个html文件夹

切换路径到home文件夹下:
cd /home
mkdir html
然后在打开apache原来的配置文件:

vi /etc/httpd/conf/httpd.conf
打开配置文件后将里面的/var/www/html/ 修改为/home/dic

6.做到这里还是出问题.访问ip时会出现这个问题

%title插图%num

问题出现原因是 Linux系统中SELinux关闭访问引起的
SELinux一共有三种状态分别是Enforcing,Permissive和Disabled状态,

执行命令 setenforce 0
1
临时关闭SELinux,就可以执行,但是下次重启服务器时,SELinux还是会恢复原始状态,
所以找到SELnux的配置文件设置为disable状态

vi /etc/selinux/config
1
重启linux系统就可以了!
完结!!

linux系统上内网ip和和外网ip的关系

1.不同服务之间的访问需要使用公网IP+端口才能访问

2.服务器上一般都是域名访问,服务器会把ip+端口映射成固定的域名,所以如果想访问服务器上其他应用,就必须的放开应用限制

问题,在服务器上放开对某个端口的限制。

问题:

背景:jmeter压力机放在服务器上,控制机在本地,控制机会发送命令给服务器上的压力机,压力机会进行并发压测,压测完了后会返回压测结果给控制机。

1.保证压力机能访问到控制机,控制机也要能访问到压力机

现在压力机启动jmeter-server,启动的ip不是公网ip,如图:

%title插图%num

但是没有关系:因为一个公网ip会映射多个内网ip,端口不会重复,所以访问时只需要用公网ip+应用本身占的ip,不用管应用启起来所占的ip。

友情链接: SITEMAP | 旋风加速器官网 | 旋风软件中心 | textarea | 黑洞加速器 | jiaohess | 老王加速器 | 烧饼哥加速器 | 小蓝鸟 | tiktok加速器 | 旋风加速度器 | 旋风加速 | quickq加速器 | 飞驰加速器 | 飞鸟加速器 | 狗急加速器 | hammer加速器 | trafficace | 原子加速器 | 葫芦加速器 | 麦旋风 | 油管加速器 | anycastly | INS加速器 | INS加速器免费版 | 免费vqn加速外网 | 旋风加速器 | 快橙加速器 | 啊哈加速器 | 迷雾通 | 优途加速器 | 海外播 | 坚果加速器 | 海外vqn加速 | 蘑菇加速器 | 毛豆加速器 | 接码平台 | 接码S | 西柚加速器 | 快柠檬加速器 | 黑洞加速 | falemon | 快橙加速器 | anycast加速器 | ibaidu | moneytreeblog | 坚果加速器 | 派币加速器 | 飞鸟加速器 | 毛豆APP | PIKPAK | 安卓vqn免费 | 一元机场加速器 | 一元机场 | 老王加速器 | 黑洞加速器 | 白石山 | 小牛加速器 | 黑洞加速 | 迷雾通官网 | 迷雾通 | 迷雾通加速器 | 十大免费加速神器 | 猎豹加速器 | 蚂蚁加速器 | 坚果加速器 | 黑洞加速 | 银河加速器 | 猎豹加速器 | 海鸥加速器 | 芒果加速器 | 小牛加速器 | 极光加速器 | 黑洞加速 | movabletype中文网 | 猎豹加速器官网 | 烧饼哥加速器官网 | 旋风加速器度器 | 哔咔漫画 | PicACG | 雷霆加速