关键词：

文章目录

• 1. 进程
• • 1.1. 系统原生 OS 模块, 创建进程
  • 1.2. multiprocessing 模块
  • • 1.2.1. Process 单进程
    • 1.2.2. Pool 进程池
  • 1.3. subprocess 模块 使用外部子进程
• 2. 线程
• • 2.1. threading 模块, 创建线程
  • 2.2. 锁 LOCK
  • 2.3. ThreadLocal 模块, 跨函数使用值

1. 进程

线程是最小的执行单元，而进程由至少一个线程组成
这部分可能会多一些, 写JS写的比较多, 接触进程还是在上学搞java的时候.

1.1. 系统原生 OS 模块, 创建进程

fork函数是UNIX或类UNIX中的分叉函数，fork函数将运行着的程序分成2个（几乎）完全一样的进程，每个进程都启动一个从代码的同一位置开始执行的线程


https://baike.baidu.com/item/fork/7143171?fr=aladdin

子进程永远返回0，而父进程返回子进程的ID.

import os

print('Process (%s) start...' % os.getpid())

# Only works on Unix/Linux/Mac:
pid = os.fork()
if pid == 0:
    print('I am child process (%s) and my parent is %s.' % (os.getpid(), os.getppid()))
else:
    print('I (%s) just created a child process (%s).' % (os.getpid(), pid))

1.2. multiprocessing 模块

1.2.1. Process 单进程

multiprocessing模块就是跨平台版本的多进程模块. multiprocessing模块提供了一个Process类来代表一个进程对象.

from multiprocessing import Process
import os

# 子进程要执行的代码
def run_proc(name):
    print('Run child process %s (%s)...' % (name, os.getpid()))

# if 块只在主进程执行
if __name__=='__main__':
    print('Parent process %s.' % os.getpid())
    p = Process(target=run_proc, args=('test',))
    print('Child process will start.')
    p.start()
    p.join()
    print('Child process end.')

=========输出=========
Parent process 27582.
Child process will start.
Run child process test (27584)...
Child process end.

start()方法启动
join()方法可以等待子进程结束后再继续往下运行，通常用于进程间的同步

1.2.2. Pool 进程池

创建多个进程

from multiprocessing import Pool
import os, time, random

def long_time_task(name):
    print('Run task %s (%s)...' % (name, os.getpid()))
    start = time.time()
    time.sleep(random.random() * 3)
    end = time.time()
    print('Task %s runs %0.2f seconds.' % (name, (end - start)))

if __name__=='__main__':
    print('Parent process %s.' % os.getpid())
    p = Pool(7)
    for i in range(4):
        print('这是主线程的 i: %s' % i)
        p.apply_async(long_time_task, args=(i,))
    print('Waiting for all subprocesses done...')
    p.close()
    p.join()
    print('All subprocesses done.')

=========输出=========

Parent process 27612.
这是主线程的 i: 0
这是主线程的 i: 1
这是主线程的 i: 2
这是主线程的 i: 3
Waiting for all subprocesses done...
Run task 0 (27617)...
Task 0 runs 0.77 seconds.
Run task 1 (27616)...
Task 1 runs 0.92 seconds.
Run task 3 (27614)...
Task 3 runs 1.42 seconds.
Run task 2 (27618)...
Task 2 runs 2.85 seconds.
All subprocesses done.

对Pool对象调用join()方法会等待所有子进程执行完毕，调用join()之前必须先调用close()，调用close()之后就不能继续添加新的Process了.

1.3. subprocess 模块 使用外部子进程

subprocess模块可以让我们非常方便地启动一个子进程，然后控制其输入和输出

下面启动一个node看看

import subprocess

print('$ node')
p = subprocess.Popen(['node'], stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
output, err = p.communicate(b'const a = 123\\nconsole.log(11111, a)\\nexit\\n')
print(output.decode('utf-8'))
print('Exit code:', p.returncode)

=========输出=========

$ node
11111 123

2. 线程

多任务可以由多进程完成，也可以由一个进程内的多线程完成. 一个进程至少有一个线程. 线程才是CPU上的执行单元.

2.1. threading 模块, 创建线程

和之前创建进程语法相似, 也是start函数创建, join等待结束

import time, threading

# 新线程执行的代码:
def loop():
    print('thread %s is running...' % threading.current_thread().name)
    n = 0
    while n < 5:
        n = n + 1
        print('thread %s >>> %s' % (threading.current_thread().name, n))
        time.sleep(1)
    print('thread %s ended.' % threading.current_thread().name)

print('thread %s is running...' % threading.current_thread().name)
t = threading.Thread(target=loop, name='LoopThread')
t.start()
t.join()
print('thread %s ended.' % threading.current_thread().name)


=========输出=========


thread MainThread is running...
thread LoopThread is running...
thread LoopThread >>> 1
thread LoopThread >>> 2
thread LoopThread >>> 3
thread LoopThread >>> 4
thread LoopThread >>> 5
thread LoopThread ended.
thread MainThread ended.

主线程实例的名字叫MainThread, 子线程的名字在创建时指定, 也可以不指定. 不指定Python会默认生成一个.

2.2. 锁 LOCK

多线程和多进程最大的不同在于，多进程中，同一个变量，各自有一份拷贝存在于每个进程中，互不影响.
而多线程中，所有变量都由所有线程共享，所以，任何一个变量都可以被任何一个线程修改，因此，线程之间共享数据最大的危险在于多个线程同时改一个变量，把内容给改乱了

我刚刚搜索了下, 其实python有很多种锁, 可是这个网站只介绍了一种, 看来之后还是得找本书看下.

下面是Lock方法的一个例子, acquire获取锁, release释放锁. 一旦一个线程加了锁, 其它线程只能等待, 直到锁被释放,

import threading
# 假定这是你的银行存款:
balance = 0
lock = threading.Lock()
def change_it(n):
    # 先存后取，结果应该为0:
    global balance
    balance = balance + n
    balance = balance - n

def run_thread(n):
    for i in range(1000000):
        change_it(n)

def run_thread_with_lock(n):
    for i in range(100000):
        # 先要获取锁:
        lock.acquire()
        try:
            # 放心地改吧:
            change_it(n)
        finally:
            # 改完了一定要释放锁:
            lock.release()

t1 = threading.Thread(target=run_thread, args=(5,))
t2 = threading.Thread(target=run_thread, args=(8,))
# t1 = threading.Thread(target=run_thread_with_lock, args=(5,))
# t2 = threading.Thread(target=run_thread_with_lock, args=(8,))
t1.start()
t2.start()
t1.join()
t2.join()
print(balance)

=========输出=========

不确定, 但不为0
如果使用这个函数启动线程 run_thread_with_lock 结果正常

2.3. ThreadLocal 模块, 跨函数使用值

ThreadLocal解决了参数在一个线程中各个函数之间互相传递的问题, 每个线程只能读写自己的ThreadLocal变量, 多个线程互不影响.

import threading
    
# 创建全局ThreadLocal对象:
local_school = threading.local()

def process_student():
    # 获取当前线程关联的student:
    std = local_school.student
    print('Hello, %s (in %s)' % (std, threading.current_thread().name))

def process_thread(name):
    # 绑定ThreadLocal的student:
    local_school.student = name
    process_student()

t1 = threading.Thread(target= process_thread, args=('Alice',), name='Thread-A')
t2 = threading.Thread(target= process_thread, args=('Bob',), name='Thread-B')
t1.start()
t2.start()
t1.join()
t2.join()

如果上面代码不用threading的话, 使用全局变量还需要加锁, 或者就是自己手动通过dict模拟.

reference links:

1. 廖雪峰Python学习文档

python学习笔记(代码片段)

...回顾时使用.1.类天下语言是一家,你抄我完,我抄他.没错,python的没啥特殊的,先来个简单的例子:classStudent(object):def__init__(self,name,score):self.name=nameself.score=scoredefg 查看详情

《南溪的python灵隐笔记》——tqdm的学习笔记(代码片段)

1如何使tqdm的输出信息呈现默认颜色tqdm(range(60),file=sys.stdout)#可以通过修改file的输出流来实现这个功能 查看详情

python学习笔记(代码片段)

python学习笔记1.关于#!/usr/bin/envpython这只是告诉操作系统这个脚本的解释、执行程序的具体位置，加了这个头，在”X”类操作系统中就直接可以这样执行脚本了“hello.py”,否则的话就得这样执行“pythonhello.py”.区别：#... 查看详情

python学习笔记之类(代码片段)

学习思维导图：Python类示例：#_*_coding:UTF-8_*_#开发者：zhuozhiwengang#开发时间:2022/5/816:41#文件名称:ClassObjectPython#开发工具:PyCharm#类定义classPerson:"""创建Person类"""#类实例(对象） 查看详情

python学习笔记(代码片段)

文章目录1.基础2.类型2.1.有序集合list和tuple2.2.dict和set3.函数3.1.闭包3.2.匿名函数3.3.装饰器3.4.偏函数4.生成器generator6.其他:6.1.map/reduce/filter/sort6.2.模块供个人学习笔记回顾时使用.1.基础print()输出input()输入r'xxx'xxx字符不需要... 查看详情

python学习笔记(代码片段)

文章目录1.异常2.单测3.读写文件3.1读文件3.2写文件3.3.操作文件和目录4.正则表达式4.1贪婪匹配5.其它5.1.StringIOBytesIO5.2.序列化5.2.1pickle5.2.2.JSON供个人学习笔记回顾时使用.1.异常没啥说的,语法换下而已.下文只会记录一下和JS语法不... 查看详情

python学习笔记(代码片段)

Python学习笔记一、数值1、内置的数值运算操作符2、内置的数值运算函数3、math库①、math库中常用的数学常数②、math库中的部分数值函数③、math库中的部分幂对数函数与三角函数二、字符串1、基本字符串运算符2、内置的字符串... 查看详情

python学习笔记(代码片段)

最近在学习python，使用过程中有个List和dict的声明比较特殊，在此备注下字典是可变对象，初始化一定不能放在for循环前面List声明必须放在程序开头（按道理List也是可变对象，但不知道为什么一定要在刚开始时就声明）代码中... 查看详情

immunitydebugger学习笔记(代码片段)

...：最下方的PyCommands窗格既可以执行调试命令也可以执行python脚步文件。1、PyCommands学习在Immunity中执行Python的方法即使用PyCommands。PyCommands就是一个个python脚本文件，存放在Immunity安装目录的PyCommands文件夹里。每个python脚本都执... 查看详情

python随记学习笔记(代码片段)

--------不断更新中----------⭐️本笔记仅自用，如要学习详细知识，请移步其他文章⭐️内置函数1.filter过滤函数过滤列表元素,第一个参数类型为函数类型lambda表达式可用于指定过滤列表元素的条件。filter(lambdax:x%3==0... 查看详情

《流畅的python》学习笔记及书评(代码片段)

《流畅的python》学习笔记文章目录《流畅的python》学习笔记写在前面1.Python数据模型1.1特殊方法2.序列构成的数组2.1内置序列类型2.2列表推导和生成器表达式2.3元组不仅仅是不可变的列表2.4切片2.5增量赋值2.6排序2.7数组、内存视... 查看详情

《流畅的python》学习笔记及书评(代码片段)

《流畅的python》学习笔记文章目录《流畅的python》学习笔记写在前面1.Python数据模型1.1特殊方法2.序列构成的数组2.1内置序列类型2.2列表推导和生成器表达式2.3元组不仅仅是不可变的列表2.4切片2.5增量赋值2.6排序2.7数组、内存视... 查看详情

《python数据科学手册》学习笔记及书评(代码片段)

《Python数据科学手册》学习笔记文章目录《Python数据科学手册》学习笔记写在前面1.食谱数据库数据找不到的问题2.Seaborn马拉松可视化里时分秒转化为秒数的问题3.scikit-learn使用fetch_mldata无法下载MNIST数据集的问题4.GridSearchCV.grid_s... 查看详情

python学习笔记——if语句(代码片段)

一1个简单的示例cars=['bwn','audi','subaru','toyota']forcarincars:ifcar=='bwn':print(car.upper())else:print(car.title())输出结果为：BWNAudiSubaruToyota二条件测 查看详情

python学习笔记-logging模块（日志）(代码片段)

模块级函数logging.getLogger([name]):返回一个logger对象，如果没有指定名字将返回rootloggerlogging.debug()、logging.info()、logging.warning()、logging.error()、logging.critical()：设定rootlogger的日志级别logging.basicConfig():用默认Formatter 查看详情

python学习笔记(代码片段)

文章目录1.进程1.1.系统原生OS模块,创建进程1.2.multiprocessing模块1.2.1.Process单进程1.2.2.Pool进程池1.3.subprocess模块使用外部子进程2.线程2.1.threading模块,创建线程2.2.锁LOCK2.3.ThreadLocal模块,跨函数使用值1.进程线程是最小的执行单元，... 查看详情

python学习笔记4（函数与模块）(代码片段)

1.Python程序的结构Python的程序由包(package)、模块(module)和函数组成。模块是处理一类问题的集合，由函数和类组成。包是由一系列模块组成的集合。包是一个完成特定任务的工具箱。2.函数2.1函数的定义defsayHello():print‘HelloWorld!‘... 查看详情

《python深度学习》第二章笔记(代码片段)

《Python深度学习》第二章笔记1.第一个神经网络示例2.张量与张量运算张量（输入网络的数据存储对象）张量运算（层的组成要素）逐元素运算广播张量点积张量变形3.神经网络如何通过反向传播与梯度下降进行学... 查看详情