一句话总结：父进程创建子进程时，子进程会复制父进程的内存（包括锁状态），需仔细处理。
1、死锁例子


#include <stdio.h>

#include <time.h>

#include <pthread.h>

#include <unistd.h>




pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;




void* doit(void* arg)

{

printf("pid = %d begin doit ...\n",static_cast<int>(getpid()));

pthread_mutex_lock(&mutex);

struct timespec ts = {2,
0};

nanosleep(&ts, NULL);

pthread_mutex_unlock(&mutex);

printf("pid = %d end doit ...\n",static_cast<int>(getpid()));




return
NULL;

}




int main(void)

{

printf("pid = %d Entering main ...\n",
static_cast<int>(getpid()));

pthread_t tid;

pthread_create(&tid, NULL, doit,
NULL);

struct timespec ts = {1,
0};

nanosleep(&ts, NULL);

if (fork() ==
0)

{

doit(NULL);

}

pthread_join(tid, NULL);

printf("pid = %d Exiting main ...\n",static_cast<int>(getpid()));




return
0;

}




运行结果：




通过查询进程可以发现死锁了，子进程3071无法往下执行。
原因：父进程创建的线程调用doit()后，对mutex加了锁；此时fork了一个子进程，子进程复制父进程的内存，包括此时的mutex锁状态；父进程接着往后执行直到结束，而子进程调用了doit()，此时mutex处于加锁状态，一直等待，造成死锁。


2、解决死锁
如何解决上述问题呢，我们需要在fork子进程前将锁释放掉，fork之后再将父进程的锁加上。用



int pthread_atfork(void (*prepare)(void), void (*parent)(void), void (*child)(void));

pthread_atfork()在fork()之前调用，当调用fork时，内部创建子进程前在父进程中会调用prepare，内部创建子进程成功后，父进程会调用parent ，子进程会调用child。

不过还是尽量少将多进程多线程混在一起。




#include <stdio.h>

#include <time.h>

#include <pthread.h>

#include <unistd.h>




pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;




void* doit(void* arg)

{

printf("pid = %d begin doit ...\n",static_cast<int>(getpid()));

pthread_mutex_lock(&mutex);

struct timespec ts = {2,
0};

nanosleep(&ts, NULL);

pthread_mutex_unlock(&mutex);

printf("pid = %d end doit ...\n",static_cast<int>(getpid()));




return
NULL;

}




void prepare(void)

{

    printf("pid = %d prepare ...\n",
static_cast<int>(getpid()));

    pthread_mutex_unlock(&mutex);

}




void parent(void)

{

    printf("pid = %d parent ...\n",
static_cast<int>(getpid()));

    pthread_mutex_lock(&mutex);

}




void child(void)

{

    printf("pid = %d child ...\n",
static_cast<int>(getpid()));

}




int main(void)

{

pthread_atfork(prepare, parent, child);

printf("pid = %d Entering main ...\n",
static_cast<int>(getpid()));

pthread_t tid;

pthread_create(&tid, NULL, doit,
NULL);

struct timespec ts = {1,
0};

nanosleep(&ts, NULL);

if (fork() ==
0)

{

    doit(NULL);

}

pthread_join(tid, NULL);

printf("pid = %d Exiting main ...\n",static_cast<int>(getpid()));




return
0;

}


结果：

http://pymotwcn.readthedocs.org/en/latest/documents/BaseHTTPServer.html
 
线程和进程¶
HTTPServer是SocketServer.TCPServer的一个简单子类. 它不使用多线程或多进程来处理请求. 要增加多线程和多进程, 可以使用SocketServer中的合适的混用类来创建一个新的类.


from BaseHTTPServer import HTTPServer, BaseHTTPRequestHandler
from SocketServer import ThreadingMixIn
import threading

class Handler(BaseHTTPRequestHandler):

    def do_GET(self):
        self.send_response(200)
        self.end_headers()
        message = threading.currentThread().getName() ## 这里threading就可以自己处理
        self.wfile.write(message)
        self.wfile.write('\n')
        return

class ThreadedHTTPServer(ThreadingMixIn, HTTPServer):
    """Handle requests in a separate thread."""

if __name__ == '__main__':
    server = ThreadedHTTPServer(('localhost', 8080), Handler)
    print 'Starting server, use <Ctrl-C> to stop'
    server.serve_forever()



每次当一个请求过来的时候, 一个新的线程或进程会被创建来处理它:

$ curl http://localhost:8080/
Thread-1
$ curl http://localhost:8080/
Thread-2
$ curl http://localhost:8080/
Thread-3

如果把上面的ThreadingMixIn换成ForkingMixIn, 也可以获得类似的结果, 但是后者是使用了独立的进程而不是线程.

1.PEP8编码规范，以及开发中的一些惯例和建议
1、代码编排：

1）缩进四个空格，空格与Tab不能混用

2）行长80，防止单行逻辑复杂

2、import：

1）不能用 from xxx import *

2)  顺序：标准库

第三方库

自定义库

3）单行不要import 多个库

4)   模块内用不到的不要import

3、空格

1）：, ; 后面跟一个空格，前面五空格（行尾分号后五空格）

2）二元操作符前后各一个空格，包括：

1.数学运算符 + - * / // = & |

2.比较运算符 == ！=  < > <= >= is not in

3.逻辑运算符 and or not

4.位运算符 & | ^  <<  >>

5.当=用于指示关键字参数或默认参数值时，不要在其两侧使用空格

4、适当添加空行：

函数间：顶级函数间空2行，类方法之间空1行

函数内：同一函数内逻辑块之间空1行

文件结尾：留一个空行

5、语义明确、直白：

not xx in yy VS xx is not in yy

not a is b     VS a is not b
二、函数闭包
引用了自由变量的函数即是一个闭包，这个被引用的自由变量和这个函数一同存在
def foo():
    l = []
    def bar(i):
        l.append(i)
        return l
    return bar
if  __name__=="__main__":
    f1 = foo()
    f2 = foo()
    f3 = foo()
    print(f1(1))
    print(f2(2))
    print(f3(3))
    """
    [1]
	[2]
	[3]
    """

三、装饰器
1、最简装饰器
def deco(func):
    #print(func)
    #print('lalala')
    def warp():
        print('成功')
        return func()
    return warp
@deco
def A():
    print('Joker')
@deco
def B():
    print('Joker2')
A()
B()
"""
成功
Joker
Joker2
A()-->deco-->func:A-->return warp:warp()-->'hahaha'
"""

2、函数体加参数
 def deco(func):
    #print(func)
    #print('lalala')
    def warp(n):
        print('成功')
        n = 'ok'
        return func(n)
    return warp
@deco
def A(name):
    print(name)
A('joker')
"""
成功
ok
"""

 def deco(func):
    def warp(n,n1):
        print('成功')
        n = 'OK'
        return func(n,n1)
    return warp

@deco
def A(name,name2): 
    print(name)
    print(name2)
A('joker','faker')

"""
OK
faker
"""

案例：

1、输入两个数字，装饰器求和，本函数打印这两个数字的和
def deco(func):
    def add(a,b):
        he = a + b
        return  func(he,b)
    return add
@deco
def A(name,name1):
    print(name)
A(10,20)
"""
30
"""

2、垃圾验证码：无论输入啥验证码，都返回验证码错误，前提在装饰器的情况下。如果不使用，则正确就打印正确
import random
def deco(func):
    def yan(n1,n2):
        n1 = -1
        return func(n1,n2)
    return yan
@deco
def A(n1,n2):
    if n1 == n2:
        print('正确')
    else:
        print('错误')

num = random.randrange(1000,9999)
print('验证码:%d'%num)
num2 = int(input('请输入验证码'))
A(num,num2)
"""
"""
验证码:5552                 验证码:7351
请输入验证码5556             请输入验证码7351
错误                         错误
"""

import random
def deco2(parms):
    def deco(func): 
        def warp(n1,n2):
            if parms:
                n1 = -1
            return func(n1,n2)
        return warp
    return deco

@deco2(False)  (True则走装饰器)
def A(n1,n2):
    if n1 == n2:
        print('验证码输入正确')
    else:
        print('验证码输入错误')

num = random.randrange(1000,9999)
print('验证码是%d'%num) 
num2 = int(input('>>'))        
A(num,num2)

3、检测某个时间段内（5秒）ip访问次数，如果ip访问次数超过10次，则返回404
import time
TIME1 = 0
TIME2 = 0

def check_ip(func):
    def warp (*args,**kwargs):
        if (round(abs(TIME2 - TIME1),2)) < 0.5:
            print('404')
        else:
            return func(*args,**kwargs)
    return warp

@check_ip
def A(ip):
    print('登录页面成功')
#模拟请求
for _ in range(50):
    ip = '127.0.0.1'
    TIME1 = time.time()
    A(ip)

    TIME2 = time.time()
    time.sleep(0.1)
    """
    登录页面成功
    404
    404
    404
    404
    """

四.进程和线程
概念

进程就是操作系统中执行的一个程序，操作系统以进程为单位分配存储空间，每个进程都有自己的地址空间、数据栈以及其他用于跟踪进程执行的辅助数据，操作系统管理所有进程的执行，为它们合理的分配资源

python中的多进程
简单的多进程
import multiprocessing

def A():
    print('Hello')

if __name__ == "__main__":
    #创建进程
    p = multiprocessing.Process(target = A, args = ())
    p.start()  #启动进程
    p.join()
    print('Over')
"""
Hello
Over
"""

多进程
import multiprocessing
import os

def A(name):
    print(os.getpid())
    print(name)

if __name__ == "__main__":
    #创建进程
    p1 = multiprocessing.Process(target = A, args = ('sdf1',))
    p2 = multiprocessing.Process(target = A, args = ('sdf2',))
    p1.start()
    p2.start()  #启动进程
    p2.join()
    p2.join()
    print('OK')
    """
    20920
	sdf1
	19444
	sdf2
	OK
    """

python进阶
一、编码规范
1、代码编排：

1）缩进四个空格，空格与Tab不能混用

2）行长80，防止单行逻辑复杂

2、import：

1）不能用 from xxx import *

2）顺序：标准库、第三方库、自定义库

3）单行不要import多个库

4）模块内用不到的不要去import

3、空格

1）标点符号后面跟一个空格，前面不要空格（行尾分号后无空格）

2）运算符前后各一个空格

3）当 = 用于指示关键字参数或默认值时，两侧无空格

4、适当添加空行

1）函数间：顶级函数间空两行，类的方法之间空1行

2）同一函数内的逻辑块之间空一行

3）文件结尾：留一个空行（Unix中\n是文件结束符）

5、注释

1）忌：逐行添加注释、没有一个注释

2）行内注释：单行逻辑过于复杂时添加

3）块注释：一段逻辑开始时添加

4）引入外来算法或者配置时需在注释中添加原链接，标明出处

5）函数和类尽可能添加docstring

6、命名

1）不要用单字母的变量名

2）包名、模块名、函数名、方法名小写，单词间用下划线连接

3）类名、异常名使用CapWords（首字母大写）的方式，异常名结尾加Error或Warning后缀

4）全局变量尽量使用大写，一组同类型的全局变量要加统一前缀，单词用下滑线连接

7、字符串拼接尽量使用join

速度快，内存消耗小

8、语意明确、直白

9、程序的构建

1）一个函数只能做一件事，并把这件事做好

2）大的功能用小的函数之间的灵活组合来完成

3）避免编写庞大的程序

10、函数名必须有动词，最好是do_something形式，或somebody_do_something句式

11、自定义的变量名、函数名不要与标准库中的名字冲突

12、格式化

Alt+Shift+f
二、函数闭包
引用了自由变量的函数即是一个闭包，这个被引用的自由变量和这个函数一同存在。
def foo():
    l = []
    def bar(i):
        l.append(i)
        return l
    return bar

if __name__ == "__main__":
    f1 = foo()
    print(f1)

#<function foo.<locals>.bar at 0x000000C17DF41378>

def foo():
    l = []
    def bar(i):
        l.append(i)
        return l
    return bar

if __name__ == "__main__":
    f1 = foo()
    f2 = foo()
    f3 = foo()
    print(f1(1))
    print(f2(2))
    print(f3(3))
"""
[1]
[2]
[3]
"""

def foo():
    l = []
    def bar(i):
        l.append(i)
        return l
    return bar

if __name__ == "__main__":
    f1 = foo()
    f2 = foo()
    print(f1(1))
    print(f2(2))
    print(f2(3))
"""
[1]
[2]
[2, 3]
"""

三、装饰器
1、最简装饰器
def deco(func):
    def warp():
        print('hahaha')
    return warp

@deco
def A():
    print('joker')
A() 

#hahaha

逻辑：A() -->deco --> func:A --> return warp:warp() --> “hahaha”
def deco(func):
    def warp():
        print('hahaha')
        func()
    return warp

@deco
def A(): #不带参
    return'joker'
print(A()) #被warp捕获

"""
hahaha
None
"""

def deco(func):
    def warp():
        print('hahaha')
        return func()
    return warp

@deco
def A():
    print('hahaha')
    return'joker'
print(A())
"""
hahaha
hahaha
joker
"""

2、函数体加参数
def deco(func):
    def warp(n):
        print('hahaha')
        return func(n)
    return warp

@deco
def A(name):
    print(name)
A('joker')
"""
hahaha
joker
"""

def deco(func):
    def warp(n):
        print('hahaha')
        n = 'OK'
        return func(n)
    return warp

@deco
def A(name):  (参数等同于作废)
    print(name)
A('joker')

"""
hahaha
OK
"""

def deco(func):
    def warp(n,n1):
        print('hahaha')
        n = 'OK'
        return func(n,n1)
    return warp

@deco
def A(name,name2): 
    print(name)
    print(name2)
A('joker','faker')

"""
OK
faker
"""

练习

1）输入两个数字，装饰器的作用是求这两个数字的和，本函数的作用是打印这两个数字的和
def deco(func):
    def warp(n,n1):
        sum_ = n + n1
        return func(sum_,n1)
    return warp

@deco
def A(name,name2): 
    print(name)
A(10,20)
#30

2）无敌验证码：无论输入什么都返回错误
import random
def deco(func):
    def warp(n1,n2): 
        n1 = -1
        return func(n1,n2)
    return warp

@deco
def A(n1,n2):
    if n1 == n2:
        print('验证码输入正确')
    else:
        print('验证码输入错误')

num = random.randrange(1000,9999)
print('验证码是%d'%num) 
num2 = int(input('>>'))        
A(num,num2)

"""
验证码是9833
>>9833
验证码输入错误
"""

3、装饰器传参
import random
def deco2(parms):
    def deco(func): 
        def warp(n1,n2):
            if parms:
                n1 = -1
            return func(n1,n2)
        return warp
    return deco

@deco2(False)  (True则走装饰器)
def A(n1,n2):
    if n1 == n2:
        print('验证码输入正确')
    else:
        print('验证码输入错误')

num = random.randrange(1000,9999)
print('验证码是%d'%num) 
num2 = int(input('>>'))        
A(num,num2)

4、不定长参数

1）*args
import random
def deco2(parms):
    def deco(func): 
        def warp(*args,**kwargs):
            args = list(args)
            if parms:
                args[0] = -1
            return func(*args,**kwargs)
        return warp
    return deco

@deco2(True)  
def A(n1,n2):
    if n1 == n2:
        print('验证码输入正确')
    else:
        print('验证码输入错误')

num = random.randrange(1000,9999)
print('验证码是%d'%num) 
num2 = int(input('>>'))        
A(num,num2)

2）**kwargs
import random
def deco2(parms):
    def deco(func): 
        def warp(*args,**kwargs):
            if parms:
                kwargs['n1'] = -1
            return func(*args,**kwargs)
        return warp
    return deco

@deco2(True)  
def A(n1,n2):
    if n1 == n2:
        print('验证码输入正确')
    else:
        print('验证码输入错误')

num = random.randrange(1000,9999)
print('验证码是%d'%num) 
num2 = int(input('>>'))        
A(n1 = num,n2 = num2)

练习：

检测某个时间段内（5秒）ip访问次数，超过十次则返回404
import time

TIME1 = 0
TIME2 = 0

def check_ip(func):
    def warp(*args,**kwargs):
        if round(abs(TIME2 - TIME1),3) < 0.5:
            print('404')
        else:
            return func(*args,**kwargs)
    return warp

@check_ip
def A(ip):
    print('进入网页成功')

#模拟请求
for _ in range(50):
    ip = '127.0.0.1'
    TIME1 = time.time()
    A(ip)
    TIME2 = time.time
    time.sleep(1)

进程和线程
一、概念
1、进程：

操作系统中执行的一个程序，操作系统以进程为单位分配存储空间，每个进程都有自己的地址空间、数据栈以及其他用于跟踪进程执行的辅助数据，操作系统管理所有进程的执行，为它们合理的分配资源。

2、线程

一个进程还可以拥有多个并发的执行线索，简单的说就是拥有多个可以获得CPU调度的执行单元，这就是线程
二、多进程
1、最简单的进程
import multiprocessing

def A():
    print('Hello')

if __name__ == "__main__":
    #创建进程
    p = multiprocessing.Process(target = A, args = ())
    p.start()  #启动进程
    p.join()
    print('Over')

#Hello
#Over

2、多进程
import multiprocessing
import os

def A(name):
    print(os.getpid())
    print(name)

if __name__ == "__main__":
    #创建进程
    p1 = multiprocessing.Process(target = A, args = ('sdf1',))
    p2 = multiprocessing.Process(target = A, args = ('sdf2',))
    p1.start()
    p2.start()  #启动进程
    p2.join()
    p2.join()
    print('OK')

"""
sdf1
13068
sdf2
OK
"""

如果程序中的代码只能按顺序一点点的往下执行，那么即使执行两个毫不相关的下载任务，也需要先等待一个文件下载完成后才能开始下一个下载任务，这并不合理也没有效率。接下来我们使用多进程的方式将两个下载任务放到不同的进程中