Python GC主要使用引用计数（reference counting）来跟踪和回收垃圾。在引用计数的基础上，通过“标记-清除”（mark and sweep）解决容器对象可能产生的循环引用问题，通过“分代回收”（generation collection）以空间换时间的方法提高垃圾回收效率。

PyObject是每个对象必有的内容，其中`ob_refcnt`就是做为引用计数。当一个对象有新的引用时，它的`ob_refcnt`就会增加，当引用它的对象被删除，它的`ob_refcnt`就会减少.引用计数为0时，该对象生命就结束了。

优点:

1. 简单

2. 实时性

缺点:

1. 维护引用计数消耗资源

2. 循环引用

基本思路是先按需分配，等到没有空闲内存的时候从寄存器和程序栈上的引用出发，遍历以对象为节点、以引用为边构成的图，把所有可以访问到的对象打上标记，然后清扫一遍内存空间，把所有没标记的对象释放。

分代回收的整体思想是：将系统中的所有内存块根据其存活时间划分为不同的集合，每个集合就成为一个“代”，垃圾收集频率随着“代”的存活时间的增大而减小，存活时间通常利用经过几次垃圾回收来度量。

Python默认定义了三代对象集合，索引数越大，对象存活时间越长。

举例：

当某些内存块M经过了3次垃圾收集的清洗之后还存活时，我们就将内存块M划到一个集合A中去，而新分配的内存都划分到集合B中去。当垃圾收集开始工作时，大多数情况都只对集合B进行垃圾回收，而对集合A进行垃圾回收要隔相当长一段时间后才进行，这就使得垃圾收集机制需要处理的内存少了，效率自然就提高了。在这个过程中，集合B中的某些内存块由于存活时间长而会被转移到集合A中，当然，集合A中实际上也存在一些垃圾，这些垃圾的回收会因为这种分代的机制而被延迟。

推荐: http://www.jianshu.com/p/J4U6rR

关于epoll的: http://www.cnblogs.com/my_life/articles/3968782.html

1. 先来先服务

2. 短作业优先

3. 最高优先权调度

1. 时间片轮转

2. 多级反馈队列调度

实时调度算法:

1. 最早截至时间优先 EDF

2. 最低松弛度优先 LLF

原因:

1. 竞争资源

2. 程序推进顺序不当

必要条件:

1. 互斥条件

2. 请求和保持条件

3. 不剥夺条件

4. 环路等待条件

处理死锁基本方法:

1. 预防死锁(摒弃除1以外的条件)

2. 避免死锁(银行家算法)

3. 检测死锁(资源分配图)

4. 解除死锁

1. 剥夺资源

2. 撤销进程

推荐: http://www.ruanyifeng.com/blog/2014/11/compiler.html

Bulid过程可以分解为4个步骤:预处理(Prepressing), 编译(Compilation)、汇编(Assembly)、链接(Linking)

以c语言为例:

预编译过程主要处理那些源文件中的以“#”开始的预编译指令，主要处理规则有：

1. 将所有的“#define”删除，并展开所用的宏定义

2. 处理所有条件预编译指令，比如“#if”、“#ifdef”、 “#elif”、“#endif”

3. 处理“#include”预编译指令，将被包含的文件插入到该编译指令的位置，注：此过程是递归进行的

4. 删除所有注释

5. 添加行号和文件名标识，以便于编译时编译器产生调试用的行号信息以及用于编译时产生编译错误或警告时可显示行号

6. 保留所有的#pragma编译器指令。

编译过程就是把预处理完的文件进行一系列的词法分析、语法分析、语义分析及优化后生成相应的汇编代码文件。这个过程是整个程序构建的核心部分。

汇编器是将汇编代码转化成机器可以执行的指令，每一条汇编语句几乎都是一条机器指令。经过编译、链接、汇编输出的文件成为目标文件(Object File)

链接的主要内容就是把各个模块直接爱你相互引用的部分处理好，使各个模块可以正确的拼接。

链接的主要过程包块 地址和空间的分配（Address and Storage Allocation）、符号决议(Symbol Resolution)和重定位(Relocation)等步骤。

静态链接方法：静态链接的时候，载入代码就会把程序会用到的动态代码或动态代码的地址确定下来

静态库的链接可以使用静态链接，动态链接库也可以使用这种方法链接导入库

动态链接方法：使用这种方式的程序并不在一开始就完成动态链接，而是直到真正调用动态库代码时，载入程序才计算(被调用的那部分)动态代码的逻辑地址，然后等到某个时候，程序又需要调用另外某块动态代码时，载入程序又去计算这部分代码的逻辑地址，所以，这种方式使程序初始化时间较短，但运行期间的性能比不上静态链接的程序

虚拟存储器是值具有请求调入功能和置换功能,能从逻辑上对内存容量加以扩充的一种存储系统.

分页: 用户程序的地址空间被划分成若干固定大小的区域，称为“页”，相应地，内存空间分成若干个物理块，页和块的大小相等。可将用户程序的任一页放在内存的任一块中，实现了离散分配。

分段: 将用户程序地址空间分成若干个大小不等的段，每段可以定义一组相对完整的逻辑信息。存储分配时，以段为单位，段与段在内存中可以不相邻接，也实现了离散分配。

1. 页是信息的物理单位,分页是为了实现非连续分配,以便解决内存碎片问题,或者说分页是由于系统管理的需要.段是信息的逻辑单位,它含有一组意义相对完整的信息,分段的目的是为了更好地实现共享,满足用户的需要.

2. 页的大小固定,由系统确定,将逻辑地址划分为页号和页内地址是由机器硬件实现的.而段的长度却不固定,决定于用户所编写的程序,通常由编译程序在对源程序进行编译时根据信息的性质来划分.

3. 分页的作业地址空间是一维的.分段的地址空间是二维的.

1. 最佳置换算法OPT:不可能实现

2. 先进先出FIFO

3. 最近最久未使用算法LRU:最近一段时间里最久没有使用过的页面予以置换.

4. clock算法

边缘触发是指每当状态变化时发生一个 io 事件，条件触发是只要满足条件就发生一个 io 事件

HTTPS握手,对称加密,非对称加密,TLS/SSL,RSA

所谓c10k问题，指的是服务器同时支持成千上万个客户端的问题，也就是concurrent 10 000 connection（这也是c10k这个名字的由来）。

def qsort(seq):

if seq==[]:

return []

else:

pivot=seq[0]

lesser=qsort([x for x in seq[1:] if x<pivot])

greater=qsort([x for x in seq[1:] if x>=pivot])

return lesser+[pivot]+greater

if __name__=='__main__':

seq=[5,6,78,9,0,-1,2,3,-65,12]

print(qsort(seq))

def coinChange(values, money, coinsUsed):

#values T[1:n]数组

#valuesCounts 钱币对应的种类数

#money 找出来的总钱数

#coinsUsed 对应于目前钱币总数i所使用的硬币数目

for cents in range(1, money+1):

minCoins = cents #从第一个开始到money的所有情况初始

for value in values:

if value <= cents:

temp = coinsUsed[cents - value] + 1

if temp < minCoins:

minCoins = temp

coinsUsed[cents] = minCoins

print('面值为：{0} 的最小硬币数目为：{1} '.format(cents, coinsUsed[cents]) )

if __name__ == '__main__':

values = [ 25, 21, 10, 5, 1]

money = 63

coinsUsed = {i:0 for i in range(money+1)}

coinChange(values, money, coinsUsed)

给定一个数组，构建二叉树，并且按层次打印这个二叉树

class Node(object):

def __init__(self, data, left=None, right=None):

self.data = data

self.left = left

self.right = right

tree = Node(1, Node(3, Node(7, Node(0)), Node(6)), Node(2, Node(5), Node(4)))

def lookup(root):

stack = [root]

while stack:

current = stack.pop(0)

print current.data

if current.left:

stack.append(current.left)

if current.right:

stack.append(current.right)

def deep(root):

if not root:

return

print root.data

deep(root.left)

deep(root.right)

if __name__ == '__main__':

lookup(tree)

deep(tree)