多线程和多进程

1.多线程

1.创建线程的两种方式

语法：

thread.Thread(group=Nore,targt=None,args=(),kwargs={},*,daemon=None)
~group：必须为None，于ThreadGroup类相关，一般不使用。
~target：线程调用的对象，就是目标函数。
~name：为线程起这个名字。
~args：为目标函数传递关键字参数，字典。
~daemon（守护进程）：用来设置线程是否随主线程退出而退出。

函数创建线程

import time
import threading
def test (x,y):
 for i in range(x,y):
     time.sleep(1)
     print(i)
thread1 = threading.Thread(name='t1',target= test,args=(1,10))
thread2 = threading.Thread(name='t2',target= test,args=(11,20))
thread1.start()   #启动线程1
thread2.start()   #启动线程2

 类创建线程

import time
import threading
class mythread(threading.Thread):
  def run(self):
    for i in range(1,10):
      print(i)
      time.sleep(1)
thread1 = mythread()
thread2 = mythread()
thread1.start()
thread2.start()

2.主线程

#创建线程时有一个damon属性，用它来判断主线程。当daemon设置False时，线程不会随主线程退出而退出，主线程会一直等着子线程执行完;。当daemon设置True时，线程会随主线程退出而退出，主线程结束其他的子线程会强制退出。
import time
import threading
def tes1():
 time.sleep(10)
 for i in range(10):
  print(i)
thread1 = threading.Thread(target=tes1,daemon=False)
thread1.start()
print('主线程完成了')

3.阻塞线程

一个线程中调用另一个线程的join方法，调用者被阻塞，直到调用线程被终止。 

#join(timeout-=None)
#timeout 参数指定调用者等待多久，没有设置时，就一直等待被调用线程结束被调用线程结束。其中，一个线程可以被join多次调用。

import time
import threading
def tes1():
 time.sleep(5)
 for i in range(10):
  print(i)
thread1=threading.Thread(target=tes1)
thread1.start()
thread1.join()
print('主线程完成了')

2.多进程

1.创建多进程

import multiprocessing
import time
def drink():
    for i in range(3):
        print("喝汤……")
        time.sleep(1)
def eat():
    for i in range(3):
        print("吃饭……")
        time.sleep(1)
if __name__ == '__main__':
    # target:指定函数名
    drink_process = multiprocessing.Process(target=drink)
    eat_process = multiprocessing.Process(target=eat)

    drink_process.start()
    eat_process.start()

2.带参多进程

#args使用方式
#进程对象 = multiprocessing.Process(target=*,args=(*,))

#kwargs使用方式
#进程对象 = multiprocessing.Process(target=*,kwargs={"变量名": 变量值})

import time
import multiprocessing
def eat(num, name):
    for i in range(num):
        print(name + "吃一口……")
        time.sleep(1)
def drink(num, name):
    for i in range(num):
        print(name + "喝一口……")
        time.sleep(1)
if __name__ == '__main__':
    # target：指定执行的函数名
    # args:使用元组方式给指定任务传参
    # kwargs:使用字典方式给指定任务传参
    eat_process = multiprocessing.Process(target=eat, args=(3, "阿giao"))
    drink_process = multiprocessing.Process(target=drink, kwargs={"num": 4, "name": "阿giao"})

3.进程编号id

• os.getpid() 获取当前进程编号。
• os.getppid() 获取当前父进程编号。

import time
import multiprocessing
import os
def dance():
    # 获取子进程id，因为当前函数就是子进程
    print('dance子进程id:',os.getpid())
    # 获取dance子进程的父进程
    print('dance的父进程:',os.getppid())
    for i in range(5):
        time.sleep(1)
        print("跳舞",i)
def sing():
    # 获取子进程id
    print('sing子进程id:',os.getpid())
    # 获取sing子进程的父进程
    print('sing的父进程：',os.getppid())
    for i in range(5):
        time.sleep(1)
        print("唱歌",i)
if __name__ == '__main__':
    # 获取当前主进程的id编号
    print('主进程id:',os.getpid())
    my_dance = multiprocessing.Process(target=dance)
    my_sing = multiprocessing.Process(target=sing)
    my_sing.start()
    my_dance.start()

3.进程池

import time
from multiprocessing import Pool
import os


# 获取CPU核心数
# cpu_cores = os.cpu_count()

# print(f"CPU核心数: {cpu_cores}")
def tes1(max):
    print('进程id{}，传入参数{}'.format(os.getpid(),max))
    time.sleep(3)
if __name__ =='__main__':
    pool = Pool(processes=3)
    for i in range(100):
        pool.apply_async(tes1,args=(i,))
    print('完成')
    pool.close()
    pool.join()