Python-并发-多线程-多进程

多线程

多线程写入到一个文件内
实现方式： 采用 concurrent 和 threading.lock 锁的方式 
           采用threading 模块和 queue的方式
		   
 方案01
   Executor.submit(fn, *args, **kwargs)
    submit返回一个Future对象。
	    其中future.result()的 
	    result方法的作用是拿到调用返回的结果。如果没有执行完毕就会去等待。
	    这里我们使用with操作符，
	      使得当任务执行完成之后，自动执行shutdown函数，而无需编写相关释放代码
    Executor.map(fn, *args, **kwargs)
     map(func, *iterables, timeout=None)  iterables：可以是一个能迭代的对象. 
  回调函数		 

代码示例

from concurrent.futures import ThreadPoolExecutor, as_completed
from threading import Lock
import random
from time import time


def judge_interval(n):
    """ # 多输入参数时，可以将输入组装成list，嵌套的list的方式提取输入参数 """
    if n > 25:
        raise Exception('Big> 25, now %s 
' % n)
    elif 10 <= n <= 25:
        return n*1000
    else:
        return -n


def multi_thread(input_nums, input_file):
    """ 多线程写入到一个文件内"""
    lock = Lock()
    with open(input_file, 'a') as input_file_obj:
        with ThreadPoolExecutor(max_workers=3) as executor:
            future_jobs = {executor.submit(judge_interval, num): num for num in input_nums}
            for job in as_completed(future_jobs):
                try:
                    # result() 方法可以获取任务的返回值
                    data = job.result()
                    # 获取程序的输入
                    data_input = future_jobs[job]
                    print(data_input, data)
                    with lock:
                        input_file_obj.write('input: %s  output: %s.
' % (data_input, data))
                except Exception as e:
                    input_file_obj.write(str(e))


if __name__ == '__main__':
    start_time = time()
    log_file = r'C:Usersowout.txt'
    nums = [random.randint(0, 40) for _ in range(0, 5)]
    multi_thread(nums, log_file)
    end_time = time()
    duration_time = (end_time-start_time)
    print(f"用时 {duration_time}秒")

多线程操作

多线程计算-代码示例
#!/usr/bin/env python3
# -*- coding: UTF-8 -*-
import threading

def my_func(num):
    return print('my_func calldeb by thread {}'.format(num))

def main():
    record =[]
	for i in range(10):
	     t = threading.Thread(target=my_func, args=(i,))
		 record.append(t)
		 t.start()
		 t.join()
if __name__ =="__main__"
     main()

多进程操作

多进程调用shell
import os
import sys
import multiprocessing

def process(n,cmd):
    print("Porcess num {} cmd={}".format(n,cmd))
    os.subprocess(cmd,shell=True)
def multi_process(file_list,i, cmd):
    record  = []
    process_num = len(file_list)
    for i in range(process_num):
        cmd = "touch " + file_list[i]
        p = multiprocessing.Process(target=process, args=(i, cmd))
        p.start()
        record.append(p)
    for p in record:
        p.join()

if __name__ == "__main__":
    file_list = ["a1.txt",'b1.txt','c1.txt','d.txt']
    multi_process(file_list,i, cmd)

参考

详解python中的Lock与RLock https://blog.csdn.net/lgyfhk/article/details/105254079
https://www.zhihu.com/question/37732728/answer/1079020249