操作系统原理 ,进程,并发

1.进程与程序
    进程:一个正常进行中的程序 是一系列程序执行的过程的总称(抽象概念)
    程序:是由程序员将自己的思维逻辑按照某种编程语言规范编写下来的一堆字符串,最终形成的是一堆文件
    进程由程序产生的,没有程序就没有进程


2.操作系统与进程
    应用程序 无法直接运行在硬件之上,一定要借助操作系统
    所以进程是由操作系统创建的

    操作系统本质也是一款软件,
        操作系统是真正在控制硬件的
        应用程序是在调用操作系统提供的接口
    主要功能:
        1.帮你封装隐藏了丑陋复杂的硬件操作,提供了简单的接口
        2.需要将各个应用程序对硬件的竞争变得优秀


3.多道技术的提高效率的原理就是空间复用和时间复用
多道:(空间复用)
同一时间在内存中存放多个应用程序
多道技术是为了解决同一时间只有一个应用程序被执行的问题

切换:(时间复用)
1.但一个程序A 在执行过程中遇到IO操作(通常都是非常慢的)操作系统就会切换另一个程序
 多个应用程序都在执行(并发)
2.当一个程序A 执行时间过长 也会强制切换到其他的应用程序,以此保证多个程序都在执行
3.如果出现了一个优先级更高的任务 也会切换
保存状态:
    当一个操作系统要从一个进程切换至另一个进程时,必须保存当前进程的状态 以便下次切换回来的时候继续执行
强调:
多个进程之间内存要相互独立 并且是物理层面的隔离(程序是不可能修改的),以保证安全性

多道技术带来的好处:
    1.同一时间可以有多个应用程序在执行 在IO比较多时 极大地提高了效率
弊端:
    如果所有应用程序都没有IO操作 反而会降低效率

应用程序的执行效率取决于IO操作,IO操作越多则效率越低
提高效率:
    1.减少IO
    2.避免被操作系统切换



4.进程的状态
    阻塞态
        遇到IO操作了
    运行态
    就绪态

右键运行->运行状态             没有IO
遇到IO->阻塞                  运行状态
IO完成->就绪                  运行时间过长->就绪
cup切换到你->运行

如何产生进程 以及进程的父子关系
运行一个程序就会产生一个进程
py文件要运行 必须借助python解释器 所以启动的进程是python.exe
同一个程序可以多次运行 产生多个进程
每个进程都会随机分配一个PID(进程ID)
一个进程a开启了另一个进程b b就是a的子进程

在linux中进程以树状形式存在

getpid 自己的pid
getppid  父进程的ppid




创建子进程
from multiprocessing import pool


def task():
    print('子进程执行中')
    print('子进程over')

    p=Process(target)=task #创建进程对象

p.start()

from multiprocessing import Process

import os
# a_apple='一个苹果'
# def task():
#     print('子进程的name',__name__)
#     print('子进程执行中..')
#     print('我是子进程 我的pid:%s 我父进程的pid:%s'%(os.getpid(),os.getppid()))
#     print('子进程over..')
#
# if __name__ == '__main__':
#     print('主进程的name',__name__)
#     print('我是主进程 我的pid:%s'%os.getpid())
#     p=Process(target=task)
#     p.start()

创建子进程方式1

from multiprocessing import Process

import os
# from multiprocessing import  Process
#
#
# class  MyP(Process):
#     def run(self):
#         print("子进程 run")
#
#
# if __name__ == '__main__':
#     MyP().start()

创建子进程方式2

from multiprocessing import Process

import os
# class MyDownload(Process):
#     #如果要增加额外的属性 就可以覆盖init方法
#     def __init__(self,url,name):
#         super().__init__()
#         self.url=url
#         self.name=name
#
#
#     #将要将子进程处理的代码放到该函数下
#     def run(self):
#         print(os.getpid())
#         print('开始下载%s'%self.url)
#         print('下载成功')
#
# if __name__ == '__main__':
#     print('主', os.getpid())
#     p=MyDownload('www.baidu.com','百度下载器')
#     p.start()
#     p.join()

View Code

 

from multiprocessing import Process

import os


# def task(name):
#     print(name)
#
# if __name__ == '__main__':
#     p=Process(target=task,kwargs={'name':'jerry'})
#     p.start()
#     # p.join()
#
#     print('over')

为子进程传参

 

开启进程对于操作系统而言开销是非常大的
windows开启子进程 与linux开启子进程方式不同
为什么开子进程?
因为有一段代码要交给他
所以他一定要读取你的数据 才能帮你处理
linux会直接将主程序的内存 完整的copy到自己的空间中
windows 导入你的程序代码 执行一遍生成一模一样的数据
那就意味着如果子进程读到了创建子进程的代码 它也会创建子进程

结论:在windows中 创建子进程的代码必须放判断下面


并行,并行,串行,阻塞
默认情况下 代码是串行的
串行:按照顺序依次执行 第一行执行完毕后才会执行第二行
需要注意的是 串行执行的过程中 因为计算操作太多也会导致程序卡住 但是这回与IO阻塞不同
io阻塞立马将cpu切到其他程序
而串行执行一堆计算任务 cpu没有切走

阻塞:指的是进程的状态

并发:指多个事件同时发生了(单核下就是通过切换+保存状态来实现 就是多道技术)

并行:真正意义上的同时执行(只在多核处理器才有可能出现)

terminate:
终止进程 与start相同的是 都是给操作系统发送信号 发完继续执行 所以不会立即就终止成功

from multiprocessing import Process
import  time
def task():
    print("11111111111111")
    time.sleep(1)
    print("over")


if __name__ == '__main__':

    p = Process(target=task,name="这是造着玩的进程")
    p.start()
    # print(p.name) # 在创建时可以给进程取名字
    p.join()
    # print(p.exitcode) # 获取进程的退出码  只有进程完全结束后才能获取到
    # print(p.pid) # 获取进程的pid


    print(p.is_alive())
    # p.terminate() # 终止进程 与start相同的是 都是给操作系统发送信号  发完继续执行 所以不会立即就终止成功
    # # time.sleep(2)
    # print( p.is_alive()) # 获取进程的存活状态

process对象重用属性

 

转载于:https://www.cnblogs.com/gengbinjia/p/10478021.html