多任务的结束

1 并发和并行的理解?

并发: 在一段时间内交替的去执行任务

并行:对于多核cpu处理多任务,操作系统给每一个cpu安排一个执行的软件,多个内核是真正的一起执行的软件。

2 多进程的使用:

正常的情况下是fn函数执行完以后才会执行fn1这个函数,但是fn这个函数又是一个死递归,所以fn1这个函数就无法执行。

def fn():
    while True:
        print(1111)
        time.sleep(1)


def fn1():
    print(222)

fn()
fn1() 

这里执行的就是 1111  11111 。。。

创建多进程,来让函数同时执行
import multiprocessing

import time

def fn():
    while True:
        print(1111)
        time.sleep(1)


def fn1():
    print(222)

if __name__ == '__main__':

    f = multiprocessing.Process(target=fn)
    f1 = multiprocessing.Process(target=fn1)
    f.start()
    f1.start()

这里的代码执行的顺序就是  1111  222  1111 11111 ..., 进程的执行是无序的,具体哪个函数先执行要看操作系统先运行哪一个。

3 获取当前主进程的编号 

if __name__ == '__main__':
    print(multiprocessing.current_process()) # <_MainProcess name='MainProcess' parent=None started>

4 获取当前子进程的编号

if __name__ == '__main__':

    f = multiprocessing.Process(target=fn)
    print(f)  # <Process name='Process-1' parent=18264 initial>
    f1 = multiprocessing.Process(target=fn1)
    print(f1)  # <Process name='Process-2' parent=18264 initial>
    f.start()
    f1.start()

5 修改子进程编号的名称: name 

if __name__ == '__main__':

    f = multiprocessing.Process(target=fn,name="AAA")

    print(f)  # <Process name='AAA' parent=12316 initial>

    f1 = multiprocessing.Process(target=fn1,name='BBB')

    print(f1)  # <Process name='BBB' parent=12316 initial>

6 第二种获取当前子进程的编号:

def fn():
    print(multiprocessing.current_process())  # <Process name='Process-1' parent=23068                                                                                started>
    while True:
        print(1111)
        time.sleep(1)

7 获取当前进程的父进程标号

def fn():
    print(os.getppid())  # 获取当前父进程的标号
    while True:
        print(1111)
        time.sleep(1)

8 根据进程的id编号 杀死自己的进程 :

def fn3():
    while True:
        print('333')
        time.sleep(2)
        os.kill(os.getpid(),9)  #根据当前进程的id编号 杀死自己的进程

9 进程传参:args   kwargs

f = multiprocessing.Process(target=fn,args=('ls',20))
f1 = multiprocessing.Process(target=fn1,kwargs={'name':'zs'})

  f2 = multiprocessing.Process(target=fn1,args = ('ls'), kwargs={'age':12})

10  子进程之间不会共享全局的数据

import multiprocessing
import time

list1 = []

def fn():
    for i in range(10):
        list1.append(i)
        time.sleep(1)

def fn1():
    for i in range(10):
        print(list1)  # [] []  [] 
        time.sleep(1)


if __name__ == '__main__':
    m1 = multiprocessing.Process(target=fn)
    m2 = multiprocessing.Process(target=fn1)
    m1.start()
    m2.start()

11 强制让某一个进程先执行完 在执行下面的进程

if __name__ == '__main__':
    m1 = multiprocessing.Process(target=fn)
    m2 = multiprocessing.Process(target=fn1)
    m1.start()
    
    m1.join()  # 让上一个进程先执行 这个进程执行完之后再执行下一个进程

    m2.start()

12 把子进程设置为守护主进程 主进程退出子进程直接销毁

if __name__ == '__main__':

m1 = multiprocessing.Process(target=fn)

m1.daemon = True  # 把子进程设置为守护主进程 主进程退出子进程直接销毁

m1.start()

第二种方式 退出主进程之前先让子进程销毁

m1.terminate()

13 关于线程:

一个进程有多个线程 也是有一个主线程。 线程是用来执行代码的。

import threading
import time

def fn():
    print('1')

def fn1():
    print('2')

if __name__ == '__main__':
    f = threading.Thread(target=fn)
    f1 = threading.Thread(target=fn1)
    f.start()
    f1.start()

14 获取当前线程的编号

第一种方式:
print(threading.current_thread()) # 获取主线程的编号
def fn():
    print(threading.current_thread()) #  <Thread(Thread-1 (fn), started 26388)>
    print('1')

第二种方式:
if __name__ == '__main__':
    f = threading.Thread(target=fn)
    f1 = threading.Thread(target=fn1)
    print(f) # <Thread(Thread-1 (fn), initial)>
    print(f1) # <Thread(Thread-2 (fn1), initial)>

15 线程传递参数:

def fn(num):
    print(threading.current_thread()) #  <Thread(Thread-1 (fn), started 26388)>
    print(num)

def fn1(name):
    print('2')

if __name__ == '__main__':
    f = threading.Thread(target=fn,args=(1))
    f1 = threading.Thread(target=fn1,kwargs={'name':'zs'})

16 子线程会等主线程结束之后再结束

17 子线程守护主线程 主线程结束子线程销毁 :daemo=True 主线程不会等子线程执行完再结束了

if __name__ == '__main__':  
    threading.Thread(target=fn,daemon=True).start()
    time.sleep(2)
    print('223')

   也可以通过设置 f1.setDaemon(True) 守护父线程

   if __name__ == '__main__':

   f1 = threading.Thread(target=fn)

   f1.setDaemon(True)

   time.sleep(2) print('223')

18 线程之间共享全局的变量

import threading
import time

list1 = []

def fn():
    for i in range(10):
        list1.append(i)
        print(list1,'1')


def fn1():
    for i in range(10,20):
        list1.append(i)
        print(list1,'2') #[0, 1, 2, 3, 10, 11, 12, 13, 4, 5, 6, 7, 14, 15, 8, 16, 17, 9, 18, 19]

if __name__ == '__main__':
    threading.Thread(target=fn).start()
    threading.Thread(target=fn1).start()

19 让当前的线程先执行完再执行下一个线程 f.join()

if __name__ == '__main__':
    f = (threading.Thread(target=fn))
    f.start()
    f.join()
    f1 = threading.Thread(target=fn1).start()

20 线程之间共享全局变量数据错误的问题

解决方法就是 线程等待jion() 还有就是互斥锁

import threading
import time

lock = threading.Lock()  创建锁

list1 = []

def fn():
    lock.acquire() 上锁
    for i in range(10):
        list1.append(i)
        print(list1,'1')
    lock.release() 解锁


def fn1():
    lock.acquire() 上锁
    for i in range(10,20):
        list1.append(i)
        print(list1,'2')
    lock.release() 解锁

if __name__ == '__main__':
    f = (threading.Thread(target=fn))
    f.start()
    f1 = threading.Thread(target=fn1).start()

21 死锁等对方一直释放锁的情景:比如判断条件不符合直接退出了条件没有释放锁

import threading
lock = threading.Lock()

def fn(index):
    lock.acquire()
    my_list = [1,2,3,4]
    if index>=len(my_list):
        print(index)
        lock.release()  # 在不符合条件之前解锁
        return
    value = my_list[index]
    print(value)
    lock.release()

if __name__ == '__main__':
    for i in range(10):
        print(i)
        f = threading.Thread(target=fn,args=(i,))
        f.start()

  • 3
    点赞
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值