A. 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. 进程的三状态图
.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两个进程同时开启只运行了一个。
B. 开机时电脑后台运行的程序太多，如何关闭不需要的程序
电脑开机自启动程序过多，必将影响电脑的开机速度和运行速度。
关闭不需要的开机自启动程序的解决办法如下：
一、利用系统配置实用程序关闭开机自启动程序。本方法适用于明确了解哪些程序不需要开机自运行。
1、点击桌面开始-运行。
2、在弹出的运行窗口的“打开”栏输入：msconfig，并回车。
3、在弹出的系统配置实用程序窗口，点击进入“启动”选项卡，找到不需要开机自启动的程序，去掉前面的勾选，在点击应用和确定。
4、重启电脑，关闭的启动程序将不再开机自动运行。
二、利用安全软件如360安全卫士的优化加速功能关闭不需要的开机自启动程序。本方法适用于不了解哪些程序是否需要开机自运行。
1、下载、安装、运行360安全卫士。如果已经安装，则点击桌面右下角处的360安全卫士图标，打开其主界面。
2、点击运行主界面当中的“优化加速”。
3、根据提示或推荐值自动选择进行优化，以关闭不需要的开机自运行程序。.可能是键盘和鼠标连接有问题或本身就有问题。
2.建议关机之后，重新插一下键盘，内注意，如果容是USB接口的键盘，不要插在蓝色插口上，因为蓝色插口是USB3.0，可能需要驱动支持。确保连接无误后开机，看看自检时键盘灯是否点亮，系统启动完成后，你可以按一下CAPS LOCK键或NUM LOCK键，看看相应的指示灯是否正常，实在不行就需要换一块键盘试试。
3.鼠标和键盘一样，USB鼠标也要插在非蓝色插口，看看鼠标灯是否点亮，系统是否自动安装硬件驱动，如果没有任何反应，灯也不亮，可能鼠标有问题或主板的接口有问题，需要更换鼠标以确认。如果换键盘鼠标都不能解决问题，就极有可能是主板接口有问题了
主机开机后，显示屏,键盘鼠标都没反应有三种情况：
1、内存条松动、接触不好、积尘，都会造成屏幕不显示。
解决方法：拔掉电源，取下内存条，用橡皮除去接口处的浮尘，再用信纸擦拭干净。将内存条对位，双手食指顶住卡座两端，大拇指压住内存条，向下压，听到“咔”紧声，就OK。
2、主板问题。解决方法：拔掉电源，取下主板电池，将CMOS跳线，跳到"colse"位置，保持五分钟以上，安上电池，恢复跳线。就OK。或用回形针让主板上的CMOS正负极导通五分钟以上，也会OK.。
3、电源有问题。 解决方法：拔掉主板电源接口接头，用回形针连通“绿”和“黑”线，如果电源风扇不转动，证明有问题，需更换。
苹果电脑鼠标没反应怎么办
分析原因：
1.有线鼠标损坏
2.USB口损坏，间接意味着主板损坏
3.没有安装驱动或驱动崩溃
解决方案：
1.更换鼠标，有线或无线均可，最好苹果牌的
2.拿到苹果售后送修，国行港行机在保非人为损坏下可以换新，其余的支付费用
3.去苹果官网下载驱动安装，注意选择正确的机型对应的BootCamp驱动
苹果电脑鼠标没反应
苹果电脑鼠标没反应
你们知道鼠标连接电脑后没反应是什么原因吗，下面是学习啦小编带来的关于苹果电脑鼠标没反应是怎么回事的内容，欢迎阅读!
苹果电脑鼠标没反应的原因一：
1.重新启动电脑，让它从新搜索你的蓝牙鼠标
2.确定你在windows下没有使用你的鼠标，如果使用了，从新启动电脑
3.检查你的驱动
4.以上还不行，如果在一年内，带上你的购买凭证，到经销商那里让他给你换新的!
苹果电脑鼠标没反应的原因二：
1内存条松动接触不好积尘，都会造成屏幕不显示
解决方法：拔掉电源，取下内存条，用橡皮除去接口处的浮尘，再用信纸擦拭干净将内存条对位，双手食指顶住卡座两端，大拇指压住内存条，向下压，听到咔紧声，就OK
2主板问题解决方法：拔掉电源，取下主板电池，将CMOS跳线，跳到"colse"位置，保持五分钟以上，安上电池，恢复跳线就OK或用回形针让主板上的CMOS正负极导通五分钟以上，也会OK.
3电源有问题 解决方法：拔掉主板电源接口接头，用回形针连通绿和黑线，如果电源风扇不转动，证明有问题，需更换
苹果电脑鼠标没反应的原因三：
1)USB接口异常
包括USB接口供电问题，接触不良，USB接口损坏等需逐一排查，更换其他USB接口确认原USB接口是否异常;
2)鼠标驱动是否已安装
确认苹果的第三方鼠标驱动是否有安装，是否安装成功，重新安装确认后在确认故障是否还存在
3)BIOS中禁用了USB接口
BIOS禁用USB接口时，键鼠设备接在禁用接口上，开机和进BIOS是可以用的，但系统下无法使用，此时只需进BIOS，将对应的USB port设置为enable状态，保存退出BIOS即可
4)设备管理器中禁用了相应的键鼠
接另一套键鼠开机进系统后，打开设备管理器，确认原键鼠是否是被禁用状态(向下的箭头)，此时右击该设备，选择启用即可
苹果无线鼠标怎么突然没反应了
1、检查电脑是否具蓝牙功能。如果是新的笔记本电脑，首先要查看此笔记本电脑是否具有蓝牙功能。因为，目前...
苹果电脑已经连接了鼠标为什么不能用
一、第一种情形：1、重新启动电脑，让它从新搜索你的蓝牙鼠标。2、确定你在windows下没有使用...
苹果电脑鼠标没反应该怎么办？
原因有三：1.有线鼠标损坏。2.USB口损坏，间接意味着主板损坏。3.没有安装驱动或驱动崩溃。...
苹果笔记本触摸鼠标没反应怎么办？
一、故障原因：1、可能是触摸板驱动程序受到损坏或者用户不小心卸载掉了。2、笔记本触摸板被关闭了。...
苹果电脑打开后鼠标和键盘都没反应怎么回事？
1.可能是键盘和鼠标连接有问题或本身就有问题。2.建议关机之后，重新插一下键盘，注意，如果是US...
苹果电脑鼠标键盘没反应怎么办
你这种情况我之前遇到，我自己这台新款的苹果就是这种情况，那时候查了好多论坛，结果这些方法全部过期就是...
C. Python多进程multiprocessing模块介绍
multiprocessing 是一个支持使用与 threading 模块类似的 API 来产生进程的包。 multiprocessing 包同时提供了本地和远程并发操作，通过使用子进程而非线程有效地绕过了 全局解释器锁。 因此，multiprocessing 模块允许程序员充分利用给定机器上的多个处理器。 它在 Unix 和 Windows 上均可运行。
1、multiprocessing.Process(group=None, target=None, name=None, args=(), kwargs={}, *, daemon=None)
2、相关方法
输出结果如下：
Pool提供了一种快捷的方法，赋予函数并行化处理一系列输入值的能力，可以将输入数据分配给不同进程处理（数据并行）。下面的例子演示了在模块中定义此类函数的常见做法，以便子进程可以成功导入该模块。这个数据并行的基本例子使用了 Pool 。
将在标准输出中打印
其中：
（1）p.apply(func [, args [, kwargs]]):在一个池工作进程中执行func( args, kwargs),然后返回结果。需要强调的是：此操作并不会在所有池工作进程中并执行func函数。如果要通过不同参数并发地执行func函数，必须从不同线程调用p.apply()函数或者使用p.apply_async()
（2）p.apply_async(func [, args [, kwargs]]):在一个池工作进程中执行func( args,**kwargs),然后返回结果。此方法的结果是 AsyncResult类的实例，callback是可调用对象，接收输入参数。当func的结果变为可用时，将理解传递给callback。callback禁止执行任何阻塞操作，否则将接收其他异步操作中的结果。多进程并发！
（3）p.close():关闭进程池，防止进一步操作。如果所有操作持续挂起，它们将在工作进程终止前完成
（4）p.jion():等待所有工作进程退出。此方法只能在close（）或teminate()之后调用
D. 什么是线程（多线程），Python多线程的好处
几乎所有的操作系统都支持同时运行多个任务，一个任务通常就是一个程序，每一个运行中的程序就是一个进程。当一个程序运行时，内部可能包含多个顺序执行流，每一个顺序执行流就是一个线程。
线程和进程
几乎所有的操作系统都支持进程的概念，所有运行中的任务通常对应一个进程（Process）。当一个程序进入内存运行时，即变成一个进程。进程是处于运行过程中的程序，并且具有一定的独立功能。进程是系统进行资源分配和调度的一个独立单位。
一般而言，进程包含如下三个特征：
独立性：进程是系统中独立存在的实体，它可以拥有自己的独立的资源，每一个进程都拥有自己的私有的地址空间。在没有经过进程本身允许的情况下，一个用户进程不可以直接访问其他进程的地址空间。
动态性：进程与程序的区别在于，程序只是一个静态的指令集合，而进程是一个正在系统中活动的指令集合。在进程中加入了时间的概念。进程具有自己的生命周期和各种不同的状态，在程序中是没有这些概念的。
并发性：多个进程可以在单个处理器上并发执行，多个进程之间不会互相影响。
并发（Concurrency）和并行（Parallel）是两个概念，并行指在同一时刻有多条指令在多个处理器上同时执行；并发才旨在同一时刻只能有一条指令执行，但多个进程指令被快速轮换执行，使得在宏观上具有多个进程同时执行的效果。
大部分操作系统都支持多进程并发执行，现代的操作系统几乎都支持同时执行多个任务。例如，程序员一边开着开发工具在写程序，一边开着参考手册备查，同时还使用电脑播放音乐……除此之外，每台电脑运行时还有大量底层的支撑性程序在运行……这些进程看上去像是在同时工作。
但事实的真相是，对于一个 CPU 而言，在某个时间点它只能执行一个程序。也就是说，只能运行一个进程，CPU 不断地在这些进程之间轮换执行。那么，为什么用户感觉不到任何中断呢？
这是因为相对人的感觉来说，CPU 的执行速度太快了（如果启动的程序足够多，则用户依然可以感觉到程序的运行速度下降了）。所以，虽然 CPU 在多个进程之间轮换执行，但用户感觉到好像有多个进程在同时执行。
现代的操作系统都支持多进程的并发执行，但在具体的实现细节上可能因为硬件和操作系统的不同而采用不同的策略。比较常用的策略有：
共用式的多任务操作策略，例如 Windows 3.1 和 Mac OS 9 操作系统采用这种策略；
抢占式的多任务操作策略，其效率更高，目前操作系统大多采用这种策略，例如 Windows NT、Windows 2000 以及 UNIX/Linux 等操作系统。
多线程则扩展了多进程的概念，使得同一个进程可以同时并发处理多个任务。线程（Thread）也被称作轻量级进程（Lightweight Process），线程是进程的执行单元。就像进程在操作系统中的地位一样，线程在程序中是独立的、并发的执行流。
当进程被初始化后，主线程就被创建了。对于绝大多数的应用程序来说，通常仅要求有一个主线程，但也可以在进程内创建多个顺序执行流，这些顺序执行流就是线程，每一个线程都是独立的。
线程是进程的组成部分，一个进程可以拥有多个线程，一个线程必须有一个父进程。线程可以拥有自己的堆栈、自己的程序计数器和自己的局部变量，但不拥有系统资源，它与父进程的其他线程共享该进程所拥有的全部资源。因为多个线程共享父进程里的全部资源，因此编程更加方便；但必须更加小心，因为需要确保线程不会妨碍同一进程中的其他线程。
线程可以完成一定的任务，可以与其他线程共享父进程中的共享变量及部分环境，相互之间协同未完成进程所要完成的任务。
线程是独立运行的，它并不知道进程中是否还有其他线程存在。线程的运行是抢占式的，也就是说，当前运行的线程在任何时候都可能被挂起，以便另外一个线程可以运行。
一个线程可以创建和撤销另一个线程，同一个进程中的多个线程之间可以并发运行。
从逻辑的角度来看，多线程存在于一个应用程序中，让一个应用程序可以有多个执行部分同时执行，但操作系统无须将多个线程看作多个独立的应用，对多线程实现调度和管理，以及资源分配。线程的调度和管理由进程本身负责完成。
简而言之，一个程序运行后至少有一个进程，在一个进程中可以包含多个线程，但至少要包含一个主线程。
归纳起来可以这样说，操作系统可以同时执行多个任务，每一个任务就是一个进程，进程可以同时执行多个任务，每一个任务就是一个线程。
多线程的好处
线程在程序中是独立的、并发的执行流。与分隔的进程相比，进程中线程之间的隔离程度要小，它们共享内存、文件句柄和其他进程应有的状态
因为线程的划分尺度小于进程，使得多线程程序的并发性高。进程在执行过程中拥有独立的内存单元，而多个线程共享内存，从而极大地提高了程序的运行效率。
线程比进程具有更高的性能，这是由于同一个进程中的线程都有共性多个线程共享同一个进程的虚拟空间。线程共享的环境包括进程代码段、进程的公有数据等，利用这些共享的数据，线程之间很容易实现通信。
操作系统在创建进程时，必须为该进程分配独立的内存空间，并分配大量的相关资源，但创建线程则简单得多。因此，使用多线程来实现并发比使用多进程的性能要高得多。
总结起来，使用多线程编程具有如下几个优点：
进程之间不能共享内存，但线程之间共享内存非常容易。
操作系统在创建进程时，需要为该进程重新分配系统资源，但创建线程的代价则小得多。因此，使用多线程来实现多任务并发执行比使用多进程的效率高。
Python 语言内置了多线程功能支持，而不是单纯地作为底层操作系统的调度方式，从而简化了 Python 的多线程编程。
在实际应用中，多线程是非常有用的。比如一个浏览器必须能同时下载多张图片；一个 Web 服务器必须能同时响应多个用户请求；图形用户界面（GUI）应用也需要启动单独的线程，从主机环境中收集用户界面事件……总之，多线程在实际编程中的应用是非常广泛的。
E. 一个Linux多进程编程
1 引言
对于没有接触过Unix/Linux操作系统的人来说，fork是最难理解的概念之一：它执行一次却返回两个值。fork函数是Unix系统最杰出的成就之一，它是七十年代UNIX早期的开发者经过长期在理论和实践上的艰苦探索后取得的成果，一方面，它使操作系统在进程管理上付出了最小的代价，另一方面，又为程序员提供了一个简洁明了的多进程方法。与DOS和早期的Windows不同，Unix/Linux系统是真正实现多任务操作的系统，可以说，不使用多进程编程，就不能算是真正的Linux环境下编程。
多线程程序设计的概念早在六十年代就被提出，但直到八十年代中期，Unix系统中才引入多线程机制，如今，由于自身的许多优点，多线程编程已经得到了广泛的应用。
下面，我们将介绍在Linux下编写多进程和多线程程序的一些初步知识。
2 多进程编程
什么是一个进程？进程这个概念是针对系统而不是针对用户的，对用户来说，他面对的概念是程序。当用户敲入命令执行一个程序的时候，对系统而言，它将启动一个进程。但和程序不同的是，在这个进程中，系统可能需要再启动一个或多个进程来完成独立的多个任务。多进程编程的主要内容包括进程控制和进程间通信，在了解这些之前，我们先要简单知道进程的结构。
2.1 Linux下进程的结构
Linux下一个进程在内存里有三部分的数据，就是"代码段"、"堆栈段"和"数据段"。其实学过汇编语言的人一定知道，一般的CPU都有上述三种段寄存器，以方便操作系统的运行。这三个部分也是构成一个完整的执行序列的必要的部分。
"代码段"，顾名思义，就是存放了程序代码的数据，假如机器中有数个进程运行相同的一个程序，那么它们就可以使用相同的代码段。"堆栈段"存放的就是子程序的返回地址、子程序的参数以及程序的局部变量。而数据段则存放程序的全局变量，常数以及动态数据分配的数据空间（比如用malloc之类的函数取得的空间）。这其中有许多细节问题，这里限于篇幅就不多介绍了。系统如果同时运行数个相同的程序，它们之间就不能使用同一个堆栈段和数据段。
2.2 Linux下的进程控制
在传统的Unix环境下，有两个基本的操作用于创建和修改进程：函数fork( )用来创建一个新的进程，该进程几乎是当前进程的一个完全拷贝；函数族exec( )用来启动另外的进程以取代当前运行的进程。Linux的进程控制和传统的Unix进程控制基本一致，只在一些细节的地方有些区别，例如在Linux系统中调用vfork和fork完全相同，而在有些版本的Unix系统中，vfork调用有不同的功能。由于这些差别几乎不影响我们大多数的编程，在这里我们不予考虑。
2.2.1 fork( )
fork在英文中是"分叉"的意思。为什么取这个名字呢？因为一个进程在运行中，如果使用了fork，就产生了另一个进程，于是进程就"分叉"了，所以这个名字取得很形象。下面就看看如何具体使用fork，这段程序演示了使用fork的基本框架：
void main(){
int i;
if ( fork() == 0 ) {
/* 子进程程序 */
for ( i = 1; i <1000; i ++ ) printf("This is child process\n");
}
else {
/* 父进程程序*/
for ( i = 1; i <1000; i ++ ) printf("This is process process\n");
}
}
程序运行后，你就能看到屏幕上交替出现子进程与父进程各打印出的一千条信息了。如果程序还在运行中，你用ps命令就能看到系统中有两个它在运行了。
那么调用这个fork函数时发生了什么呢？fork函数启动一个新的进程，前面我们说过，这个进程几乎是当前进程的一个拷贝：子进程和父进程使用相同的代码段；子进程复制父进程的堆栈段和数据段。这样，父进程的所有数据都可以留给子进程，但是，子进程一旦开始运行，虽然它继承了父进程的一切数据，但实际上数据却已经分开，相互之间不再有影响了，也就是说，它们之间不再共享任何数据了。它们再要交互信息时，只有通过进程间通信来实现，这将是我们下面的内容。既然它们如此相象，系统如何来区分它们呢？这是由函数的返回值来决定的。对于父进程，fork函数返回了子程序的进程号，而对于子程序，fork函数则返回零。在操作系统中，我们用ps函数就可以看到不同的进程号，对父进程而言，它的进程号是由比它更低层的系统调用赋予的，而对于子进程而言，它的进程号即是fork函数对父进程的返回值。在程序设计中，父进程和子进程都要调用函数fork（）下面的代码，而我们就是利用fork（）函数对父子进程的不同返回值用if...else...语句来实现让父子进程完成不同的功能，正如我们上面举的例子一样。我们看到，上面例子执行时两条信息是交互无规则的打印出来的，这是父子进程独立执行的结果，虽然我们的代码似乎和串行的代码没有什么区别。
读者也许会问，如果一个大程序在运行中，它的数据段和堆栈都很大，一次fork就要复制一次，那么fork的系统开销不是很大吗？其实UNIX自有其解决的办法，大家知道，一般CPU都是以"页"为单位来分配内存空间的，每一个页都是实际物理内存的一个映像，象INTEL的CPU，其一页在通常情况下是4086字节大小，而无论是数据段还是堆栈段都是由许多"页"构成的，fork函数复制这两个段，只是"逻辑"上的，并非"物理"上的，也就是说，实际执行fork时，物理空间上两个进程的数据段和堆栈段都还是共享着的，当有一个进程写了某个数据时，这时两个进程之间的数据才有了区别，系统就将有区别的"页"从物理上也分开。系统在空间上的开销就可以达到最小。
下面演示一个足以"搞死"Linux的小程序，其源代码非常简单：
void main()
{
for( ; ; ) fork();
}
这个程序什么也不做，就是死循环地fork，其结果是程序不断产生进程，而这些进程又不断产生新的进程，很快，系统的进程就满了，系统就被这么多不断产生的进程"撑死了"。当然只要系统管理员预先给每个用户设置可运行的最大进程数，这个恶意的程序就完成不了企图了。
2.2.2 exec( )函数族
下面我们来看看一个进程如何来启动另一个程序的执行。在Linux中要使用exec函数族。系统调用execve（）对当前进程进行替换，替换者为一个指定的程序，其参数包括文件名（filename）、参数列表（argv）以及环境变量（envp）。exec函数族当然不止一个，但它们大致相同，在Linux中，它们分别是：execl，execlp，execle，execv，execve和execvp，下面我只以execlp为例，其它函数究竟与execlp有何区别，请通过manexec命令来了解它们的具体情况。
一个进程一旦调用exec类函数，它本身就"死亡"了，系统把代码段替换成新的程序的代码，废弃原有的数据段和堆栈段，并为新程序分配新的数据段与堆栈段，唯一留下的，就是进程号，也就是说，对系统而言，还是同一个进程，不过已经是另一个程序了。（不过exec类函数中有的还允许继承环境变量之类的信息。）
那么如果我的程序想启动另一程序的执行但自己仍想继续运行的话，怎么办呢？那就是结合fork与exec的使用。下面一段代码显示如何启动运行其它程序：
char command[256];
void main()
{
int rtn; /*子进程的返回数值*/
while(1) {
/* 从终端读取要执行的命令 */
printf( ">" );
fgets( command, 256, stdin );
command[strlen(command)-1] = 0;
if ( fork() == 0 ) {
/* 子进程执行此命令 */
execlp( command, command );
/* 如果exec函数返回，表明没有正常执行命令，打印错误信息*/
perror( command );
exit( errorno );
}
else {
/* 父进程， 等待子进程结束，并打印子进程的返回值 */
wait ( &rtn );
printf( " child process return %d\n",. rtn );
}
}
}
此程序从终端读入命令并执行之，执行完成后，父进程继续等待从终端读入命令。熟悉DOS和WINDOWS系统调用的朋友一定知道DOS/WINDOWS也有exec类函数，其使用方法是类似的，但DOS/WINDOWS还有spawn类函数，因为DOS是单任务的系统，它只能将"父进程"驻留在机器内再执行"子进程"，这就是spawn类的函数。WIN32已经是多任务的系统了，但还保留了spawn类函数，WIN32中实现spawn函数的方法同前述UNIX中的方法差不多，开设子进程后父进程等待子进程结束后才继续运行。UNIX在其一开始就是多任务的系统，所以从核心角度上讲不需要spawn类函数。
在这一节里，我们还要讲讲system（）和popen（）函数。system（）函数先调用fork（），然后再调用exec（）来执行用户的登录shell，通过它来查找可执行文件的命令并分析参数，最后它么使用wait（）函数族之一来等待子进程的结束。函数popen（）和函数system（）相似，不同的是它调用pipe（）函数创建一个管道，通过它来完成程序的标准输入和标准输出。这两个函数是为那些不太勤快的程序员设计的，在效率和安全方面都有相当的缺陷，在可能的情况下，应该尽量避免。
2.3 Linux下的进程间通信
详细的讲述进程间通信在这里绝对是不可能的事情，而且笔者很难有信心说自己对这一部分内容的认识达到了什么样的地步，所以在这一节的开头首先向大家推荐着名作者Richard Stevens的着名作品：《Advanced Programming in the UNIX Environment》，它的中文译本《UNIX环境高级编程》已有机械工业出版社出版，原文精彩，译文同样地道，如果你的确对在Linux下编程有浓厚的兴趣，那么赶紧将这本书摆到你的书桌上或计算机旁边来。说这么多实在是难抑心中的景仰之情，言归正传，在这一节里，我们将介绍进程间通信最最初步和最最简单的一些知识和概念。
首先，进程间通信至少可以通过传送打开文件来实现，不同的进程通过一个或多个文件来传递信息，事实上，在很多应用系统里，都使用了这种方法。但一般说来，进程间通信（IPC：InterProcess Communication）不包括这种似乎比较低级的通信方法。Unix系统中实现进程间通信的方法很多，而且不幸的是，极少方法能在所有的Unix系统中进行移植（唯一一种是半双工的管道，这也是最原始的一种通信方式）。而Linux作为一种新兴的操作系统，几乎支持所有的Unix下常用的进程间通信方法：管道、消息队列、共享内存、信号量、套接口等等。下面我们将逐一介绍。
2.3.1 管道
管道是进程间通信中最古老的方式，它包括无名管道和有名管道两种，前者用于父进程和子进程间的通信，后者用于运行于同一台机器上的任意两个进程间的通信。
无名管道由pipe（）函数创建：
#include <unistd.h>
int pipe(int filedis[2])；
参数filedis返回两个文件描述符：filedes[0]为读而打开，filedes[1]为写而打开。filedes[1]的输出是filedes[0]的输入。下面的例子示范了如何在父进程和子进程间实现通信。
#define INPUT 0
#define OUTPUT 1
void main() {
int file_descriptors[2];
/*定义子进程号 */
pid_t pid;
char buf[256];
int returned_count;
/*创建无名管道*/
pipe(file_descriptors);
/*创建子进程*/
if((pid = fork()) == -1) {
printf("Error in fork\n");
exit(1);
}
/*执行子进程*/
if(pid == 0) {
printf("in the spawned (child) process...\n");
/*子进程向父进程写数据，关闭管道的读端*/
close(file_descriptors[INPUT]);
write(file_descriptors[OUTPUT], "test data", strlen("test data"));
exit(0);
} else {
/*执行父进程*/
printf("in the spawning (parent) process...\n");
/*父进程从管道读取子进程写的数据，关闭管道的写端*/
close(file_descriptors[OUTPUT]);
returned_count = read(file_descriptors[INPUT], buf, sizeof(buf));
printf("%d bytes of data received from spawned process: %s\n",
returned_count, buf);
}
}
在Linux系统下，有名管道可由两种方式创建：命令行方式mknod系统调用和函数mkfifo。下面的两种途径都在当前目录下生成了一个名为myfifo的有名管道：
方式一：mkfifo("myfifo","rw");
方式二：mknod myfifo p
生成了有名管道后，就可以使用一般的文件I/O函数如open、close、read、write等来对它进行操作。下面即是一个简单的例子，假设我们已经创建了一个名为myfifo的有名管道。
/* 进程一：读有名管道*/
#include <stdio.h>
#include <unistd.h>
void main() {
FILE * in_file;
int count = 1;
char buf[80];
in_file = fopen("mypipe", "r");
if (in_file == NULL) {
printf("Error in fdopen.\n");
exit(1);
}
while ((count = fread(buf, 1, 80, in_file)) > 0)
printf("received from pipe: %s\n", buf);
fclose(in_file);
}
/* 进程二：写有名管道*/
#include <stdio.h>
#include <unistd.h>
void main() {
FILE * out_file;
int count = 1;
char buf[80];
out_file = fopen("mypipe", "w");
if (out_file == NULL) {
printf("Error opening pipe.");
exit(1);
}
sprintf(buf,"this is test data for the named pipe example\n");
fwrite(buf, 1, 80, out_file);
fclose(out_file);
}
2.3.2 消息队列
消息队列用于运行于同一台机器上的进程间通信，它和管道很相似，事实上，它是一种正逐渐被淘汰的通信方式，我们可以用流管道或者套接口的方式来取代它，所以，我们对此方式也不再解释，也建议读者忽略这种方式。
2.3.3 共享内存
共享内存是运行在同一台机器上的进程间通信最快的方式，因为数据不需要在不同的进程间复制。通常由一个进程创建一块共享内存区，其余进程对这块内存区进行读写。得到共享内存有两种方式：映射/dev/mem设备和内存映像文件。前一种方式不给系统带来额外的开销，但在现实中并不常用，因为它控制存取的将是实际的物理内存，在Linux系统下，这只有通过限制Linux系统存取的内存才可以做到，这当然不太实际。常用的方式是通过shmXXX函数族来实现利用共享内存进行存储的。
首先要用的函数是shmget，它获得一个共享存储标识符。
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/shm.h>
int shmget(key_t key, int size, int flag);
这个函数有点类似大家熟悉的malloc函数，系统按照请求分配size大小的内存用作共享内存。Linux系统内核中每个IPC结构都有的一个非负整数的标识符，这样对一个消息队列发送消息时只要引用标识符就可以了。这个标识符是内核由IPC结构的关键字得到的，这个关键字，就是上面第一个函数的key。数据类型key_t是在头文件sys/types.h中定义的，它是一个长整形的数据。在我们后面的章节中，还会碰到这个关键字。
当共享内存创建后，其余进程可以调用shmat（）将其连接到自身的地址空间中。
void *shmat(int shmid, void *addr, int flag);
shmid为shmget函数返回的共享存储标识符，addr和flag参数决定了以什么方式来确定连接的地址，函数的返回值即是该进程数据段所连接的实际地址，进程可以对此进程进行读写操作。
使用共享存储来实现进程间通信的注意点是对数据存取的同步，必须确保当一个进程去读取数据时，它所想要的数据已经写好了。通常，信号量被要来实现对共享存储数据存取的同步，另外，可以通过使用shmctl函数设置共享存储内存的某些标志位如SHM_LOCK、SHM_UNLOCK等来实现。