并发编程

# from multiprocessing import Process,Pipe
# def func(conn1,conn2):
#     msg = conn2.recv()
#     msg2 = conn1.recv()
#     print(msg)
#     print(msg2)
#
# if __name__ == '__main__':
#     conn1,conn2 =Pipe()
#     p=Process(target=func,args=(conn1,conn2))
#     p.start()
#     conn1.send("来造作吧")
#     conn2.send("小伙子你很骚啊")

'''
发送数据时,用管道1发送的,就必须用管道2进行接收
如果在子进程还是用管道1进行接收,就默认表示没有地方进行数据交互
主程序结束,注意管道会出现的2个错误EOFError,OSError'''

#数据共享函数 Manager
# from multiprocessing import Process,Manager,Lock
# def func(dic,loc):
#     loc.acquire()
#     for el in range(10):
#         dic['num'] -= 1
#     loc.release()
# if __name__ == '__main__':
#     m =Manager()
#     loc = Lock()
#     dic = m.dict({'num': 100})
#     lst =[]
#     for i in range(10):
#         p = Process(target=func,args=(dic,loc))
#         lst.append(p)
#         p.start()
#     print(dic['n
#     [pp.join() for pp in lst]um'])

'''首先Manager函数把一个字典进行处理,设置为共享数据,主进程调用Process方法
进行调用,把共享的数据也传输过去.因为主程序很快就会运行完,所有要加join方法,把
开辟的子进程进行等待,子进程通过加锁把数据转换成同步阻塞,牺牲了运行效率,保障了数据安全'''

# import time
# from multiprocessing import Process,Pool
#
# def func(i):
#     num = 0
#     for el in range(5):
#         num += (i+el)
#         print('>>>',num)
# if __name__ == '__main__':
#     pool = Pool(4)
#     start_time = time.time()
#     pool.map(func,range(50))
#     end_time = time.time()
#     print(start_time -end_time)

''''导入Pool函数,同时设定开辟进程为4,利用了Pool函数中的map方法,也是映射的方法,
把0-49的数字分别传输给func函数,进行运算,因为开辟的进程是4,开始就是0,1,2,3
4个数字进行计算,并且Pool函数不用自己定义join和Lock.函数本身封装了这样的属性'''

# import time,os
# from multiprocessing import Process,Pool
# def func(i):
#     num = 0
#     print('%s run' % os.getpid())
#     # for el in range(5):
#     num += i
#     time.sleep(0.5)
#     # print(el)
#     return num
#
# if __name__ == '__main__':
#     pool = Pool(3)
#     for i in range(10):
#         res = pool.apply(func,args=(i,))
#         print(res)
#     print('%s主进程' % os.getpid())

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

# import time
# from multiprocessing import Process,Pool
# def func(i):
#     num = 0
#     for el in range(5):
#         num += (i+el)
#     return num
# if __name__ == '__main__':
#     pol =Pool()
#
#     lst = []
#     for i in range(10):
#         res = pol.apply_async(func,args=(i,))
#         lst.append(res)
#     for ress in lst:
#         print(ress.get())

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

# import time,os
# from multiprocessing import Pool,Process
#
# def func(n):
#     print("子进程的id",os.getpid())
#     return n*n
#
# def call_back_func(m):
#     print('回调函数的id',os.getpid())
#     print(m)
#
# if __name__ == '__main__':
#     pool =Pool()
#     pool.apply_async(func,args=(5,),callback=call_back_func)
#     print('主进程的id',os.getpid())
#     pool.close()
#     pool.join()

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

当前文件路径的获取

import sys
file_obj = sys.modules['__main__']
print(file_obj)