这样就需要一个进程空间内部，并行执行。一个进程内部有多个执行流来并行操作，但是出现资源争抢线性

        线程是一个进程内部的多个执行流

            多个线程不能同时打开一个资源文件，而lib尽管可以共享，也是在内核级别存在的。

            资源发送争抢的区域叫临界区。

        单进程、单线程：一个进程内存空间内有一个执行流。

        单进程、多线程：一个进程内的指令集分成多个执行流

        不管你的一个进程空间内部有多少个执行流，说白了就是多少个线程，但是你有一个cpu，多个线程没有什么明显的地方，除了麻烦以外。

        多个cpu就有好多好处了。

web服务器工作模型及短板。：

        web服务器：web服务进程。有一个用户访问时，我不能直接访问，否则有问题，那第二个来访问怎么办，只能等着。

        怎么办呢？给每个用户生成一个子进程，每个用户一个子进程，一个用户需要10M内存，1000个用户就是10g。还要涉及到进程切换。
但是如果访问主页，主页这个内存空间的话，每个用户这一个子进程就要开辟一块，那我们的服务器资源都要撑坏了。所以为了让众多用户共享一个资源来说，我们就要采用线程模型。
web服务比如启动一个进程，里面分配多个线程，这样我们就打开一份数据就行了。cpu多的话就好了。

        但是多个I/O争用的。虽然我们cpu多个，里面处理数据很快，但是我们网卡就有一个，还是会堵在网卡队列这里。

所以我们要理解原理，我们就知道系统瓶颈短板在哪了。

对于linux 而言，不是线程操作系统。windows solorias 都是微内核的线程操作系统。linux是单内核的。

线程跟内核本身的关系并不大，是由线程库实现的。迄今为止，linux内核中维持的每一个线程，跟进程毫无区别。

程序时由指令和数据组成。程序时位于硬盘上的，是死的，只有当内核创建数据结构     ，分配了数据资源，cpu资源，处于活动状态，才有真正的执行价值，才会被拿来一个个被运行。

    程序内的指令能不能并行执行？即进程内的多条指令流。单核是不能了。双核的话，要是第一条运行到一半依靠第二个指令的结果，所以不能同时运行的。这是在一个执行流的情况下。

        那我们两个cpu干什么呢？可以执行多个进程啊，虽然不能执行一个进程的多个指令

分成n个执行流，每个流内都有指令和数据，是不互相干扰的。

        这样就需要一个进程空间内部，并行执行。一个进程内部有多个执行流来并行操作，但是出现资源争抢线性

        线程是一个进程内部的多个执行流

            多个线程不能同时打开一个资源文件，而lib尽管可以共享，也是在内核级别存在的。

            资源发送争抢的区域叫临界区。

        单进程、单线程：一个进程内存空间内有一个执行流。

        单进程、多线程：一个进程内的指令集分成多个执行流

为了避免用户的进程操作系统资源，cpu是有保护进制的。cpu把它能操作运行的指令时分4类。分别放在环0 1 2 3 上。

用户进程只要不是以内核方式开发的，是以自己编程方式开发的基本程序，是不能调用特权指令，一旦尝试调用cpu的特权指令，cpu就会唤醒内核的。而普通程序要想访问硬件，就要访问特定的程序接口访问特权指令，要通过系统调用通知内核。

        库调用，系统调用。

        库调用是执行库的代码的，而系统调用是执行内核代码的。

        程序运行，到内核运行 在回到用户空间这就叫做模式转换。

        所以产生系统调用在内核浪费的时间越多，cpu越浪费。所以大部分时间70%应该浪费到用户空间，才会产生生产力

比如我们的ftp服务器，只有在访问硬盘数据资源，网卡封包解包等才会执行内核模式操作。所以浪费在内核模式的程序大部分是系统程序。而用户工作程序，应该大部分时间需要浪费在用户空间。

cpu只有一颗，在同一时刻，cpu运行的进程只有一个，不能让一个进程一直占用cpu，我们一定要让其及时切换交给其他进程。

         寄存器：保存当前进程的执行状态码

         1级缓存  2级缓存 3级缓存 内存  硬盘

        而进程切换，我们要把寄存器当前的执行状态码，保存下来。保存现场。

        每个进程，内核都会在内存维护一个task_starck 任务结构，用于保存进程的属性状态信息。一旦切换进程，就会保存当前状态。再把另一个进程，本来保存在内存的任务结构的状态信息，从新交给cpu执行。在这个切换时间内，cpu并没有干活。所以这个切换时间越快越好。

        那是越频繁越好呢？？  大量时间cpu都浪费到来回切换了。

当然内核也有内核工作频率的，靠时钟驱动的。比如内核100hz/s   1s 震荡100次。内核工作hz 200 500 1000  s是越快越好吗？

        每次HZ翻转时，时钟震荡翻转时，都会产生时钟中断发生1s，linux是抢占式多任务，如果中断就会发生抢占在时钟中断周期走完时。

        cpu时间走完了，或者内核分配的时间走完了。

        为什么会抢？

            进程是有优先级的。

            进程调度，是内核的核心功能之一。要公平合理。对于那些需要占用特权资源的。紧急的进程优先级高。

            公平：

                    结果公平

                    七点公平

            进程的调度算法非常重要：

                    统筹方法

                    程序=算法指令+数据 结构

                优先级高的排前面，低的排后面。排1对合适吗？

                我们按照优先级排队，优先级相同的排一队。在算法过滤

                Big O :算法优先的判断工具

                O(1)

                    横 队列长度   纵是扫描时间

#!/usr/bin/env python

import threading

import time

class MyThread(threading.Thread):

    def __init__(self, func, args, name=''):

        threading.Thread.__init__(self)

        self.name=name

        self.func=func

        self.args=args

    def run(self):

        apply(self.func, self.args)

def print_func(num):

    while True:

        print "I am thread%d" % num

        time.sleep(1)

threads = []

t1 = MyThread(print_func, (1, ), print_func.__name__)

threads.append(t1)

t2 = MyThread(print_func, (2, ), print_func.__name__)

threads.append(t2)

for t in threads:

    t.setDaemon(True)

    t.start()

print "ok\n"

for t in threads:

    t.start()

    t.join()

print "ok\n"

#_*_coding:utf-8_*_

import threading

import time

def run(num):

    global NUM

    time.sleep(1)

    print " hi i am thread %s ...lalala " % num

    NUM += 1

NUM =0

p_list = []

for i in range(30):

    t = threading.Thread(target=run,args=(i,))

    t.start()

    p_list.append(t)  #我们自己实现并行，先让并发线程执行,加到列表等待我们取结果即可

    #t.jion() # 等待一个线程结束才会执行第二个线程，这样就成了串行，而不是并行了

for i in p_list: #

    i.join() #取出我们上面放入的结果。 但是串行取出

print '---->',NUM   #由于加入列表时候是并发加入的，数字没有先后，所以打印结果i的时候也就看到没有顺序。最后打印的的i会导致 NUM的变化

#coding:utf-8

import threading

import time

gl_num = 0

def show(arg):

    global gl_num

    time.sleep(1)

    gl_num +=1

    print gl_num

for i in range(10):

    t = threading.Thread(target=show, args=(i,))

    t.start()

print 'main thread stop'

未使用锁

main thread stop

 9

Process finished with exit code 0

多次运行可能产生混乱。这种场景就是适合使用锁的场景。

运行结果

# coding:utf-8

import threading

import time

gl_num = 0

lock = threading.RLock()

# 调用acquire([timeout])时，线程将一直阻塞，

# 直到获得锁定或者直到timeout秒后（timeout参数可选）。

# 返回是否获得锁。

def Func():

    lock.acquire()

    global gl_num

    gl_num += 1

    time.sleep(1)

    print gl_num

    lock.release()

for i in range(10):

    t = threading.Thread(target=Func)

    t.start()

使用Lock

4

8

Process finished with exit code 0

可以看出，全局变量在在每次被调用时都要获得锁，才能操作，因此保证了共享数据的安全性

运行结果

# encoding: UTF-8

import threading

import time

# 商品

product = None

# 条件变量

con = threading.Condition()

# 生产者方法

def produce():

    global product

    if con.acquire():

        while True:

            if product is None:

                print 'produce...'

                product = 'anything'

                # 通知消费者，商品已经生产

                con.notify()

            # 等待通知

            con.wait()

            time.sleep(2)

# 消费者方法

def consume():

    global product

    if con.acquire():

        while True:

            if product is not None:

                print 'consume...'

                product = None

                # 通知生产者，商品已经没了

                con.notify()

            # 等待通知

            con.wait()

            time.sleep(2)

t1 = threading.Thread(target=produce)

t2 = threading.Thread(target=consume)

t2.start()

t1.start()

生产者消费者模型

produce...

consume...

produce...

consume...

produce...

consume...

produce...

consume...

produce...

consume...

Process finished with exit code -1

程序不断循环运行下去。重复生产消费过程。

运行结果

import threading

import time

condition = threading.Condition()

products = 0

class Producer(threading.Thread):

    def run(self):

        global products

        while True:

            if condition.acquire():

                if products < 10:

                    products += 1;

                    print "Producer(%s):deliver one, now products:%s" %(self.name, products)

                    condition.notify()#不释放锁定，因此需要下面一句

                    condition.release()

                else:

                    print "Producer(%s):already 10, stop deliver, now products:%s" %(self.name, products)

                    condition.wait();#自动释放锁定

                time.sleep(2)

class Consumer(threading.Thread):

    def run(self):

        global products

        while True:

            if condition.acquire():

                if products > 1:

                    products -= 1

                    print "Consumer(%s):consume one, now products:%s" %(self.name, products)

                    condition.notify()

                    condition.release()

                else:

                    print "Consumer(%s):only 1, stop consume, products:%s" %(self.name, products)

                    condition.wait();

                time.sleep(2)

if __name__ == "__main__":

    for p in range(0, 2):

        p = Producer()

        p.start()

    for c in range(0, 3):

        c = Consumer()

        c.start()

生产者消费者模型

import threading

alist = None

condition = threading.Condition()

def doSet():

    if condition.acquire():

        while alist is None:

            condition.wait()

        for i in range(len(alist))[::-1]:

            alist[i] = 1

        condition.release()

def doPrint():

    if condition.acquire():

        while alist is None:

            condition.wait()

        for i in alist:

            print i,

        print

        condition.release()

def doCreate():

    global alist

    if condition.acquire():

        if alist is None:

            alist = [0 for i in range(10)]

            condition.notifyAll()

        condition.release()

tset = threading.Thread(target=doSet,name='tset')

tprint = threading.Thread(target=doPrint,name='tprint')

tcreate = threading.Thread(target=doCreate,name='tcreate')

tset.start()

tprint.start()

tcreate.start()

生产者消费者模型

# encoding: UTF-8

import threading

import time

event = threading.Event()

def func():

    # 等待事件，进入等待阻塞状态

    print '%s wait for event...' % threading.currentThread().getName()

    event.wait()

    # 收到事件后进入运行状态

    print '%s recv event.' % threading.currentThread().getName()

t1 = threading.Thread(target=func)

t2 = threading.Thread(target=func)

t1.start()

t2.start()

time.sleep(2)

# 发送事件通知

print 'MainThread set event.'

event.set()

Thread-1 wait for event...

Thread-2 wait for event...

#2秒后。。。

MainThread set event.

Thread-1 recv event.

 Thread-2 recv event.

Process finished with exit code 0

#!/usr/bin/env python

# _*_ coding:utf-8 _*_

import threading

import time

import random

def light():

    if not event.isSet():  #没有设置的话

        event.set()  # 设置绿灯

    count = 0  #计数器秒数

    while True:

        if count < 10:    #小于十秒 是绿灯

            print("\033[42;1m ------green light on ----\033[0m")

        elif count < 13:  #小于13秒 大于10秒 是黄灯

            print("\033[43;1m ------yellow light on ----\033[0m")

        elif count < 20:  #小于于20秒 有设置则取消

            if event.isSet():

                event.clear()

            print("\033[41;1m ------red light on ----\033[0m")

        else:  #大于20 重新

            count = 0    #取消秒数计时

            event.set()   #重新变为绿灯

        time.sleep(1)

        count +=1

def car(n):  # 第二个线程 车线程

    while 1:

        time.sleep(random.randrange(3))  #随机等待三秒

        if event.isSet():

            print("car [%d] is running..." % n ) #如果被设置了信号则是绿灯，该线程的车即可通过

        else:  #否则的话提示红灯

            print("car [%d] is waitting for the red light.." %n)

            event.wait()   #红灯的话，会在此处卡住，不往下执行

            print("Green light is on ,car %s is running......." %n)

if __name__ == '__main__':  #下面是定义了两个线程  ，灯线程 车线程， threading.Event用来设置标着符号让两个线程交流

    event = threading.Event()

    Light = threading.Thread(target=light)

    Light.start()

    for i in range(3):

        t = threading.Thread(target=car,args=(i,))

        t.start()

#_*_coding:utf-8_*_

import threading

import time

import random

def light():

    if not event.isSet():  #没有设置的话

        event.set()  # 设置绿灯

    count = 0  #计数器秒数

    while True:

        if count < 10:    #小于十秒 是绿灯

            print "\033[42;1m ------green light on ----\033[0m"

        elif count < 13:  #小于13秒 大于10秒 是黄灯

            print "\033[43;1m ------yellow light on ----\033[0m"

        elif count < 20:  #小于于20秒 有设置则取消

            if event.isSet():

                event.clear()

            print "\033[41;1m ------red light on ----\033[0m"

        else:  #大于20 重新

            count = 0    #取消秒数计时

            event.set()   #重新变为绿灯

        time.sleep(1)

        count +=1

def car(n):  # 第二个线程 车线程

    while 1:

        time.sleep(random.randrange(3))  #随机等待三秒

        if event.isSet():

            print "car [%s] is running..." % n  #如果被设置了信号则是绿灯，该线程的车即可通过

        else:  #否则的话提示红灯

            print "car [%s] is waitting for the red light.." %n

            event.wait()   #红灯的话，会在此处卡住，不往下执行

            print "Green light is on ,car %s is running......." %n

if __name__ == '__main__':  #下面是定义了两个线程  ，灯线程 车线程， threading.Event用来设置标着符号让两个线程交流

    event = threading.Event()

    Light = threading.Thread(target=light)

    Light.start()

    for i in range(3):

        t = threading.Thread(target=car,args=(i,))

        t.start()

import time

import threading

li = []

def f(i):

    time.sleep(3)

    li.append(i)

    print(i,li)

if __name__ == '__main__':

    for i in range(10):

        t = threading.Thread(target=f,args=(i,))

        t.start()

import multiprocessing

li = []

def f(i):

    time.sleep(3)

    li.append(i)

    print(i,li)

if __name__ == '__main__':

    for i in range(10):

        p = multiprocessing.Process(target=f,args=(i,))

        p.start()

from multiprocessing import Process,Array

temp = Array('i', [11,22,33,44])

def Foo(i,temp):

    temp[i] = 100+i

    for item in temp:

        print(i,'----->',item)

if __name__ == '__main__':

    for i in range(2):

        p = Process(target=Foo,args=(i,temp))

        p.start()

不同平台的进程共享数据的代码

from multiprocessing import Process,Manager

def f(i,dic):

    dic[i] = 100  + i

    for k,v in dic.items():

        print(k,v)

    print("end")

if __name__ == "__main__":

    manage = Manager()

    dic = manage.dict()

    for i in range(2):

        p = Process(target=f, args=(i,dic))

        p.start()

        p.join()

!/usr/bin/env python

_*_coding:utf-8_*_

from multiprocessing import Process,Manager

def f(i,li):

    li.append(i)

    for i in li:

        print(i)

    print("end")

if __name__ == "__main__":

    manage = Manager()

    li = manage.list()

    for i in range(2):

        p = Process(target=f, args=(i,li))

        p.start()

        p.join()

manager方式 字典 列表的共享

import  multiprocessing,time

def f(conn):

    conn.send([42,None,'HELLO'])

    conn.close

if __name__ == '__main__':  #管道发送 子进程数据给父进程接收

    parent_conn,child__conn = multiprocessing.Pipe()

    p = multiprocessing.Process(target=f,args=(child__conn,))

    p.start()

    print parent_conn.recv()  #prints "[42,None,'hello']"

p.join()

#_*_coding:utf-8_*_

__author__ = 'jianzuo'

import  multiprocessing,time

def f(conn):

    conn.send([42,None,'HELLO'])

    conn.close

if __name__ == '__main__':  #管道发送 子进程数据给父进程接收

    A,B = multiprocessing.Pipe() #赋值A B为管道两端

    p = multiprocessing.Process(target=f,args=(B,))  #将b子进程数据发送到管道

    p.start()

    print A.recv()  #prints "[42,None,'hello']"   #父进程接收

    p.join()

import  multiprocessing,time

def f(conn,q):

    conn.send([42,None,'HELLO'])

    q.put('hahhahhah')

    conn.close

if __name__ == '__main__':  #管道发送 子进程数据给父进程接收

    '''

    parent_conn,child__conn = multiprocessing.Pipe()

    p = multiprocessing.Process(target=f,args=(child__conn,))

    p.start()

    print parent_conn.recv()  #prints "[42,None,'hello']"

    p.join()

    '''

    A,B = multiprocessing.Pipe() #赋值A B为管道两端

    Q = multiprocessing.Queue()

    p = multiprocessing.Process(target=f,args=(B,Q))  #将b子进程数据发送到管道

    p.start()

    print A.recv()  #prints "[42,None,'hello']"   #父进程接收

    print "queue....----",Q.get()

p.join()

'c': ctypes.c_char,  'u': ctypes.c_wchar,

    'b': ctypes.c_byte,  'B': ctypes.c_ubyte,

    'h': ctypes.c_short, 'H': ctypes.c_ushort,

    'i': ctypes.c_int,   'I': ctypes.c_uint,

    'l': ctypes.c_long,  'L': ctypes.c_ulong,

    'f': ctypes.c_float, 'd': ctypes.c_double