操作系统简介&多进程

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、判断上述三种效果，哪种属于并发，哪种属于串行？
"前两种是并发执行，最后一个是串行"