操作系统简介&多进程

1.操作系统

操作系统为程序员操作硬件提供了接口。程序员不需要直接写程序操作硬件,只需要按照一定的规范,把数据提交给操作系统,操作系统回去操作硬盘,CPU和内存

创新互联是专业的北海街道网站建设公司,北海街道接单;提供网站设计制作、成都网站设计,网页设计,网站设计,建网站,PHP网站建设等专业做网站服务;采用PHP框架,可快速的进行北海街道网站开发网页制作和功能扩展;专业做搜索引擎喜爱的网站,专业的做网站团队,希望更多企业前来合作!

1.1第一代计算机

"特点"
    没有操作系统的概念,所有程序都是直接操控硬件
"工作过程"
   程序员预约一段时间,在这段时间一个程序员独享计算机,其他人等待
"优点"
    程序员在申请的时间内独享资源,可以及时调整自己的程序
"缺点"
    浪费资源,一段时间内只有一个人使用

1.2第二代计算机:批处理系统

"工作过程"
    多个程序员的代码放在一起进行提交,然后机器顺序计算,得到多个程序员代码的输出
"优点"
    批处理代码,不再是一个程序员独享计算机,节省了时间
"缺点"
    1.整个流程需要人的参与,把多个程序员的代码在机器之间搬动,进行执行和得到输出
    2.计算机仍然是顺序执行的
    3.程序员不能独享计算机,不能即使调试得到结果,需要等到大家都提交完成,一起处理后得到结果,有问题不能立刻处理

操作系统简介&多进程

1.3第三代计算机:多道程序设计

"解决第二代计算机中需要人参与的问题"
    使用SPOOLING技术,就不需要人在中间搬动磁带了
"解决第二代计算机顺序执行的问题"
多道技术
    多道技术中的多道指的是多个程序,多道技术的实现是为了解决多个程序竞争或共享一个CPU的有序调度问题,解决方式是多路复用,分为时间上的复用和空间上的复用
    "空间上的复用:"将内存分为几部分,每部分放入一个程序,这样,同一时间内存中就有了多个程序
    "空间上复用的问题:"程序之间的内存必须是分割开的,这种分割需要在硬件层面操作,由操作系统控制。如果内存彼此不分割,则一个程序可以访问另外一个程序的内存。
    首先丧失的是安全性,如qq程序可以访问操作系统的内存,这就拿到了操作系统的权限。
    其次丧失的是稳定性,如果qq程序退出,可能会导致操作系统的程序退出。
    "时间上的复用:"当一个程序在等待I/O时,或一个程序运行了一段时间,CPU就切换,运行其他程序。
"解决单个程序员不能独享计算机的问题"
    "分时操作系统:"多个终端+多道技术,可以多个程序员连接计算机,操作系统采用多道的技术,处理多个程序员的任务。所有的用户以为自己独享了计算机资源。
    第三代计算机广泛采用了必须的保护硬件(程序之间的内存彼此隔离后),分时系统才开始流行。

1.4第四代计算机:个人计算机

1.5总结

一:操作系统的作用
    1.隐藏复杂的硬件接口,提供良好的抽象接口。
    2.管理、调度进程,并且将多个进程多硬件的竞争变得有序。
二:多道技术
    1.产生背景:针对单核,实现并发
      现在的主机一般是多核,多核都会使用多道技术
      有4个CPU,运行在cpu1上的某个程序遇到io阻塞,会等到io结束再重新调度,对被调度到4个cpu中的任意一个,具体由操作系统的调度算法决定。
    2.空间上的复用:内存中同时存在多个程序,需要硬件支持,将多个程序的内存空间分隔开来。
    3.时间上的复用:复用一个cpu时间片。
       如果程序在进行io处理,或一个程序占用cpu较长时间,就会吧进程的状态保存下来,去处理别的程序。下次CPU切换回来,继续上次的位置,继续运行。

2.进程理论

2.1什么是进程

进程是正在运行的代码程序。负责运行程序,执行任务的是CPU。

2.2进程与程序的区别

程序仅仅是一堆代码
进程是程序的运行过程,运行起来的代码会在操作系统中产生一个进程
同一个程序运行两次,是两个进程。

2.3并发与并行

无论是并发还是并行,在用户看来都是'同时'运行的
不管是进程还是线程,都只是一个任务而已,真正做事的是CPU,但同一个CPU在同一时刻只能执行一个任务
"并发":是伪并行,即看起来是同时运行。单个cpu+多道技术可以实现并发
例如:你可能正在学习,但突然有人找你聊天,你可能聊一会,看一会视频,等对方有回复了,你在回复。你就做到了做两件事,看似同时进行,但实际上你是一会学习,一会回复,在同一时间实际只做了一件事
"并行":同时运行,需要具备多个CPU才能实现并行。
单核下,可以使用多道技术,多核下,每个CPU也可以使用多道技术。
例如:有四个CPU,6个任务,在同一时间有四个任务在执行,分别分配给了cpu0,cpu1,cpu2,cpu3
如果cpu0上的任务遇到I/O,cpu0就会处理任务5,这就是单核下的多道技术
如果cpu0上的I/O结束了,那么操作系统会重新进行分配,决定调度给那个CPU是操作系统算法和任务优先级决定的。

2.4进程的创建

"进程创建的四种形式"
1.启动操作系统,会创建一些进程。linux中ps -aux查看进程,windows中tasklist查看
2.一个进程在运行过程中开启子进程。(os.fork,subprocess.Popen都可以开启子进程)
3.windows上用户双击某个软件,Linux中启动某个服务,都可以创建一个进程。
4.批处理作业的初始化(只在大型机的批处理系统中应用。)
"linux与Windows中的进程的创建"
1.Windows中调用CreateProcess来创建进程。
2.Unix中调用fork,fork会创建一个与父进程一模一样的副本
"两者的相同与不同"
相同的是:进程创建后,父进程和子进程有个字不同的地址空间(多道技术要求进程之间内存是相互隔离的),任何一个进程中的数据要和其他进程的数据相互隔离,互不影响。
不同的是:在Unix中,子进程的初始地址空间是父进程的一个副本,子进程中的数据来源于父进程,与父进程中的数据是完全相同的,但windows中子进程与父进程并不是完全相同。

2.5进程的终止

1.程序正常退出
2.报错退出
3.被kill掉

2.6进程的层次结构

无论UNIX还是Windows,进程只有一个父进程,不同的是
1.Unix中所有的进程,都是以init进程为根,组成树形结构。父子进程共同组成一个进程组,这样,当从键盘发出一个信号,该信号会被发送给与键盘相关的进程组中的所有成员。
2.在windows中,没有进程层次的概念,所有的进程地位相同,唯一类似于进程层次的,是在创建进程时,父进程会得到一个特别的令牌(称为句柄),该句柄可以用于控制子进程,但是父进程有权把该句柄传给其他子进程,这样就没有层次了。

2.7进程的状态

操作系统简介&多进程

运行中的进程被调度到就绪态的原因
1.进程自身遇到I/O阻塞,便要让出CPU让其他进程去执行,这样就保证了CPU一直爱工作
2.与进程无关,操作系统原因,如果一个进程占用时间过多,或者优先级原因,而调用其他进程去使用CPU

2.8进程并发的实现

进程并发的实现在于,硬件中断一个正在运行的进程,会把该进程的状态信息进行保存,为此,操作系统维护一个表格,即进程表,每个进程占用一个进程表项
该表存放了进程状态的重要信息,这样当CPU再次调用时,能从该进程的上次终端位置继续执行,就好像没有中断过一样。

操作系统简介&多进程

3.开启进程的两种方式

3.1multiprocessing模块介绍

python中的"多线程"是无法利用多核优势的
python中的"多进程"是可以充分的利用多核CPU的资源,可以使用os.cpu_count()来查看cpu数
python中使用multiprocessing模块来开启多个子进程,使用threading来开启多个线程。
multiprocessing模块功能众多:支持子进程、通信和共享数据、执行不同形式的同步,提供了Process,Queue,Pipe,Lock等组件。
"进程与线程不同,进程没有任何共享状态,进程修改的数据,改动的仅限于该进程内。"

3.2process类的介绍

Process([group [, target [, name [, args [, kwargs]]]]])
由该类实例化得到的对象,可用来开启一个子进程
"注意"
1.需要使用关键字的方式来制定参数
2.args指定的是传给target函数的位置参数,是一个元组形式,设置方式args=("a",2)
3.kwargs指定的是传给target函数的位置参数,是一个字典的形式,设置方式kwargs={a:2,b:"test"}
"参数介绍"
group:未使用,为None
target:表示调用对象,即子进程要执行的任务,指向一个函数
args:表示target函数的位置参数,元组形式,args=(1,2,'vita',)
kwargs:表示target函数的位置参数,字典形式,kwargs={'name':'vita','age':18}
name:表示子进程的名称
"方法介绍"
p.start():启动进程,并调用该子进程中的run()方法
p.run():进程启动时运行的方法,正是该方法去调用target指定的函数,自定义的继承自Process的类,需要实现该方法
p.terminate():强制终止进程p,不会做任何的清理工作,
    如果p创建了子进程,该子进程就成了僵尸进程
    如果p还保存了一个锁,那么锁也不会被释放,进而导致死锁
p.is_alive():如果p在运行,就返回True
p.join([timeout]):主线程等待p终止
    "注意"是主线程处于等待状态,而p处于运行状态
"属性介绍"
p.daemon:默认为False,
如果设为True,代表p为后台运行的守护进程,当p的父进程终止时,p也随之终止
设置为True后,p不能创建自己的新进程,必须在p.start之后设置
p.name:进程的名称
p.pid:进程的pid

3.3Process创建子进程

注意:在windows中Process()必须放到# if __name__ == '__main__':下
"方式一"
#!/usr/bin/env python
# -*- coding:utf-8 -*-
# Author: vita
from multiprocessing import Process
def target_func(name):
   print("子进程:",name)
if __name__ == '__main__':
# 实例化两个对象,开启两个子进程
    p1=Process(name="p1",target=target_func,args=("p1",))# 这里一定要加',',否则TypeError: target_func() takes 1 positional argument but 2 were given
    p2=Process(name="p2",target=target_func,args=("p2",))
    p1.start()
    p2.start()
    print("主进程") #会发现创建了子进程,主进程依旧在继续运行,所以先输出了主进程的内容,然后运行子进程,

D:\software2\Python3\install\python.exe E:/PythonProject/new-python/python-test/BasicGrammer/test.py
主进程
子进程: p1
子进程: p2

Process finished with exit code 0
"方式二"
#!/usr/bin/env python
# -*- coding:utf-8 -*-
# Author: vita
from multiprocessing import Process
# 这里要继承Process
class Func(Process):
   # 重用父类中的init方法,并加入新参数
   def __init__(self,name):
      super().__init__()
      self.nm=name

   # 一定要写run 方法,start方法会自动调用run方法
   def run(self): #
      print("子进程",self.nm)
if __name__ == '__main__':
# 实例化两个对象,开启两个子进程
    func = Func("p1")
    func.start()
    func1 = Func("p2")
    func1.start()
    print("主进程")

D:\software2\Python3\install\python.exe E:/PythonProject/new-python/python-test/BasicGrammer/test.py
主进程
子进程 p1
子进程 p2

Process finished with exit code 0

3.4pid和ppid

#!/usr/bin/env python
# -*- coding:utf-8 -*-
# Author: vita
from multiprocessing import Process
import os
# 这里要继承Process
class Func(Process):

   def __init__(self,name):
      super().__init__()
      self.nm=name

   def run(self): #
      # 子进程的ppid就是main的pid
      print("子进程:%s,pid:%s,ppid:%s"%(self.nm,os.getpid(),os.getppid()))
if __name__ == '__main__':
    func = Func("p1")
    func.start()
    func1 = Func("p2")
    func1.start()
    # 主进程的ppid就是你运行py文件的程序的进程号,
    # 如果使用pycharm运行,就是pycharm的进程号
    # 如果使用cmd终端运行,就是终端的进程号
    print("主进程:,pid:%s,ppid:%s"%(os.getpid(),os.getppid()))

D:\software2\Python3\install\python.exe E:/PythonProject/new-python/python-test/BasicGrammer/test.py
主进程:,pid:6100,ppid:11200
子进程:p1,pid:8252,ppid:6100
子进程:p2,pid:10784,ppid:6100

Process finished with exit code 0

4.Process方法和属性详解

4.1join()

在主进程运行过程中,可以开启子进程,主进程与子进程的任务分为
1.在主进程的任务与子进程的任务彼此独立时,主进程先执行完成,还要等待子进程执行完成后才统一回收资源
2.如果主进程的任务需要在执行到某个阶段,需要等待子进程执行完成后继续执行,就可使用join()
"join"
#!/usr/bin/env python
# -*- coding:utf-8 -*-
# Author: vita
from multiprocessing import Process
import os
import time
# 这里要继承Process
class Func(Process):

   def __init__(self,name):
       super().__init__()
       self.nm=name

   def run(self): #

       print("子进程:%s is running"%(self.nm))
       time.sleep(3)
       print("子进程:%s is finishing" % (self.nm))
if __name__ == '__main__':

   p_list=[]
   p1 = Func("p1")
   # 只是发送信号给操作系统,治愈操作系统何时执行,还要看系统内部的调用
   p1.start()
   p_list.append(p1)
   p2 = Func("p2")
   p2.start()
   p_list.append(p2)
   # 方法哦一个列表中,for循环来执行join
   for p in p_list:
       p.join()
   print("主进程运行完成")

D:\software2\Python3\install\python.exe E:/PythonProject/new-python/python-test/BasicGrammer/test.py
子进程:p1 is running
子进程:p2 is running
子进程:p1 is finishing
子进程:p2 is finishing
主进程运行完成

Process finished with exit code 0
进程执行了start()后,信号就已经发送给了操作系统,操作系统会根据自己的调度规则,进行运行
join()是让主进程等待多个子进程的运行,此时所有的子进程还是并发执行的,
所有的子进程的运行时间是运行时间最长的子进程的运行时间。当所有子进程运行完成后,继续执行主进程的代码

4.2其他属性和方法

"p.terminate(),p.is_alive,p.name,p.pid"
#!/usr/bin/env python
# -*- coding:utf-8 -*-
# Author: vita
from multiprocessing import Process
import os
import time
# 这里要继承Process
class Func(Process):

   def __init__(self,name):
       super().__init__()
       self.nm=name

   def run(self): #

       print("子进程:%s is running"%(self.nm))
       time.sleep(3)
       print("子进程:%s is finishing" % (self.nm))
if __name__ == '__main__':

   p1 = Func("p1")
   # 只是发送信号给操作系统,至于操作系统何时执行,还要看系统内部的调用
   p1.start()
   # 执行了terminate(),就没有执行子进程的代码了
   p1.terminate()
   # 执行terminate()也是发送给操作系统一个进程终止信号,但不会立刻终止
   print(p1.is_alive())
   print("主进程")
   print("子进程名:%s,子进程pid:%s" %(p1.name,p1.pid))
   time.sleep(2)
   # 休息2秒后,才终止
   print(p1.is_alive())

D:\software2\Python3\install\python.exe E:/PythonProject/new-python/python-test/BasicGrammer/test.py
True
主进程
子进程名:Func-1,子进程pid:14768
False

Process finished with exit code 0

5.练习

5.1思考开启进程的方式一和方式二各开启了几个进程?

总共有主进程+开启的子进程

5.2进程之间的内存空间是共享的还是隔离的?下述代码的执行结果是什么?

"进程间的数据是相互隔离的,所以主进程仍然输出100,子进程是0"
#!/usr/bin/env python
# -*- coding:utf-8 -*-
# Author: vita
from multiprocessing import Process

def work():
    global n
    n=0
    print('子进程内: ',n)

if __name__ == '__main__':
    n = 100  # 在windows系统中应该把全局变量定义在if __name__ == '__main__'之上就可以了
    p=Process(target=work)
    p.start()
    p.join()
    print('主进程内: ',n)

D:\software2\Python3\install\python.exe E:/PythonProject/new-python/python-test/BasicGrammer/test.py
子进程内:  0
主进程内:  100

Process finished with exit code 0

5.3基于多进程实现并发的套接字通信?

"server"
#!/usr/bin/env python
# -*- coding:utf-8 -*-
# Author: vita
from socket import *
from multiprocessing import Process

def talk(conn):
    while True:
        try:
            data = conn.recv(1024)
            if not data: break
            conn.send(data.upper())
        except ConnectionResetError:
            break

    conn.close()

def server(ip,port):
    server = socket(AF_INET, SOCK_STREAM)
    server.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1)
    server.bind((ip,port))
    server.listen(5)

    while True:
        conn, addr = server.accept()
        p = Process(target=talk, args=(conn,))
        p.start()

    server.close()

if __name__ == '__main__':
    server('127.0.0.1', 8080)
"client"
#!/usr/bin/env python
# -*- coding:utf-8 -*-
# Author: vita
from socket import *

client=socket(AF_INET,SOCK_STREAM)
client.connect(('127.0.0.1',8080))

while True:
    msg=input('>>: ').strip()
    if not msg:continue

    client.send(msg.encode('utf-8'))
    data=client.recv(1024)
    print(data.decode('utf-8'))

5.4思考每来一个客户端,服务端就开启一个新的进程来服务它,这种实现方式有无问题?

如果客户端过多,服务端就会开启很多个子进程,会耗尽资源

5.5改写下列程序,分别别实现下述打印效果

1、改写下列程序,分别别实现下述打印效果

from multiprocessing import Process
import time
import random

def task(n):
    time.sleep(random.randint(1,3))
    print('-------->%s' %n)

if __name__ == '__main__':
    p1=Process(target=task,args=(1,))
    p2=Process(target=task,args=(2,))
    p3=Process(target=task,args=(3,))

    p1.start()
    p2.start()
    p3.start()

    print('-------->4')
效果一:保证最先输出-------->4
"上面的代码不做更改,就是首先输出4"
-------->4
-------->1
-------->3
-------->2
效果二:保证最后输出-------->4
"p1.join()
p2.join()
p3.join()
这样就能让主进程等待子进程执行完成后,继续执行主进程,就可最后输出4"
-------->2
-------->3
-------->1
-------->4
效果三:保证按顺序输出
"   p1.start()
        p1.join()
    p2.start()
        p2.join()
    p3.start()
        p3.join()"
-------->1
-------->2
-------->3
-------->4
2、判断上述三种效果,哪种属于并发,哪种属于串行?
"前两种是并发执行,最后一个是串行"

分享文章:操作系统简介&多进程
标题来源:http://scyanting.com/article/gogidp.html