线程实用方法

创建线程的方法

1.直接使用Thread
target:method
args:method需要的参数

from threading import Thread
t2 = Thread(target=method, args=())

2.继承thread

class MyThread(Thread):
    def __init__(self, arg):
        Thread.__init__(self)
        self.arg = arg
    def run(self):
        self.arg

三、线程中进行事件通知

event函数可以实现跨线程通知事件开启

"""
使用Event函数进行线程间事件通知
"""
from threading import Event

def waitMethod(e):
    print("haha")
    e.wait()
    print("wait finish")
def startMethod(e):
    print("start method")
    e.set()
event=Event()
t4=Thread(target=waitMethod,args=(event,))
t5=Thread(target=startMethod,args=(event,))
t4.start()
t5.start()
###haha
###start method
###wait finish

四、使用ThreadLocal为当前线程维护本地变量

1.线程本地对象
使用threadlocal存储的对象，会在其他线程使用时，为每一个使用threadlocal中维护的那个变量的线程单独提供该变量，其他线程访问不到或者不会对当前线程维护的那个变量造成影响

2.实例 有多个线程使用操作一个方法，方法中的变量不能被其他线程的结果影响时 ，可以使用threadlocal维护该变量，例如我们需要为每一个客户端一个独立的对象

t_local=threading.local
t.x=3

def test(arg):
    t.x=arg
    print("%s"%(threading.current_thread())+" %s"%(t.x))

t8=Thread(target=test,args=(6,))
t8.start()
t9=Thread(target=test,args=(9,))
t9.start()

#<Thread(Thread-7, started 123145431937024)> 6
#<Thread(Thread-8, started 123145431937024)> 9

创建线程池

使用from concurrent.futures import ThreadPoolExecutor引入线程池的支持
1.线程执行的结果可以通过future拿到
2.map函数可以根据接收到的参数的个数来，执行相应次数的方法

executors=ThreadPoolExecutor(3)

def testA(a,b):
    print(a**b)
    return "a : %s"%(a)+" b : %s"%(b)
####使用submit来执行方法
result=executors.submit(testA,2,3)
####通过future的result方法拿到方法执行的结果
print(result.result())
###使用map函数来，根据传递的参数来指定 方法执行的次数
executors.map(testA,[1,2,3],[2,4,6])

跨进程通信

使用Queue进行跨进程通信

"""
使用Queue来进行线程间通信
"""


class Thread2(Thread):
    def __init__(self, queue):
        Thread.__init__(self)
        self.queue = queue

    def run(self):
        self.queue.put(1)
class Thread3(Thread):
    def __init__(self, queue):
        Thread.__init__(self)
        self.queue = queue

    def run(self):
      data=  self.queue.get(1)
      print(data)

queue=Queue()
t2=Thread2(queue)
t2.start()
t3=Thread3(queue)
t3.start()

线程间通知**

当需要一个线程任务完成后通知另一个线程时，可以使用Event
1.和锁类似，wait函数式一个阻塞方法

"""
使用Event函数进行线程间事件通知
"""
from threading import Event

def waitMethod(e):
    print("haha")
    ###等待其他线程通知
    e.wait()
    print("wait finish")

def startMethod(e):
    print("start method")
    ###通知其他线程
    e.set()
event=Event()
t4=Thread(target=waitMethod,args=(event,))
t5=Thread(target=startMethod,args=(event,))
t4.start()
t5.start()
event.clear()

多进程和多进程通信

1.使用Pipe来进行进程间通信，Pipe是一个双向管道，同时创建两个管道对象，c1发送的只能由c2来接收

"""
在同一个进程内，多个线程的执行 需要获得GIL锁的同意，哪个线程获得了锁，哪个线程可以执行
"""
from multiprocessing import Process,Pipe
import queue
def p1(c):
    print("receive a num ")
    result=c.recv()
    print(result)
    c.send(result*2)
###Pipe 创建一个双向的管道 c1 send的  c2可以receive到
c1,c2=Pipe()

Process(target=p1,args=(c2,)).start()
c1.send(10)
print(c1.recv())