wap医院网站建设,被网站开发公司坑,国家重点建设网站,长沙百度搜索网站排名文章目录 多进程多进程使用流程导入包Process进程类说明 获取进程编号目的常用操作 获取进程名进程注意点进程之间不共享全局变量主进程会等待子进程结束之后再结束设置守护主进程 多线程threading模块线程注意点线程之间执行是无序的主线程会等待所有的子线程执行结束在结束线… 文章目录 多进程多进程使用流程导入包Process进程类说明 获取进程编号目的常用操作 获取进程名进程注意点进程之间不共享全局变量主进程会等待子进程结束之后再结束设置守护主进程 多线程threading模块线程注意点线程之间执行是无序的主线程会等待所有的子线程执行结束在结束线程之间共享全局变量线程之间共享全局变量数据出现错误问题 多线程共享全局变量问题线程等待互斥锁 多进程
多进程使用流程
导入包
import multiprocessingProcess进程类说明
语法
Process({group [, target [, name [, args [,kwargs]]]]})
group指定进程组目前只能使用None
target执行的目标任务名
name进程名字
args以元组形式给执行任务传参
kwargs以字典形式给执行任务传参Process创建实例对象的常用方法 start()创建子进程join()等待子进程执行结束terminate()不管任务是否完成立即终止子进程 Process创建的实例对象的常用属性 name当前进程的别名默认为Process-NN为从1开始递增的整数 代码示例
# *_*coding:utf-8 *_*
import multiprocessing
import timedef sing(msg):for i in range(5):print(f{msg})time.sleep(1)def dance(msg):for i in range(5):print(f{msg})time.sleep(1)if __name__ __main__:# 单进程需要至少10s钟完成# sing(sing)# dance(dance)# 三个进程1个主进程2个子进程# 创建子进程方式# target为任务名创建一个sing线程,通过元组方式传参sing_obj multiprocessing.Process(targetsing, args(sing sing sing,))# target为任务名创建一个dance线程通过字段方式传参dance_obj multiprocessing.Process(targetdance, kwargs{msg: dance dance dance})# 启动两个线程sing_obj.start()dance_obj.start()获取进程编号
目的
获取进程编号的目的是验证主进程与子进程的关系得知子进程是由哪个主进程创建出来的
常用操作
获取当前进程编号:os.getpid()回去当前父进程编号:os.getppid代码示例
# *_*coding:utf-8 *_*
import multiprocessing
import osdef sing():# 获取当前进程编号print(sing当前进程编号: , os.getpid())# 获取当前进程print(sing 当前进程: , multiprocessing.current_process())# 获取当前父进程编号print(sing父进程编号: , os.getppid())if __name__ __main__:# 获取主进程IDprint(main当前进程编号: , os.getpid())obj multiprocessing.Process(targetsing)obj.start()获取进程名
创建子进程时使用name给子进程起名代码示例
# *_*coding:utf-8 *_*
import multiprocessingdef sing():# 获取当前进程名print(sing 当前进程: , multiprocessing.current_process())if __name__ __main__:# 获取主进程IDobj multiprocessing.Process(targetsing, nametest_dance)obj.start()进程注意点
进程之间不共享全局变量
进程是分配资源的最小单位每个进程都会有自己的独立空间创建子进程会对主进程资源进行拷贝也就是说子进程是主进程的一个副本之所以进程之间不共享全局变量是因为操作的不是一个进程里面的全局变量只不过不同进程里面的全局变量名字相同而已代码示例
# *_*coding:utf-8 *_*
import multiprocessing
import time# 定义全局变量
g_num 0def my_read():print(my_read, g_num)def my_write():# 向全局变量中写数据global g_numg_num 10print(my_write, g_num)if __name__ __main__:# 创建子进程read_obj multiprocessing.Process(targetmy_read)write_obj multiprocessing.Process(targetmy_write)# 开启子进程write_obj.start()# 保证全局变量数据被写入time.sleep(1)read_obj.start()主进程会等待子进程结束之后再结束
代码示例
# *_*coding:utf-8 *_*
import multiprocessing
import timedef func():for i in range(5):time.sleep(0.3)print(func())if __name__ __main__:obj multiprocessing.Process(targetfunc)obj.start()print(main)exit(0)设置守护主进程
设置守护主进程的目的是主进程退出子进程销毁不让主进程等待子进程去执行设置守护主进程方式子进程对象.daemontrue销毁子进程方式子进程对象.terminate()注意需要在子进程start之前设置
多线程
线程是使用资源的最小单位依附于进程
threading模块
Python的多线程可以通过threading模块来实现语法
import threadingthread_obj threading.Thread([group[, target[, name[, args[, kwargs]]]]])
group预留参数暂未使用
target执行的目标任务名
args以元组的方式给执行任务传参
kwargs以字典的方式给执行任务传参
name线程名一般不设置# 启动线程
thread_obj.start()代码示例
# *_*coding:utf-8 *_*import time
import threadingdef sing(msg):while True:print(f{msg})time.sleep(1)def dance(msg):while True:print(f{msg})time.sleep(1)if __name__ __main__:# 创建一个sing线程,通过元组方式传参sing_thread_obj threading.Thread(targetsing, args(sing sing sing,))# 创建一个dance线程通过字段方式传参dance_thread_obj threading.Thread(targetdance, kwargs{msg: dance dance dance})# 启动两个线程sing_thread_obj.start()dance_thread_obj.start()线程注意点
线程之间执行是无序的
代码示例
# *_*coding:utf-8 *_*
import threading
import timedef func():# sleep的时候CPU是空闲的所有创建出来的线程都在等待CPU的执行time.sleep(0.3)# 实际执行线程位置print(threading.current_thread())if __name__ __main__:for _ in range(5):# 创建线程位置my_func threading.Thread(targetfunc)my_func.start()主线程会等待所有的子线程执行结束在结束
未设置守护线程代码示例
# *_*coding:utf-8 *_*
import threading
import timedef func():for _ in range(5):time.sleep(0.2)print(func)if __name__ __main__:obj threading.Thread(targetfunc)obj.start()time.sleep(0.5)print(main over)设置守护线程 守护线程就是主线程退出子线程销毁不再执行 设置方式 方式一threading.Thread(target方法名, daemonTrue)方式二线程对象.setDaemon(True) 代码示例
# *_*coding:utf-8 *_*
import threading
import timedef func():for _ in range(5):time.sleep(0.2)print(func)if __name__ __main__:# # 不设置守护线程方式# obj threading.Thread(targetfunc)# # 设置守护线程方式一# obj threading.Thread(targetfunc, daemonTrue)obj threading.Thread(targetfunc)# 设置守护线程方式二obj.setDaemon(True)obj.start()time.sleep(0.5)print(main over)线程之间共享全局变量
# *_*coding:utf-8 *_*
import threading
import timeg_num []def my_read():global g_numprint(my_read: , g_num)def my_write():global g_numfor i in range(5):g_num.append(i)print(my_write: , g_num)if __name__ __main__:print(main start: , g_num)write_obj threading.Thread(targetmy_write)read_obj threading.Thread(targetmy_read)write_obj.start()# 确保write先执行time.sleep(0.1)read_obj.start()print(main finish: , g_num)线程之间共享全局变量数据出现错误问题
代码示例
# *_*coding:utf-8 *_*
import threadingg_num 0def func1():global g_numfor _ in range(1000000):g_num 1print(func1: , g_num)def func2():global g_numfor _ in range(1000000):g_num 1print(func2: , g_num)if __name__ __main__:obj1 threading.Thread(targetfunc1)obj2 threading.Thread(targetfunc2)obj1.start()obj2.start()print(g_num)多线程共享全局变量问题
线程等待
语法子线程.join()功能让主线程等待当前子线程执行完毕在继续向下执行代码示例
# *_*coding:utf-8 *_*
import threadingg_num 0def func1():global g_numfor _ in range(1000000):g_num 1print(func1: , g_num)def func2():global g_numfor _ in range(1000000):g_num 1print(func2: , g_num)if __name__ __main__:obj1 threading.Thread(targetfunc1)obj2 threading.Thread(targetfunc2)obj1.start()obj1.join()obj2.start()obj2.join()print(g_num)互斥锁
对共享数据进行锁定保证同一时刻只能有一个线程去操作基本使用语法
# 创建锁
mutex threading.Lock()
# 上锁
mutex.acquire()
# 释放锁
mutex.release()代码示例
# *_*coding:utf-8 *_*
import threadingg_num 0# 创建锁
mutex threading.Lock()def func1():global g_num# 加锁mutex.acquire()for _ in range(1000000):g_num 1# 释放锁mutex.release()print(func1: , g_num)def func2():global g_num# 加锁mutex.acquire()for _ in range(1000000):g_num 1# 释放锁mutex.release()print(func2: , g_num)if __name__ __main__:obj1 threading.Thread(targetfunc1)obj2 threading.Thread(targetfunc2)obj1.start()obj2.start()
