附录 A. 开​​​​​​​发​​​​​​​者​​​​​​​小​​​​​​​贴​​​​​​​示​​​​​​​

每​​​​​​​本​​​​​​​优​​​​​​​秀​​​​​​​的​​​​​​​编​​​​​​​程​​​​​​​课​​​​​​​本​​​​​​​都​​​​​​​包​​​​​​​含​​​​​​​内​​​​​​​存​​​​​​​分​​​​​​​配​​​​​​​以​​​​​​​及​​​​​​​具​​​​​​​体​​​​​​​功​​​​​​​能​​​​​​​性​​​​​​​能​​​​​​​的​​​​​​​问​​​​​​​题​​​​​​​。​​​​​​​当​​​​​​​您​​​​​​​开​​​​​​​发​​​​​​​自​​​​​​​己​​​​​​​的​​​​​​​软​​​​​​​件​​​​​​​时​​​​​​​,请​​​​​​​注​​​​​​​意​​​​​​​可​​​​​​​能​​​​​​​在​​​​​​​运​​​​​​​行​​​​​​​该​​​​​​​软​​​​​​​件​​​​​​​的​​​​​​​系​​​​​​​统​​​​​​​中​​​​​​​增​​​​​​​加​​​​​​​电​​​​​​​源​​​​​​​消​​​​​​​耗​​​​​​​的​​​​​​​问​​​​​​​题​​​​​​​。​​​​​​​虽​​​​​​​然​​​​​​​这​​​​​​​些​​​​​​​考​​​​​​​虑​​​​​​​不​​​​​​​会​​​​​​​影​​​​​​​响​​​​​​​每​​​​​​​一​​​​​​​行​​​​​​​代​​​​​​​码​​​​​​​,但​​​​​​​您​​​​​​​可​​​​​​​以​​​​​​​优​​​​​​​化​​​​​​​那​​​​​​​些​​​​​​​经​​​​​​​常​​​​​​​成​​​​​​​为​​​​​​​性​​​​​​​能​​​​​​​瓶​​​​​​​颈​​​​​​​部​​​​​​​分​​​​​​​的​​​​​​​代​​​​​​​码​​​​​​​。​​​​​​​
经​​​​​​​常​​​​​​​会​​​​​​​出​​​​​​​问​​​​​​​题​​​​​​​的​​​​​​​技​​​​​​​术​​​​​​​包​​​​​​​括​​​​​​​:
  • 使​​​​​​​用​​​​​​​线​​​​​​​程​​​​​​​。​​​​​​​
  • 不​​​​​​​必​​​​​​​要​​​​​​​ CPU 唤​​​​​​​醒​​​​​​​以​​​​​​​及​​​​​​​未​​​​​​​有​​​​​​​效​​​​​​​使​​​​​​​用​​​​​​​唤​​​​​​​醒​​​​​​​。​​​​​​​如​​​​​​​果​​​​​​​您​​​​​​​必​​​​​​​须​​​​​​​执​​​​​​​行​​​​​​​唤​​​​​​​醒​​​​​​​,尽​​​​​​​快​​​​​​​一​​​​​​​次​​​​​​​做​​​​​​​完​​​​​​​所​​​​​​​有​​​​​​​的​​​​​​​事​​​​​​​(迅​​​​​​​速​​​​​​​返​​​​​​​回​​​​​​​闲​​​​​​​置​​​​​​​状​​​​​​​态​​​​​​​)。​​​​​​​
  • 不​​​​​​​必​​​​​​​要​​​​​​​的​​​​​​​ [f]sync() 使​​​​​​​用​​​​​​​。​​​​​​​
  • 不​​​​​​​必​​​​​​​要​​​​​​​的​​​​​​​活​​​​​​​跃​​​​​​​调​​​​​​​用​​​​​​​或​​​​​​​者​​​​​​​使​​​​​​​用​​​​​​​简​​​​​​​短​​​​​​​常​​​​​​​规​​​​​​​超​​​​​​​时​​​​​​​(使​​​​​​​用​​​​​​​响​​​​​​​应​​​​​​​事​​​​​​​件​​​​​​​)。​​​​​​​
  • 没​​​​​​​有​​​​​​​有​​​​​​​效​​​​​​​使​​​​​​​用​​​​​​​唤​​​​​​​醒​​​​​​​。​​​​​​​
  • 低​​​​​​​效​​​​​​​磁​​​​​​​盘​​​​​​​访​​​​​​​问​​​​​​​。​​​​​​​使​​​​​​​用​​​​​​​大​​​​​​​量​​​​​​​缓​​​​​​​冲​​​​​​​来​​​​​​​避​​​​​​​免​​​​​​​频​​​​​​​繁​​​​​​​的​​​​​​​磁​​​​​​​盘​​​​​​​访​​​​​​​问​​​​​​​。​​​​​​​一​​​​​​​次​​​​​​​写​​​​​​​入​​​​​​​大​​​​​​​块​​​​​​​信​​​​​​​息​​​​​​​。​​​​​​​
  • 低​​​​​​​效​​​​​​​使​​​​​​​用​​​​​​​计​​​​​​​时​​​​​​​器​​​​​​​。​​​​​​​可​​​​​​​能​​​​​​​时​​​​​​​使​​​​​​​用​​​​​​​跨​​​​​​​应​​​​​​​用​​​​​​​程​​​​​​​序​​​​​​​(甚​​​​​​​至​​​​​​​跨​​​​​​​系​​​​​​​统​​​​​​​)的​​​​​​​组​​​​​​​群​​​​​​​计​​​​​​​时​​​​​​​器​​​​​​​。​​​​​​​
  • 过​​​​​​​量​​​​​​​的​​​​​​​ I/O,电​​​​​​​源​​​​​​​消​​​​​​​耗​​​​​​​或​​​​​​​者​​​​​​​内​​​​​​​存​​​​​​​使​​​​​​​用​​​​​​​(包​​​​​​​括​​​​​​​内​​​​​​​存​​​​​​​泄​​​​​​​露​​​​​​​)
  • 执​​​​​​​行​​​​​​​不​​​​​​​必​​​​​​​要​​​​​​​计​​​​​​​算​​​​​​​。​​​​​​​
下​​​​​​​面​​​​​​​的​​​​​​​部​​​​​​​分​​​​​​​更​​​​​​​详​​​​​​​细​​​​​​​地​​​​​​​阐​​​​​​​述​​​​​​​这​​​​​​​些​​​​​​​方​​​​​​​面​​​​​​​。​​​​​​​

A.1. 使​​​​​​​用​​​​​​​线​​​​​​​程​​​​​​​

普​​​​​​​遍​​​​​​​认​​​​​​​为​​​​​​​使​​​​​​​用​​​​​​​线​​​​​​​程​​​​​​​使​​​​​​​应​​​​​​​用​​​​​​​程​​​​​​​序​​​​​​​可​​​​​​​更​​​​​​​好​​​​​​​且​​​​​​​更​​​​​​​迅​​​​​​​速​​​​​​​地​​​​​​​执​​​​​​​行​​​​​​​,但​​​​​​​并​​​​​​​不​​​​​​​总​​​​​​​是​​​​​​​这​​​​​​​样​​​​​​​。​​​​​​​
Python

Python 使​​​​​​​用​​​​​​​全​​​​​​​局​​​​​​​锁​​​​​​​定​​​​​​​解​​​​​​​码​​​​​​​器​​​​​​​[1],因​​​​​​​此​​​​​​​使​​​​​​​用​​​​​​​线​​​​​​​程​​​​​​​只​​​​​​​能​​​​​​​在​​​​​​​有​​​​​​​大​​​​​​​量​​​​​​​ I/O 操​​​​​​​作​​​​​​​时​​​​​​​受​​​​​​​益​​​​​​​。​​​​​​​Unladen-swallow [2] 是​​​​​​​一​​​​​​​个​​​​​​​ Python 快​​​​​​​速​​​​​​​部​​​​​​​署​​​​​​​,您​​​​​​​可​​​​​​​用​​​​​​​它​​​​​​​来​​​​​​​优​​​​​​​化​​​​​​​您​​​​​​​的​​​​​​​代​​​​​​​码​​​​​​​。​​​​​​​

Perl

Perl 线​​​​​​​程​​​​​​​原​​​​​​​是​​​​​​​用​​​​​​​于​​​​​​​系​​​​​​​统​​​​​​​中​​​​​​​不​​​​​​​使​​​​​​​用​​​​​​​ forking 技​​​​​​​术​​​​​​​的​​​​​​​应​​​​​​​用​​​​​​​程​​​​​​​序​​​​​​​(比​​​​​​​如​​​​​​​使​​​​​​​用​​​​​​​ 32 位​​​​​​​ Windows 操​​​​​​​作​​​​​​​系​​​​​​​统​​​​​​​的​​​​​​​系​​​​​​​统​​​​​​​)。​​​​​​​在​​​​​​​ Perl 线​​​​​​​程​​​​​​​中​​​​​​​会​​​​​​​为​​​​​​​每​​​​​​​个​​​​​​​单​​​​​​​一​​​​​​​线​​​​​​​程​​​​​​​复​​​​​​​制​​​​​​​数​​​​​​​据​​​​​​​(写​​​​​​​时​​​​​​​复​​​​​​​制​​​​​​​)。​​​​​​​数​​​​​​​据​​​​​​​不​​​​​​​是​​​​​​​默​​​​​​​认​​​​​​​共​​​​​​​享​​​​​​​的​​​​​​​,因​​​​​​​为​​​​​​​用​​​​​​​户​​​​​​​应​​​​​​​该​​​​​​​可​​​​​​​以​​​​​​​定​​​​​​​义​​​​​​​数​​​​​​​据​​​​​​​共​​​​​​​享​​​​​​​等​​​​​​​级​​​​​​​。​​​​​​​必​​​​​​​须​​​​​​​包​​​​​​​括​​​​​​​共​​​​​​​享​​​​​​​ threads::shared 模​​​​​​​块​​​​​​​的​​​​​​​数​​​​​​​据​​​​​​​。​​​​​​​但​​​​​​​是​​​​​​​数​​​​​​​据​​​​​​​不​​​​​​​仅​​​​​​​仅​​​​​​​是​​​​​​​被​​​​​​​复​​​​​​​制​​​​​​​(写​​​​​​​时​​​​​​​复​​​​​​​制​​​​​​​),该​​​​​​​模​​​​​​​块​​​​​​​还​​​​​​​为​​​​​​​这​​​​​​​些​​​​​​​数​​​​​​​据​​​​​​​生​​​​​​​成​​​​​​​了​​​​​​​捆​​​​​​​绑​​​​​​​变​​​​​​​量​​​​​​​,这​​​​​​​就​​​​​​​需​​​​​​​要​​​​​​​更​​​​​​​多​​​​​​​的​​​​​​​时​​​​​​​间​​​​​​​,且​​​​​​​速​​​​​​​度​​​​​​​更​​​​​​​慢​​​​​​​。​​​​​​​[3]

C

C 线​​​​​​​程​​​​​​​共​​​​​​​享​​​​​​​同​​​​​​​一​​​​​​​内​​​​​​​存​​​​​​​,每​​​​​​​个​​​​​​​线​​​​​​​程​​​​​​​都​​​​​​​有​​​​​​​自​​​​​​​己​​​​​​​的​​​​​​​栈​​​​​​​,同​​​​​​​时​​​​​​​内​​​​​​​核​​​​​​​不​​​​​​​一​​​​​​​定​​​​​​​要​​​​​​​生​​​​​​​成​​​​​​​新​​​​​​​的​​​​​​​文​​​​​​​件​​​​​​​描​​​​​​​述​​​​​​​符​​​​​​​并​​​​​​​分​​​​​​​配​​​​​​​新​​​​​​​的​​​​​​​内​​​​​​​存​​​​​​​空​​​​​​​间​​​​​​​。​​​​​​​C 可​​​​​​​以​​​​​​​真​​​​​​​正​​​​​​​在​​​​​​​更​​​​​​​多​​​​​​​线​​​​​​​程​​​​​​​中​​​​​​​使​​​​​​​用​​​​​​​更​​​​​​​多​​​​​​​ CPU 支​​​​​​​持​​​​​​​。​​​​​​​因​​​​​​​此​​​​​​​要​​​​​​​最​​​​​​​大​​​​​​​化​​​​​​​您​​​​​​​的​​​​​​​线​​​​​​​程​​​​​​​性​​​​​​​能​​​​​​​,请​​​​​​​使​​​​​​​用​​​​​​​低​​​​​​​级​​​​​​​语​​​​​​​言​​​​​​​,比​​​​​​​如​​​​​​​ C 或​​​​​​​者​​​​​​​ C++。​​​​​​​如​​​​​​​果​​​​​​​您​​​​​​​使​​​​​​​用​​​​​​​脚​​​​​​​本​​​​​​​语​​​​​​​言​​​​​​​,请​​​​​​​考​​​​​​​虑​​​​​​​写​​​​​​​入​​​​​​​一​​​​​​​个​​​​​​​ C 绑​​​​​​​定​​​​​​​。​​​​​​​请​​​​​​​使​​​​​​​用​​​​​​​分​​​​​​​析​​​​​​​器​​​​​​​识​​​​​​​别​​​​​​​不​​​​​​​能​​​​​​​很​​​​​​​好​​​​​​​执​​​​​​​行​​​​​​​的​​​​​​​代​​​​​​​码​​​​​​​。​​​​​​​[4]


为了尽快向用户提供最新的信息,本文档可能会包括由机器自动从英文原文翻译的内容。如需更多信息,请参阅此说明。