2.

使用Python进行代码编写时，将其设置为科学模式，并在函数前面添加#%%标志，然后也可以达到一个一个代码块的效果。企业可以单独运行某一个部分

隐藏丑陋复杂的硬件接口，提供良好的抽象接口

管理、调度进程，并且将多个进程对硬件的竞争变得有序

2. 多道技术产生背景

针对单核，实现并发

现在的主机一般是多核，那么每个核都会利用多道技术

有 4 个 cpu，运行于 cpu1 的某个程序遇到 io 阻塞，会等到 io 结束再重新调度

会被调度到 4 个 cpu 中的任意一个，具体由操作系统调度算法决定

3. 多道技术空间上的复用：如内存中同时有多道程序

4. 多道技术时间上的复用

复用一个 cpu 的时间片

注意，遇到 io 切，占用 cpu 时间过长也切

核心在于切之前将进程的状态保存下来

这样才能保证下次切换回来时，能基于上次切走的位置继续运行

进程的概念

进程是一个具有一定独立功能的程序关于某个数据集合的一次运行活动

进程是操作系统动态执行的基本单元

在传统的操作系统中，进程既是基本的分配单元，也是基本的执行单元

进程与程序的区别

程序是指令和数据的有序集合，是一个静态的概念。程序可以作为一种软件资料长期存在，是永久的

进程是程序在处理机上的一次执行过程,它是一个动态的概念。进程是有一定生命期的，是暂时的

5. 注意：同一个程序执行两次，就会在操作系统中出现两个进程。所以可以同时运行一个软件，分别做不同的事情也不会混乱，比如可以打开两个Pycharm做不同的事

6. 进程调度

要想多个进程交替运行，操作系统必须对这些进程进行调度

这个调度也不是随即进行的，而是需要遵循一定的法则

由此就有了进程的调度算法：先来先服务调度算法、短作业优先调度算法、时间片轮转法、多级反馈队列

并行和并发

并行是指在一个时间点上，有多个进程在被 cpu 计算，比如赛跑，两个人都在不停的往前跑

并发是指资源有限的情况下，在一个时间段上，有多个进程在被 cpu 计算，交替轮流使用资源

并行与并发的区别

并行是从微观上，也就是在一个精确的时间片刻，有不同的程序在执行，这就要求必须有多个处理器

并发是从宏观上，在一个时间段上可以看出是同时执行的，比如一个服务器同时处理多个 session

进程的三状态

在程序运行的过程中，由于被操作系统的调度算法控制，程序会进入几个状态

就绪

运行

阻塞

2. 举例说明什么是 argv，什么是阻塞

import sys

print(sys.argv)

# 运行结果：

['G:/course_select/进程的概念.py']

# argv 指参数

# sys.argv 是 Python 解释器在运行的时候传递进来的参数

# 首先在cmd输入以下信息：

python G:/course_select/进程的概念.py

# 打印结果：

['G:/course_select/进程的概念.py']

# 然后在cmd中切换路径到G盘，接着输入 python course_select/进程的概念.py

# 打印结果：

['course_select/进程的概念.py']

# 接着，再在cmd中输入：python course_select/进程的概念.py 123 abc

# 打印结果：

['course_select/进程的概念.py', '123', 'abc']

# 因此，以下程序不能在编辑器里运行，只能在 cmd 里面使用 Python 运行本文件

# 然后要在后面加上 aaa bbb

# 就像上面的 python course_select/进程的概念.py 123 abc 一样

if sys.argv[1] == "aaa" and sys.argv[2] == "bbb":

print("登录成功")

else:

print("登录失败")

exit()

print(666)

# 而如果使用input(),其实就是一种阻塞

3. 进程的三状态图

234e05553b4315faa53410e4072c9a16.png

同步异步

同步：形象的说，一件事的执行必须依赖另一件事的结束，强调的是顺序性

异步： 形象的说，两件事情可以同时进行

注意：同步异步和并行、并发没关系

阻塞：等待，比如 input sleep recv accept recvfrom

非阻塞：不等待，start/terminate 都是非阻塞的

阻塞与非阻塞主要是从程序（线程）等待消息通知时的状态角度来说的

可以分为四类：

同步阻塞

异步阻塞

同步非阻塞

异步非阻塞

start/terminate 都是非阻塞的

进程模块

跟进程相关的基本都在这个模块里：multiprocessing

父进程与子进程的对比分析

父进程，比如运行本文件

子进程，运行 Process(target=func).start()

父进程与子进程数据隔离

主进程等待子进程结束之后再结束

子进程和主进程之间默认是异步的

from multiprocessing import Process

import time

def func():

time.sleep(1)

print(666)

if __name__ == "__main__":

# 开启了一个新的进程，在这个新的进程里执行的 func()

Process(target=func).start()

time.sleep(1)

# 主进程

print(777)

# 777

# 666

# 运行结果仔细观察发现有异步的效果

# 也就是说，主进程和新的进程同时执行

3. 上面的示例中为什么要有 if __name__ == "__main__"？其实这是 windows 操作系统开启子进程的方式问题

4. 继续深入

import time

import os

from multiprocessing import Process

def func():

time.sleep(1)

print(666, os.getpid(), os.getppid())

if __name__ == "__main__":

# 代码执行到这里并不代表开启了子进程

p = Process(target=func)

# 开启了一个子进程，并执行func()

p.start()

time.sleep(1)

print(777, os.getpid(), os.getppid())

# 主进程运行的结果

777 12340 1636

# 子进程运行的结果

666 7604 12340

# 由上面两行结果可以得出：

# 利用 os.getpid() 证明两个进程不一样

# 另外每次运行，os.getpid() 结果都不一样

# 但是，12340 是主进程的 id，7604 是子进程的 id

# 1636 是 Pycharm 的 id，排列特点不变

5. 开启多个相同的子进程示例

import time

import os

from multiprocessing import Process

def func():

time.sleep(3)

print(666, os.getpid(), os.getppid())

if __name__ == "__main__":

for i in range(10):

p = Process(target=func)

p.start()

time.sleep(1)

print(777, os.getpid(), os.getppid())

# 这里需要注意一点：Python 程序一直都是逐行执行

# 但是因为这里设置了时间延迟，因此会先执行主程序的代码

# 运行结果：

777 29006 3833 # 暂停 2s 后再有下面的结果

666 29007 29006

666 29009 29006

666 29008 29006

666 29010 29006

666 29013 29006

666 29011 29006

666 29012 29006

666 29014 29006

666 29016 29006

666 29015 29006

# 观察结果发现主进程只运行了一次

# 然后剩下的全是一个子进程重新运行的结果

# 主进程运行完不会结束，它会等子进程全部运行结束

# 注意变量 p 拿到的是最后一个子进程的 id

6. 开启多个不同的子进程示例

import time

import os

from multiprocessing import Process

def func():

time.sleep(2)

print(666, os.getpid(), os.getppid())

def func2():

print(111)

if __name__ == "__main__":

for i in range(3):

p = Process(target=func)

p.start()

for i in range(2):

p = Process(target=func2)

p.start()

time.sleep(1)

print(777, os.getpid(), os.getppid())

# 运行程序时仔细观察结果显示顺序：

111

111

777 29316 3833

666 29319 29316

666 29317 29316

666 29318 29316

7. 给子进程传参示例

from multiprocessing import Process

def func(name):

print(666, name)

if __name__ == "__main__":

p = Process(target=func,args=(777,)) # 注意是一个元组

p.start()

import time

from multiprocessing import Process

def func(num, name):

time.sleep(1)

print(num, "hello", name)

if __name__ == "__main__":

for i in range(10):

p = Process(target=func, args=(i, "abc"))

p.start()

print("主进程")

# 运行结果：

666 777

主进程

0 hello abc

2 hello abc

1 hello abc

3 hello abc

5 hello abc

4 hello abc

6 hello abc

7 hello abc

8 hello abc

9 hello abc

# 多运行几次，发现子进程并不是完全按顺序运行的

# 比如上面先出结果 2 hello abc，再出结果 1 hello abc

8. 子进程可以有返回值吗：不能有返回值，因为子进程函数中的返回值无法传递给父进程

import time

from multiprocessing import Process

def func():

time.sleep(3)

print("这是子进程,3s后才运行")

if __name__ == "__main__":

Process(target=func).start()

print("主进程")

# 运行结果：

主进程

这是子进程,3s后才运行

# 主进程会默认等待子进程结束之后才结束

# 因为父进程要负责回收子进程占用的操作系统资源

相关资源：Python多进程写入同一文件的方法_python多进程写入同意文件-其它...

文章知识点与官方知识档案匹配

Python入门技能树首页概览

194693 人正在系统学习中

点击阅读全文

打开CSDN，阅读体验更佳

Python多进程(一)进程及进程池_程序员-夏天的博客

print("主进程结束") 通过上述代码我们发现,multiprocessing.Process帮我们创建一个子进程,并且成功运行,但是我们发现,在子进程还没执行完的时候主进程就已经死了,那么这个子进程在主进程结束后就是一个孤儿进程,那么我们可以让主进程等待...

Python多进程之Process、Pool、Lock、Queue、Event、Semaphore、Pipe_大 ...

1. Python创建进程类Process python的multiprocessing模块提供了一个创建进程的类Precess,其创建有以下两种方法: 创建Process类的实例,并指向目标函数和传递参数 自定义一个类并继承Process类,重写__init__()和run()方法 ...

python两个进程同时开启只运行了一个_二十二、 深入Python的进程和线程（上篇）...

「@Author： Runsen」进程(Process)和线程(Thread)都是操作系统中的基本概念，它们之间有一些优劣和差异，那么在Python中如何使用进程和线程？CPU计算机的核心是CPU，它承担了计算机的所有计算任务，CPU就像一个工厂，时刻在运行着，而操作系统管理着计算机，负责任务的调度、资源的分配和管理。进程进程是指在系统中能独立运行并作为资源分配的基本单位，它是由一组机器指令、数据...

继续访问

python启动多个进程_Python多处理：只有一个进程正在运行

由于注释表明您希望使用初始化程序和initargs参数传递featureVector.在Unix类型的系统上,这将导致大量的性能提升(即使selLabel中只有1个项目),因为该值将使用os.fork基本上免费传递给子进程.否则,每次调用foo时,featureVector都将被父进程pickle,通过管道传递并由子进程进行unpickled.这将花费很长时间,并且基本上将序列化所有子进程,因为它...

继续访问

python多进程多线程,多个程序同时运行_陈逸飞_p的博客_pyth...

python 模块应用 开发工具 pycharm 实现方法 多任务的实现可以用进程和线程来实现 进程—>线程--->多任务应用 多进程操作 比如下载多个文件, 利用cpu 资源 提高效率 多任务: 同一时间执行多个任务, 比如windows操作系统 执行...

python多进程单例_Python多线程处理实例详解【单进程/多进程】

python — 多线程处理 1、一个进程执行完后,继续下一个进程 root@72132server:~# cd /root/python/multiprocess/ root@72132server:~/python/multiprocess# ls multprocess.py root@72132server:~/python/multiprocess# cat multprocess...

系统编程__2__父子进程的创建和回收

系统编程 这里写的是对于小白来说更多的了解系统编程的文章，有写的不对的地方还恳请各位大佬指出错误，小编一定会多多采纳[手动多谢]。 那么，上一次我们稍微了解了一下关于系统编程的一些主要内容[没有看到的童鞋还请去上一篇文章稍微复习一下噢]。 这节课，我们先来想一想，我们为什么要学系统编程呢？原因很简单，我们要充分的利用CPU的性能，CPU和我们人类不太一样，我们人类大多数情况下，在同一时间，只能完成一件事，而CPU作为无数科学家的心血当然不会这么简单，CPU能够同时进行多个进程，这里的进程我们可以理解成任务，

继续访问

android 10 system/core无法打印log问题

1.关闭重定向 system/core/init/util.cpp --- a/init/util.cpp +++ b/init/util.cpp @@ -454,7 +454,7 @@ static void InitAborter(const char* abort_message) { // SetStdioToDevNull() must be called again in second stage init. void SetStdioToDevNull(char** argv) { ...

继续访问

Python多进程1 一个多进程实例_BBJG_001的博客

下执行,job('主进程step1###')p1=mp.Process(target=job,args=('新进程>>>',))# 创建一个进程# 注意当只有一个参数的时候,一定要在参数后面加一个逗号,因为args需要是一个可以迭代的参量p1.start()# 开始执行新进程# p...

热门推荐 python多进程多线程,多个程序同时运行

python 多线程 多进程同时运行 多任务要求 python 基础语法 python 文件目录操作 python 模块应用 开发工具 pycharm 实现方法 多任务的实现可以用进程和线程来实现 进程—>线程---->多任务应用 多进程操作 比如下载多个文件, 利用cpu 资源 提高效率 多任务： 同一时间执行多个任务, 比如windows操作系统 执行方式有两种( 表现形式 ) 并发 在单核cpu中: 在一段时间内交替执行多个任务, 例如单核cpu 处理多任务, 操作系统让各个任务交

继续访问

fork()函数

多进程通信 fork()函数

继续访问

（1/7）Electron教程（一）什么是 Electron，由来、适用场景 和 Electron 的环境搭建（1/7）

最近自己有个小的需求，是做一个能编辑本地特定文本的工具，需要跨平台， Windows 和 macOS，这样，如果用原生开发的话，Windows 就要用c#macOS 就要用swift，学习成本高，并且学完用处也不是很大。我本身是前端开发的，发现了这个electron能满足我的需求，跨平台运行，内部是 js 驱动的，简直就是如鱼得水。顺便把学习的经历写出来，分享需要的人，我会按标题序号渐进式地编写内容。electron。...

继续访问

fork()详解

<一>： fork()函数用来创建新的进程，它的特点是调用一次返回两次( 在原来的进程中返回新进程的 PID（新进程的 PID 肯定不等于 0）， 在新进程中返回为 0.) 函数原型：pid_t fork(void)； pid_t getpid()获取当前进程的 pid 值。 pid_t getppid()获取当前进程的父进程 pid 值。 图一 如图一所...

继续访问

fork()函数详解

目录 1.基本了解： 2.fork函数的了解： 3.僵死进程： 1.基本了解： 一个进程，包括代码、数据和分配给进程的资源。fork 函数会新生成一个进程，调用 fork 函数的进程为父进程，新生成的进程为子进程。在父进程中返回子进程的 pid，在子进程中返回 0，失败返回-1。 为什么两个进程的fpid不同呢，这与fork函数的特性有关。fork调用的一个奇妙之处就是它仅仅被调用一次，却能够返回两次，它可能有三种不同的返回值： 1）在父进程中，fork返回新创建子进程的进程...

继续访问

Electron在Windows下的环境搭建

Electron作为一种用javascript写桌面程序的开发方式，现在已经被大众接受。下面就介绍如何在windows（>win7）下快速搭建Electron开发环境。 1. nodejs 的安装 从nodejs 下载最新版本的windows安装程序进行安装，我下载的是v6.9.1，安装时一路默认即可，这个安装会把nodejs和npm配置到系统PATH中，这样在命令行的任何位置都可以直接...

继续访问

python多线程pool_Python mutiprocessing多线程池pool操作示例

本文实例讲述了Python mutiprocessing多线程池pool操作。分享给大家供大家参考，具体如下：python — mutiprocessing 多线程 pool脚本代码：root@72132server:~/python/multiprocess# lsmultiprocess_pool.py multprocess.pyroot@72132server:~/python/multi...

继续访问

最新发布 python入门开发学习笔记之守护进程

本节重点 了解守护进程的概念 本节时长需控制在5分钟内 一 守护进程 主进程创建子进程，然后将该进程设置成守护自己的进程，守护进程就好比崇祯皇帝身边的老太监，崇祯皇帝已死老太监就跟着殉葬了。 关于守护进程需要强调两点： 其一：守护进程会在主进程代码执行结束后就终止 其二：守护进程内无法再开启子进程,否则抛出异常：AssertionError: daemonic processes are not allowed to have children 如果我们有两个任务需要并发执行，那么开一个主进程和一个子进程分

继续访问

用python进行多进程编程时，只有主进程可以运行，子进程貌似没有运行是什么原因？

找了半天，原来是这个原因！这是因为multiprocessing模块在交互模式是不支持的，在 cmd 里头输入 python xxx.py 来运行起来，你就可以看到子进程的执行了。

继续访问

linux中fork() 函数详解

fork入门知识 一个进程，包括代码、数据和分配给进程的资源。fork（）函数通过系统调用创建一个与原来进程几乎完全相同的进程，也就是两个进程可以做完全相同的事，但如果初始参数或者传入的变量不同，两个进程也可以做不同的事。 一个进程调用fork（）函数后，系统先给新的进程分配资源，例如存储数据和代码的空间。然后把原来的进程的所有值都复制到新的新进程中，只有少数值与原来的进程的值不同。相当于克隆了...

继续访问

Windows版 Node.js 安装详解以及Electron安装

Windows Node.js 安装详解以及Electron安装详解，示例版本：node v10.15.0/npm6.4.1 介绍： 简单的说 Node.js 就是运行在服务端的 JavaScript。 Node.js 是一个基于Chrome JavaScript 运行时建立的一个平台。 Node.js是一个事件驱动I/O服务端JavaScript环境，基于Google的V8引擎，V8引擎执...

继续访问

Electron 简介

本教程我们来学习 Electron 的基础知识，下面我们先来学习一下什么是 Electron。 Electron是什么 Electron 是是 GitHub 开发的一个开源框架。它允许使用 Node.js（作为后端）和 Chromium（作为前端）完成桌面 GUI 应用程序的开发。 Electron 可以用于构建具有 HTML、CSS、JavaScript 的跨平台桌面应用程序，它通过将 Chromium 和 node.js 合同一个运行的环境中来实现这一点，应用程序可以打包到 Mac、Windows 和

继续访问

Election的优缺点

优点 原生的接口（菜单、消息提醒、系统托盘等）。 上手难度低。能够使用react、vue等前端框架，能方便地迁移前端组件，构建出漂亮的桌面应用。 方便热更新 调试和测试方便 Electron使用node.js。因此，您可以导入Chrome应用程序中不容易使用的许多模块 Electron文档要好得多，尽管它是一个更年轻的平台 缺点 不适合开发轻量级的应用。即使一个electron的项目框架，也包含chromium内核，打包完接近200G。 相比c++开发的桌面应用，性能远远不如后者。 启动速

继续访问

[electron]终极奥义 五千字教程丢给你

前言 本文包含打包、自动更新、简易API、调试、进程通信等相关知识点，内容较多，可能会引起不适，请酌情查看（手动滑稽）。 electron 简介 electron是由Github开发，是一个用Html、css、JavaScript来构建桌面应用程序的开源库，可以打包为Mac、Windows、Linux系统下的应用。 electron是一个运行时环境，包含Node和Chromium，可以理解成把we...

继续访问

深入理解Java中的wait() 方法

使用场景 当某个线程获取到锁后，发现当前还不满足执行的条件，就可以调用对象锁的wait方法，进入等待状态。 直到某个时刻，外在条件满足了，就可以由其他线程通过调用notify()或者notifyAll()方法，来唤醒此线程。 这篇文章将侧重于讨论wait()方法对于线程状态的影响，以及被唤醒后线程的状态变更。 条件 只有已经获取锁的线程，才可以调用锁的wait方法，否则会抛出异常IllegalMonitorStateException。 比如下面的代码，A获得了锁后，主动调用wait方法释放锁和

继续访问

用Electron开发桌面应用的避坑指南(文末送书)

送一波高质量Web开发图书，送5本书籍，随你挑。抽奖规则见本文最后！抽奖规则见本文最后！抽奖规则见本文最后！如今，Electron 领域发生了重大的变革，Electron 版本更新换代极快...

继续访问

python多进程只有一个进程在执行

python两个进程同时开启只运行了一个。

需要使用新的函数as_completed()来实现，可以把多个并发的协程一起给它，但它把返回的结果变成一个生成器，每次返回一个协程的结果，与函数wait()一样，执行协程是乱序的，不会等所有协程执行完成才返回。例子：

async def phase(i):

    print('in phase {}'.format(i))

    await asyncio.sleep(0.5 - (0.1 * i))

    print('done with phase {}'.format(i))

    return 'phase {} result'.format(i)

async def main(num_phases):

    print('starting main')

    phases = [

        phase(i)

        for i in range(num_phases)

    ]

    print('waiting for phases to complete')

    results = []

    for next_to_complete in asyncio.as_completed(phases):

        answer = await next_to_complete

        print('received answer {!r}'.format(answer))

        results.append(answer)

    print('results: {!r}'.format(results))

    return results

event_loop = asyncio.get_event_loop()

try:

    event_loop.run_until_complete(main(3))

finally:

    event_loop.close()

结果输出如下：starting main

waiting for phases to complete

in phase 2

in phase 1

in phase 0

done with phase 2

received answer 'phase 2 result'

done with phase 1

received answer 'phase 1 result'

done with phase 0

received answer 'phase 0 result'

results: ['phase 2 result', 'phase 1 result', 'phase 0 result']