python 笔记 ——多任务编程

目录

1.多任务编程：

1.1 线程 

1.2 进程

---

1.多任务编程：

多线程介绍：多任务执行：多进程多线程介绍_使用一个操作系统线程实现主动切换的多个执行流-CSDN博客

多任务执行方式：

• 并发：在一段时间内交替去执行多个任务（任务数大于cpu的核数）
• 并行：在一段时间内同时一起执行多个任务（任务数小于cpu的核数）

并行：对于多核cpu处理多任务才是真正意义上的一起执行 

1.1 线程 

线程子类重写：python：threading.Thread类的使用详解_threading.调用的方法 回调-CSDN博客

 socket与threading的使用:python实现socket+threading处理多连接_python实现socket+threading处理多连接-csdn博客-CSDN博客

 threading daemon:谈谈python threading daemon-CSDN博客

库：

import threading

 函数：

dance_process = threading.Thread(group="指定线程组", 
                        target="执行目标任务名", 
                        name="线程名字", 
                        args="元组传参"，
                        kwargs="字典传参"
                        daemon=守护线程True/False)

#线程是无序的，具体哪个进程是由操作系统调度决定
    #参数1：group,
    #参数2：target, 执行目标任务
    #参数3：name, 线程名,如果不设置，默认是Process-1, ...
    #参数4：args, 目标任务传参
    #参数5：kwargs, 字典传参
  
Lock = threading.Lock()  # 互斥锁
Lock.acquire()  #上锁
Lock.release()  #释放锁
dance_process.daemon = False #daemon线程：守护线程，后台线程。顾名思义它就是运行在后台执行，并随着程序的退出而退出的。
dance_threading.start() #启动线程
dance_threading.join(2000) #线程等待

1.1.1 上锁

import threading
a = 0
Lock = threading.Lock()  # 互斥锁

def sing():
    Lock.acquire()  #上锁   上锁后只会有一个上锁线程执行，即只有一个锁被锁，无法再锁
    for i in range(1000000):
        global a     # 表示要声明修改全局变量的内存地址
        a += 1
    print("a1:",a)
    Lock.release()  #释放锁

def dance():
    Lock.acquire()
    for i in range(1000000):
        global a
        a += 1
    print("a2:", a)
    Lock.release()

if __name__ == '__main__':
    #子线程执行完会自动销毁
    sing_threading = threading.Thread(target=sing)
    dance_threading = threading.Thread(target=dance)
    sing_threading.start()
    #sing_threading.join() #线程等待 添加后不断会改变print("c:",a)的值，也是线程数据bug的一个解决办法
    dance_threading.start()
    print("c:",a)

#运行结果
c: 0
a1: 1000000    #线程之间共享全局变量
a2: 2000000

1.2 进程

一个进程包含一个线程，一个进程里可以创建多个线程；每启动一个进程，操作系统都会给其分配一定的运行内存资源

daemon:python 多进程daemon_python daemon-CSDN博客

库:

import multiprocessing

函数：

func = multiprocessing.Process(group="指定进程组", 
                        target="执行目标任务名", 
                        name="进程名字", 
                        args="元组传参"，
                        kwargs="字典传参"
                        daemon=守护进程True/False)

#进程是无序的，具体哪个进程是由操作系统调度决定
    #参数1：group,
    #参数2：target, 执行目标任务
    #参数3：name, 进程名,如果不设置，默认是Process-1, ...
    #参数4：args, 目标任务传参
    #参数5：kwargs, 字典传参
    
func.start()  #启动子进程
func.join()  #是否等待子进程执行结束，或执行多少秒
os.getpid()  #在子进程内，可获取子进程编号，主进程同
os.kill(要Kill的进程, 进程编号)  #根据进程编号强制kill 进程
拓展：
Semaphore用来控制对共享资源的访问数量，例如池的最大连接数
Event用来实现进程间同步通信
Queue是多进程安全的队列，可以使用Queue实现多进程之间的数据传递。
Pipe方法返回(conn1, conn2)代表一个管道的两个端
Pool可以提供指定数量的进程

拓展来源：python 多进程daemon_python daemon-CSDN博客

daemon扩展：

import multiprocessing
import time

ia = list()
def add(ia,a,b,c):
    for i in range(10):
        ia.append(i)
        a,b,c = c,b,a
        print("add:", i)
        time.sleep(0.2)
    print("模块add添加数据完成")

def read(ia):
    time.sleep(1)
    print("read:", ia)

def round_1():
    while True:
        print("round in...")
        time.sleep(0.1)
    print("模块round_1添加数据完成")

if __name__ == '__main__':
    add_process = multiprocessing.Process(target=add, args=(ia,1,2,3))
    round_process = multiprocessing.Process(target=round_1)
    read_process = multiprocessing.Process(target=read, kwargs={"ia": ia})

    round_process.daemon = True   #把该进程设置为守护进程，当所有主进程退出时，该进程会自动销毁
    round_process.daemon = True
    round_process.start()
    add_process.start()
    read_process.start()
    add_process.join()
    print(ia)

#运行结果
round in...
add: 0
round in...
round in...
add: 1
round in...
round in...
add: 2
round in...
add: 3
round in...
round in...
add: 4
round in...
round in...
read: []      #进程之间不共享全局变量
add: 5
round in...
round in...
add: 6
round in...
round in...
add: 7
round in...
round in...
add: 8
round in...
round in...
add: 9
round in...
round in...
模块add添加数据完成    #
[]