python进程和线程对应模块_python进程和线程

------------------------------线程---------------------------

#线程应用的第一种方式：thread模块是比较底层的模块

#import thread：引用的模块

#thread.start_new_thread(defName,())：线程的创建

#thread.exit_thread()：线程的结束

#线程应用的第二种方式：threading模块是对thread做了一些包装，可以更方便被引用

#import threading：引用的模块

#myThread=threading.Thread(target=defName,args=('Alice',))：线程的创建

#myThread.start()：线程开始执行

#num=len(threading.enumerate)：线程数量的查看

#线程应用的第三种方式：创建一个线程类，继承基类：threading.Thread 。重写def run(self):方法。需要运行的内容，写在run方法里面。

#class MyThread(threading.Thread)：创建类的对象

#可以进行重构函数的对应扩展：def __init__(self,name,time):threading.Thread.__init__(self,name='对应的线程名字')

#myThread=MyThread()：创建对象

#myThread.start()：线程开始执行

------------------------------线程同步之互斥锁---------------------------

#线程同步之互斥锁

#互斥锁同步：线程同步能够保证多个线程安全访问竞争资源，最简单的同步机制是引用互斥锁。互斥锁为资源引入一个状态：锁定/非锁定。某个线程要更改共享数据时，先将其锁定，此时资源的状态为“锁定”，其他线程不能更改；直到该线程释放资源，将资源的状态变成“非锁定”，其他的线程才能再次锁定该资源。

#mutex=threading.Lock()：创建互斥锁

#if mutex.acquire([blocking])：互斥锁锁定状态，返回值不为0表示上锁成功

#锁定方法acquire可以有一个blocking参数。如果设定blocking为True，则当前线程会堵塞，直到获取到这个锁为止(如果没有指定，那么默认为True);如果设定blocking为False，则当前线程不会堵塞

#mutex.release()：互斥锁释放状态

------------------------------线程同步至可重入锁---------------------------

#线程同步之可重入锁

#RLock内部维护着一个Lock和一个counter变量，counter记录了acquire的次数，从而使得资源可以被多次acquire。直到一个线程所有的acquire都被release，其他的线程才能获得资源：

#mutex=threading.RLock()：创建可重入锁

#mutex.acquire()：可重入锁锁定状态

#mutex.release()：可重入锁释放状态

------------------------------线程同步之条件变量---------------------------

#线程同步之条件变量

#Python提供的Condition对象提供了对复杂线程同步问题的支持。Condition被称为条件变量，除了提供与Lock类似的acquire和release方法外，还提供了wait和notify方法。线程首先acquire一个条件变量，然后判断一些条件。如果条件不满足则wait；如果条件满足，进行一些处理改变条件后，通过notify方法通知其他线程，其他处于wait状态的线程接到通知后会重新判断条件。不断的重复这一过程，从而解决复杂的同步问题。

#Condition对象维护了一个锁(Lock/RLock)和一个waiting池。线程通过acquire获得Condition对象，当调用wait方法时，线程会释放Condition内部的锁并进入blocked状态，同时在waiting池中记录这个线程。当调用notify方法时，Condition对象会从waiting池中挑选一个线程，通知其调用acquire方法尝试取到锁。

#Condition对象的构造函数可以接受一个Lock/RLock对象作为参数，如果没有指定，则Condition对象会在内部自行创建一个RLock。

#除了notify方法外，Condition对象还提供了notifyAll方法，可以通知waiting池中的所有线程尝试acquire内部锁。由于上述机制，处于waiting状态的线程只能通过notify方法唤醒，所以notifyAll的作用在于防止有线程永远处于沉默状态。

#con=threading.Condition()：创建条件变量

#con.acquire()：条件变量锁定状态

#con.wait()：线程释放Condition内部的锁并进入blocked状态，同时在waiting池中记录这个线程

#con.notify()：Condition对象会从waiting池中挑选一个线程，通知其调用acquire方法尝试取到锁

#con.notifyAll()：唤醒所有处于waiting池中的所有线程，防止有线程永远处于沉默状态

#con.release()：条件变量释放状态

------------------------------线程同步之队列---------------------------

#from Queue import Queue：进行对应的队列包的引用

#queue=Queue()：队列的创建

#queue.qsize()：获取队列中内容的数量

#queue.put(内容)：向队列中添加对应的数据信息

#queue.set()：从队列中取出对应的数据

#queue.empty()：查看当前队列内容是否为空

1 #引入对应的包

2 importthreading3

4 from Queue importQueue5

6 from time importsleep7

8 #线程生产者

9 classProducer(threading.Thread):10 #重写run方法

11 defrun(self):12 globalg_queue13

14 whileTrue:15 ifcon.acquire():16 #判断是否停止生产,获取队列中的数量

17 if g_queue.qsize() < 20:18

19 #每次生产5个产品

20 for i in range(5):21 g_queue.put("产品")22

23 print("生产出5个产品，产品总量：%d"%g_queue.qsize())24 else:25 con.wait()26 print("停止生产")27

28 con.release()29 sleep(1)30

31

32 #线程消费者

33 classConsumer(threading.Thread):34 #重写run方法

35 defrun(self):36 globalg_queue37

38 whileTrue:39 ifcon.acquire():40 #判断是否停止消费

41 if g_queue.qsize()>5:42 #进行消费

43 for i in range(3):44 g_queue.get()45

46 print("消费3 总数：%d"%g_queue.qsize())47

48 if g_queue.qsize()<20:49 con.notify()50 con.release()51 sleep(1)52

53 #全局变量

54 con=threading.Condition()55 #g_num=600

56 #创建一个队列

57 g_queue=Queue()58

59

60 #main函数

61 defmain():62 pro=Producer()63 pro.start()64 con=Consumer()65 con.start()66

67 #程序入口

68 if __name__ == '__main__':69 main()70

71 线程队列实现生产者消费者

View Code

------------------------------线程间通信---------------------------

threading.Event可以使一个线程等待其他线程的通知。其内置了一个标志，初始值为False。线程通过wait()方法进入等待状态，直到另一个线程调用set()方法将内置标志设置为True时，Event通知所有等待状态的线程恢复运行。还可以通过isSet()方法查询Envent对象内置状态的当前值。

#event=threading.Event()：进行对应Envent对象的创建

#self.threadEvent=event ：重构对应threading.Thread基类中的__init__的方法。

#self.threadEvent.wait()：使线程进入等待状态

#event.set()：启动waiting池中等待的线程

------------------------------线程的合并和后台线程---------------------------

python的Thread类中还提供了join()方法，使得一个线程可以等待另一个线程执行结束后再继续运行。这个方法还可以设定一个timeout参数，避免无休止的等待。因为两个线程顺序完成，看起来象一个线程，所以称为线程的合并。

默认情况下，主线程在退出时会等待所有子线程的结束。如果希望主线程不等待子线程，而是在退出时自动结束所有的子线程，就需要设置子线程为后台线程(daemon)。方法是通过调用线程类的setDaemon()方法。

#myThread.setDaemon(True)：将该线程转为后台线程

------------------------------ThreadLocal---------------------------

global_dict={}

global_dict[threading.current_thread()]

------------------------------多进程---------------------------

在Unix/Linux操作系统中，提供了一个fork()系统函数，它非常特殊。

普通的函数调用，调用一次，返回一次，但是fork()调用一次，返回两次，因为操作系统自动把当前进程(称为父进程)复制了一份(称为子进程)，然后，分别在父进程和子进程内返回。

子进程永远返回0，而父进程返回子进程的ID。

这样做的理由是，一个父进程可以fork出很多子进程，所以，父进程要记下每个子进程的ID，而子进程只需要调用getppid()就可以拿到父进程的ID。

#import os ：引用对应的进程包

#pid=os.fork()：程序执行到os.fork()时，操作系统会创建一个新的进程(子进程)，然后复制父进程的所有信息到子进程中，然后父进程和子进程都会从fork()函数中得到一个返回值，其进程中这个值一定是0，而父进程中是子进程的 id号

#os.getpid()：获取当前进程的pid

#os.getppid()：获取父进程的pid

------------------------------multiprocessing模块---------------------------

#from multiprocessing import Process：multiprocessing模块提供了一个Process类来代表一个进程对象。

#p=Process(target=run_proc,args=('test',))：创建对应的进程对象

#p.start()：进程的启动

#p.join()：multiprocessing模块提供了一个Process类来代表一个进程对象，下面的例子演示了启动一个子进程并等待其结束

#multiprocessing.cpu_count()：查看对应的cpu核数

#pipe=multiprocessing.Pipe()：创建一个管道，管道两个端口调用分别为pipe[0],pipe[1]

#pipe[0].send(i)：为管道一侧进行内容的添加操作

#pipe[0].recv()：获取管道一侧的内容信息

1 #coding=utf-8

2

3 #引用对应的包

4 from socket import *

5

6 from multiprocessing importProcess7

8 importsys9

10 #进程函数：为客户提供tcp服务

11 deftcpClient(newSocket,destAddr):12 print("客户端(%s)以上线"%str(destAddr))13 whileTrue:14 #数据的接受

15 recvData=newSocket.recv(1024)16 #模拟echo将数据回发服务器

17 newSocket.send(recvData)18

19 #如果接收的数据长度为0，进行客户端的关闭操作

20 if len(recvData) <=0:21 print("------客户端(%s)已经下线-------"%str(destAddr))22

23 newSocket.close()24 break

25 print ("客户端(%s)传递过的数据为：%s"%(str(destAddr),recvData))26

27

28 #函数：main

29 defmain():30 #创建Tcp套接字

31 socTcpSer=socket(AF_INET,SOCK_STREAM)32

33 socTcpSer.setsockopt(SOL_SOCKET,SO_REUSEADDR,1)34

35 #创建ip和端口进行绑定

36 local=("",int(sys.argv[1]))37 socTcpSer.bind(local)38

39 #开启监听程序

40 socTcpSer.listen(5)41

42 print('---------等待客户端上线---------')43

44 #进行服务的开启，并循环为客户进行服务

45 whileTrue:46

47 #接受客户端响应信息

48 newSocket,destAddr=socTcpSer.accept()49

50 #创建子进程

51 pClient=Process(target=tcpClient,args=(newSocket,destAddr,))52

53 #子进程开始

54 pClient.start()55

56 socTcpSer.close()57

58

59 #程序入口

60 if __name__=='__main__':61 main()62

63 多进程实现tcp服务64

65 多进程模拟tcp服务

View Code