div id="myTime">

并发编程 

 1 # from multiprocessing import Process,Pipe
 2 # def func(conn1,conn2):
 3 #     msg = conn2.recv()
 4 #     msg2 = conn1.recv()
 5 #     print(msg)
 6 #     print(msg2)
 7 #
 8 # if __name__ == '__main__':
 9 #     conn1,conn2 =Pipe()
10 #     p=Process(target=func,args=(conn1,conn2))
11 #     p.start()
12 #     conn1.send("来造作吧")
13 #     conn2.send("小伙子你很骚啊")
管道
'''
发送数据时,用管道1发送的,就必须用管道2进行接收
如果在子进程还是用管道1进行接收,就默认表示没有地方进行数据交互
主程序结束,注意管道会出现的2个错误EOFError,OSError'''

 1 #数据共享函数 Manager
 2 # from multiprocessing import Process,Manager,Lock
 3 # def func(dic,loc):
 4 #     loc.acquire()
 5 #     for el in range(10):
 6 #         dic['num'] -= 1
 7 #     loc.release()
 8 # if __name__ == '__main__':
 9 #     m =Manager()
10 #     loc = Lock()
11 #     dic = m.dict({'num': 100})
12 #     lst =[]
13 #     for i in range(10):
14 #         p = Process(target=func,args=(dic,loc))
15 #         lst.append(p)
16 #         p.start()
17 #     print(dic['n
18 #     [pp.join() for pp in lst]um'])
数据共享
'''首先Manager函数把一个字典进行处理,设置为共享数据,主进程调用Process方法
进行调用,把共享的数据也传输过去.因为主程序很快就会运行完,所有要加join方法,把
开辟的子进程进行等待,子进程通过加锁把数据转换成同步阻塞,牺牲了运行效率,保障了数据安全'''

 1 # import time
 2 # from multiprocessing import Process,Pool
 3 #
 4 # def func(i):
 5 #     num = 0
 6 #     for el in range(5):
 7 #         num += (i+el)
 8 #         print('>>>',num)
 9 # if __name__ == '__main__':
10 #     pool = Pool(4)
11 #     start_time = time.time()
12 #     pool.map(func,range(50))
13 #     end_time = time.time()
14 #     print(start_time -end_time)
进程池
''''导入Pool函数,同时设定开辟进程为4,利用了Pool函数中的map方法,也是映射的方法,
把0-49的数字分别传输给func函数,进行运算,因为开辟的进程是4,开始就是0,1,2,3
4个数字进行计算,并且Pool函数不用自己定义join和Lock.函数本身封装了这样的属性'''


 1 # import time,os
 2 # from multiprocessing import Process,Pool
 3 # def func(i):
 4 #     num = 0
 5 #     print('%s run' % os.getpid())
 6 #     # for el in range(5):
 7 #     num += i
 8 #     time.sleep(0.5)
 9 #     # print(el)
10 #     return num
11 #
12 # if __name__ == '__main__':
13 #     pool = Pool(3)
14 #     for i in range(10):
15 #         res = pool.apply(func,args=(i,))
16 #         print(res)
17 #     print('%s主进程' % os.getpid())
进程的同步方法

'''
主程序定义了三个子进程,0-9的数字传给了func进行运算.因为属于同步进程
func里面的for循环不会开辟内存空间去运行它.所有的运算就在定义的三个子进程
中,子进程全部运行完,再运行主程序的逻辑'''

 

 1 # import time
 2 # from multiprocessing import Process,Pool
 3 # def func(i):
 4 #     num = 0
 5 #     for el in range(5):
 6 #         num += (i+el)
 7 #     return num
 8 # if __name__ == '__main__':
 9 #     pol =Pool()
10 #
11 #     lst = []
12 #     for i in range(10):
13 #         res = pol.apply_async(func,args=(i,))
14 #         lst.append(res)
15 #     for ress in lst:
16 #         print(ress.get())
进程的异步方法

'''和同步方法的区别就是调用的函数为apply_asyns,同时取得返回值的时候
要调用get方法取值,不然打印出来是一串内存地址.异步方法每个进去的数字
都会进行逻辑运算同时效率也会比同步方法要高'''

 

 1 # import time,os
 2 # from multiprocessing import Pool,Process
 3 #
 4 # def func(n):
 5 #     print("子进程的id",os.getpid())
 6 #     return n*n
 7 #
 8 # def call_back_func(m):
 9 #     print('回调函数的id',os.getpid())
10 #     print(m)
11 #
12 # if __name__ == '__main__':
13 #     pool =Pool()
14 #     pool.apply_async(func,args=(5,),callback=call_back_func)
15 #     print('主进程的id',os.getpid())
16 #     pool.close()
17 #     pool.join()
回调函数

'''程序都是在主程序中运行的,不过回调函数要手动定义close以及
join的方法,保障回调函数的结果能够显现出来.因为不确定你的子进程函数
中定义的函数的执行效率,所有函数在封装的时候没有考虑定义close以及join'''


当前文件路径的获取
1 import sys
2 file_obj = sys.modules['__main__']
3 print(file_obj)


 






            

            
posted @ 
2018-11-29 16:37 
lowen107 
阅读(114) 
评论(0) 
编辑 
收藏 
举报