python的多线程和多进程网络编程

二十八、python的多线程和多进程网络编程

线程和进程关系：

进程是具有独立功能的程序，进程是系统进行资源分配和调度的一个独立单位

线程是进程的一个实体，是cpu调度的基本单位，它是比进程更小的能独立运行的基本单位

 

国家是系统，企业是进程，个人是线程。

 

进程和线程：

进程有独立的地址空间，一个进程崩溃后，不会对其它进程产生影响(windows有点烂linux不会)。

线程有自己的堆栈和局部变量，但线程之间没有单独的地址空间，一个线程死掉就等于整个进程死掉。所以单进程的程序比多线程的程序健壮。

 

 

GIL和多线程：

Globle Interpreter Lock

CPU密集型

IO密集型

Python的多线程：

1、Thread模块：偏底层

2、Threading模块：偏高层

3、继承threading.Thread,实现run()方法

-join() : 挂起当前线程，直到被调用线程结束

-start():启动线程，执行run中的代码

-is.active():线程是否结束

 

线程中的锁：

threading.Lock

threading.Rock

Acquire(): 申请锁

Release():释放锁

 

代码1：

class A(threading.Thread):

    def run(self):

        while True:

            print 'in thread'  #多个输出在一行可证明print为非原子操作

            time.sleep(1)

 

if __name__ == "__main__":

    mt = [A() for i in range(4)]

    for t in mt:

        t.start()

    for t in mt:

        t.join()

 

代码二：

class A(threading.Thread):

    def __init__(self, n):

        threading.Thread.__init__(self)  #必须要调用父类的这个方法，否则实例化失败

        self._n = n

 

    def run(self):

        while True:

            print 'in thread %s' % self._n  #可以看到In threading是那个线程打印的

            time.sleep(1)

 

if __name__ == "__main__":

    mt = [A(i) for i in range(4)]

    for t in mt:

        t.start()

    for t in mt:

        t.join()

 

代码三：

from faker import Factory

faker = Factory.create()

cnt = 10000

x1 = [faker.paragraph() for i in range(cnt)]

x2 = [faker.paragraph() for i in range(cnt)]

 

import time

#1、单线程

start=time.clock()

for one in x1:

    len(one)

for one in x2:

    len(one)

end = time.clock()

print 'single thread is %s ' % (end-start)

 

代码三：

#2、多线程，线程多反而慢咯？？cpu密集型的任务，py的多线程反而会适得其反。并没有磁盘i/o和网络i/o

 

import threading

class A(threading.Thread):

    def __init__(self, x):

        threading.Thread.__init__(self)

        self.x = x

    def run(self):

        for each in self.x:

            len(each)

 

t1 = A(x1)

t2 = A(x2)

start1 = time.clock()

t1.start()

t2.start()

t1.join()

t2.join()

end1 = time.clock()

print 'two thread is %s ' % (end1-start1)

print (end1-start1)/(end-start)

Python的多进程：

1、多个python进程=多个GIL锁

2、Multiprocessing模块

3、继承multiprocessing.Process,实现run()方法

-join(): 挂起当前进程，直到被调用进程结束

-start(): 启动进程，执行run中的代码

 

代码1：

import multiprocessing

import time

 

#1、多进程，运行后可以去任务列表中看到5个python.exe进程。为啥是5个？脚本一个，脚本里面启动4个

class A(multiprocessing.Process):

    def __init__(self, n):

        multiprocessing.Process.__init__(self)  #必须要调用父类的这个方法，否则实例化失败

        self._n = n

 

    def run(self):

        while True:

            print 'in thread %s' % self._n  #可以看到In threading是那个线程打印的

            time.sleep(1)

 

if __name__ == "__main__":

    mt = [A(i) for i in range(4)]

    for t in mt:

        t.start()

    for t in mt:

        t.join()

 

 

进程间通信：

1、进程的内存空间是相互独立的

2、通过multiprocessing.Queue实现通信

3、Queue.put()

4、Queue.get()

 

代码二：

##模拟进程之间的消息通信，生产者和消费者模式。python的多进程容易吧，同样的功能，比java、c++容易多咯

import multiprocessing

import time

 

class Producer(multiprocessing.Process):

   def __init__(self, q):

       multiprocessing.Process.__init__(self)  #必须先实例化父类

       self._q = q

 

   def run(self):

        while True:

            self._q.put('time is %s' % time.time()) #往生产者队列中放时间

            time.sleep(1)

 

class Consumer(multiprocessing.Process):

    def __init__(self, q, n):  #q：队列，n：消费者进程编号

        multiprocessing.Process.__init__(self)

        self._q = q

        self._n = n

    def run(self):

        while True:

            msg = None

            try:

                msg = self._q.get()  #从队列中取东西容易抛错

            except :

                time.sleep(1)

                continue

            if msg:

                print 'in consumer %s %s' % (self._n, msg)

 

if __name__ == "__main__":

    q = multiprocessing.Queue() #获取一个队列

    producer = Producer(q) #实例一个生产者

    c1 = Consumer(q, 1) #获取一个消费者实例

    c2 = Consumer(q, 2) #获取一个消费者实例

    producer.start() #将生产者启动

    c1.start() #将消费者启动

    c2.start() #将消费者启动