python多进程存储数据_python进程、多进程

进程：

进程（Process）是计算机中的程序关于某数据集合上的一次运行活动，是系统进行资源分配和调度的基本单位，是操作系统结构的基础。在早期面向进程设计的计算机结构中，进程是程序的基本执行实体；在当代面向线程设计的计算机结构中，进程是线程的容器。程序是指令、数据及其组织形式的描述，进程是程序的实体。。

狭义定义：进程是正在运行的程序的实例（an instance of a computer program that is being executed）。

广义定义：进程是一个具有一定独立功能的程序关于某个数据集合的一次运行活动。它是操作系统动态执行的基本单元，在传统的操作系统中，进程既是基本的分配单元，也是基本的执行单元。

进程是一个内核级的实体，进程结构的所有成分都在内核空间中，一个用户程序不能直接访问这些数据。

进程状态：

创建、就绪、运行、阻塞、结束

进程的概念主要有两点：

第一，进程是一个实体。每一个进程都有它自己的地址空间，一般情况下，包括文本区域（text region）、数据区域（data region）和堆栈（stack region）。文本区域存储处理器执行的代码；数据区域存储变量和进程执行期间使用的动态分配的内存；堆栈区域存储着活动过程调用的指令和本地变量。

第二，进程是一个“执行中的程序”。程序是一个没有生命的实体，只有处理器赋予程序生命时，它才能成为一个活动的实体，我们称其为进程。

进程是操作系统中最基本、重要的概念。是多任务系统出现后，为了刻画系统内部出现的动态情况，描述系统内部各程序的活动规律引进的一个概念,所有多任务设计操作系统都建立在进程的基础上。

进程是操作系统中分配资源的最小单位

线程是操作系统调度的最小单位

线程属于进程，一般一个进程会 有一个主线程

程序+数据+运行是进程

简单理解就是一个程序

Ps –ef

进程的特征

Ø动态性：进程的实质是程序在多任务系统中的一次执行过程，进程是动态产生，动态消亡的。

Ø并发性：任何进程都可以同其他进程一起并发执行

Ø独立性：进程是一个能独立运行的基本单位，同时也是系统分配资源和调度的独立单位；

Ø异步性：由于进程间的相互制约，使进程具有执行的间断性，即进程按各自独立的、不可预知的速度执行

Ø结构特征：进程由程序、数据和进程控制块三部分组成。

Ø多个不同的进程可以包含相同的程序：一个程序在不同的数据集里就构成不同的进程，能得到不同的结果；但是执行过程中，程序不能发生改变。

进程的状态

创建

就绪：可被执行的状态，需要等CPU执行

运行：

组赛：等待数据或资源时，I/O，

结束：

CPU：寄存器（存储），控制器（控制），

Cpu缓存

https://baike.baidu.com/item/CPU缓存/3728308?fr=aladdin

程序本身，数据，堆栈

单核CPU，运行时用时间片轮寻

单cpu时用多线程好还是单线程好？

如果是纯计算密集型的，开一个线程要快，因为CPU在同一时刻只能运行一个线程，如果程序没有I/O操作，那一个线程块，保证CPU告诉的执行这个线程，此时开多个线程，cpu要做切换，切换本身产生延迟

如果是大量i/o时，需要等待时，cpu不会等，如果只跑一个线程，cpu会等，如果多线程，一个需要等时，cpu会执行其他的线程，这样cpu利用率要高，

如果有大量I/O，多线程好，会提高cpu利用率

进程特点

动态性

并发性

独立性：QQ和word进程是独立的，没有关系

异步性：各自在执行当中，相互并行执行

同步(顺序运行)和异步（并行执行）

同步时：业务有1，2，3，4严格的顺序，一步一步的执行，就是同步

异步：业务没有严格的执行的顺序，注册搜狐邮箱后，系统会把账号同步给其他模块账户的过程就是异步

一般互联网中业务都是异步的

同步需要耗时

结构：程序、数据、进程控制块PCB(存进程相关的信息，id，副id，状态等等)

不同的进程可以执行相同的程序，不同账号登陆

CPU组成:运算器、控制器、寄存器

主频3.5G，发展较慢

摩尔定律：没18个月cpu速度翻一倍，现在失效了

智能时代：吴军

刻意练习：

进程切换：

CPU时间片轮寻，进

上下文：一个程序运行时的中间状态和数据

比如跑到第5行，下次跑的时候，还是从第5行跑，这个状态和数据就是上下文

进程运行状态：

就绪状态，运行状态，阻塞状态

阻塞：I/O或进程同步，或网络服务器发请求等待数据等，被阻塞

原语（原子操作）：一段程序不能分割，操作系统的最小的一个指令集

loadnunner的事物是用来算时间差的，用来计时的，统计耗时

数据库的事务要么都失败，要么都成功

ram：random

room，read only

内存：随机访问存储器RAM

内存更快，不能永久保存，磁盘慢，永久 保存数据

互联网口诀：分库、分表、分布式计算、分布式缓存、异步技术

互联网系统架构：

服务器端和客户端

数据库有没有集群，怎么搭的？

写的多还是读的多，主是写，从是读，主的少，从的多

mysql：主从结构，主的是写，从的是读

挂起（等待、组赛）：等待I/O、其他进程的结果（进程间同步）

同步、异步、阻塞、非阻塞

同步：死等

异步：不等

阻塞：等待一个条件的发生

非阻塞：不需要等待条件

进程的五态模型：

进程状态转换

活跃就绪：是指进程在主存并且可被调度的状态。

静止就绪（挂起就绪）：是指进程被对换到辅存时的就绪状态，是不能被直接调度的状态，只有当主存中没有活跃就绪态进程，或者是挂起就绪态进程具有更高的优先级，系统将把挂起就绪态进程调回主存并转换为活跃就绪。

活跃阻塞：是指进程已在主存，一旦等待的事件产生便进入活跃就绪状态。

静止阻塞：是指进程对换到辅存时的阻塞状态，一旦等待的事件产生便进入静止就绪状态。

linux：swap，内存不够用时写入swap（硬盘）

pcb存贮进程的信息

程序计数器，program counter,记录运行到哪一行

进程的创建过程：

一旦操作系统发现了要求创建新进程的事件后，便调用进程创建原语Creat（）按下述步骤创建一个新进程。

1）申请空白PCB（进程控制块）。为新进程申请获得唯一的数字标识符，并从PCB集合中索取一个空白PCB。

2）为新进程分配资源。为新进程的程序和数据以及用户栈分配必要的内存空间。显然，此时操作系统必须知道新进程所需要的内存大小。

3）初始化进程控制块。PCB的初始化包括：

①初始化标识信息，将系统分配的标识符和父进程标识符，填入新的PCB中。

②初始化处理机状态信息，使程序计数器指向程序的入口地址，使栈指针指向栈顶。

③初始化处理机控制信息，将进程的状态设置为就绪状态或静止就绪状态，对于优先级，通常是将它设置为最低优先级，除非用户以显式的方式提出高优先级要求。

4）将新进程插入就绪队列，如果进程就绪队列能够接纳新进程，便将新进程插入到就绪队列中

进程终止：

引起进程终止的事件

1）正常结束

在任何计算机系统中，都应该有一个表示进程已经运行完成的指示。例如，在批处理系统中，通常在程序的最后安排一条Hold指令或终止的系统调用。当程序运行到Hold指令时，将产生一个中断，去通知OS本进程已经完成。

2）异常结束

在进程运行期间，由于出现某些错误和故障而迫使进程终止。这类异常事件很多，常见的有：越界错误，保护错，非法指令，特权指令错，运行超时，等待超时，算术运算错，I/O故障。

3）外界干预

外界干预并非指在本进程运行中出现了异常事件，而是指进程应外界的请求而终止运行。这些干预有：操作员或操作系统干预，父进程请求，父进程终止。

如果系统发生了上述要求终止进程的某事件后，OS便调用进程终止原语，按下述过程去终止指定的进程。

1）根据被终止进程的标识符，从PCB集合中检索出该进程的PCB，从中读出该进程状态。

2）若被终止进程正处于执行状态，应立即终止该进程的执行，并置调度标志为真。用于指示该进程被终止后应重新进行调度。

3）若该进程还有子孙进程，还应将其所有子孙进程予以终止，以防他们成为不可控的进程。

4）将被终止的进程所拥有的全部资源，或者归还给其父进程，或者归还给系统。

5）将被终止进程（它的PCB）从所在队列（或链表）中移出，等待其它程序来搜集

阻塞

1、请求系统服务

2、启动某种操作

3、新数据尚未到达

4、没事儿干

唤醒：

各种事儿已经准备完成

调度算法：

先到显出

时间片轮转

优先级

Python进程

multiprocessing较多

进程间通信

ü 文件

ü 管道（ Pipes Pipes ）

ü Socket

ü 信号

ü 信号量

ü 共享内存

#!/user/bin/python

#encoding=utf-8

import os

print os.getpid()

pid = os.fork() # 创建一个子进程

print "******",pid #子进程id和0

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)

[gstudent@iZ2zejbxp2btn9jh8knipuZ xxx]$ python test.py

610

****** 611

I (610) just created a child process (611).

****** 0

I am child process (611) and my parent is 610.

在linux中，执行fork函数之后

父进程拿到的返回的fork函数返回值是子进程的pid

子进程拿到的返回的fork函数返回值是0

父进程和子进程会分别执行后续未执行的代码

，子进程执行的时if，父进程执行的是else

fork()

fork() 函数，它也属于一个内建并 且只在 Linux 系统下存在。 它非常特殊普通的函数调用，一次返回但是 fork() fork() 调用一次，返回两因为操 作系统自动把当前进程（称为父）复制了一份（称为子进程），然后分别在父进程和子内返回。

子进程永远返回 0，而父进程

返回子的PID 。这样做的理由是，一个父进程可

以fork() fork() 出很多子进程，所以父要

记下每个子进程的 ID ，而子进程只需要调

用getppid () 就可以拿到父进程的 ID ，子 进程只需要调用 os.getpid os.getpid () 函数可以获取

自

创建进程

Multiprocessing

Multiprocessing模块创建进程使用的是Process类。

Process类的构造方法：

help(multiprocessing.Process)

__init__(self,

group=None, target=None, name=None, args=(), kwargs={})

参数说明：

group：进程所属组，基本不用。

target：表示调用对象，一般为函数。

args：表示调用对象的位置参数元组。

name：进程别名。

kwargs：表示调用对象的字典。

创建子进程时，只需要传入一个执行函数和函数的参数，创建一个Process实例，并用其start()方法启动，这样创建进程比fork()还要简单。

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

注意：

在Windows上要想使用进程模块，就必须把有关进程的代码写在当前.py文件的if __name__ == ‘__main__’ :语句的下面，才能正常使用Windows下的进程模块。Unix/Linux下则不需要。

创建5个进程例子

#coding=utf-8

import multiprocessing

def do(n) :

#获取当前线程的名字

name = multiprocessing.current_process().name

print name,'starting'

print "worker ", n

return

if __name__ == '__main__' :

numList = []

for i in xrange(5) :

p = multiprocessing.Process(target=do, args=(i,))

numList.append(p)

p.start()

p.join()#进程执行完毕后才继续执行

print "Process end."

print numList

c:\Python27\Scripts>python task_test.py

Process-1 starting

worker 0

Process end.

Process-2 starting

worker 1

Process end.

Process-3 starting

worker 2

Process end.

Process-4 starting

worker 3

Process end.

Process-5 starting

worker 4

Process end.

[,

, ,

stopped)>, ]

把p.join()注释掉

p.start()

#p.join()

print "Process end."

print numList

c:\Python27\Scripts>python task_test.py

Process end.

Process end.

Process end.

Process end.

Process end.

[PP,

rocess-1rocess-3< Process(Process-2, started)>s , tartings<

tartingProcess(Process-3, started)>P

wProcess-4 sworker rocess-2tarting

worker , orker 3

< 0sProcess(Process-4,

started)>2

tarting,

orker ]

1

Process-5 starting

worker 4

练习：三个进程，每个进程写一个文件，每个文件中有进程的名称和日期

#coding=utf-8

import multiprocessing

import time

def do(n) :

fp=open(r"d:\\%s.txt"%n,'w')

name=multiprocessing.current_process().name

fp.write("%s

%s"%(name,time.strftime("%Y-%m-%d %H:%M:%S")))

fp.close()

return

if __name__ == '__main__' :

numList = []

for i in xrange(3) :

p = multiprocessing.Process(target=do, args=(i,))

numList.append(p)

p.start()

p.join()

print "Process end."

print numList

Process-2 2018-03-31 14:55:34

Os.fork()和multiprocessing结合使用

#!/usr/bin/python

# -*- coding: utf-8 -*-

from multiprocessing import Process

import os

import time

def sleeper(name, seconds):

print "Process ID# %s" % (os.getpid())

print "Parent Process ID# %s" %

(os.getppid())

#仅支持在linux上,一个进程会有父进程和自己的ID，windows上就没有父进程id

print

"%s will sleep for %s seconds" % (name, seconds)

time.sleep(seconds)

# if __name__ == "__main__":

child_proc = Process(target = sleeper, args = ('bob', 5))

child_proc.start()

print "in parent process after child process start"

print "parent process about to join child process"

child_proc.join()

print "in parent process after child process join"

print "the parent's parent process: %s" % (os.getppid())

没运行成功

多进程模板程序

#coding=utf-8

import multiprocessing

import urllib2

import time

def func1(url) :

response = urllib2.urlopen(url)

html = response.read()

print html[0:20]

time.sleep(20)

def func2(url) :

response = urllib2.urlopen(url)

html = response.read()

print html[0:20]

time.sleep(20)

if __name__ == '__main__' :

p1 =

multiprocessing.Process(target=func1,args=("http://www.sogou.com",),name="gloryroad1")

p2 =

multiprocessing.Process(target=func2,args=("http://www.baidu.com",),name="gloryroad2")

p1.start()

p2.start()

p1.join()

p2.join()

time.sleep(10)

print "done!"

c:\Python27\Scripts>python task_test.py