1、编程语言的发展：
机器语言：二进制
汇编语言：指令，命令形式的
高级语言：面向过程（C）面向对象（python，c++，java）
2、操作系统的目标：
为了用户使用更方便。
作用：
有效性：提高系统资源利用率。
方便性：更加方便用户的使用。
高内聚：内聚指模块内部各部分之间的紧密程度。
低耦合：耦合指模块与模块之间的依赖程度。
3、计算机的组成：
cpu，主板，存储，输入，输出
4、并行、并发
并发：指两件或多件事情，在同一时间间隔内同时执行（宏观上是并行，微观上是串行）
并行：指两件或多件事情，在同一时间点同时执行
5、进程有三部分组成：
代码段，数据段，PCB（进程控制块）
6、进程的三种基本状态：
就绪状态：除了cpu之外，进程获得了需要的所有资源
执行状态：进程获取了需要的所有资源正在执行
阻塞状态：进程由于某些原因放弃了cpu，无法继续执行，此时进程在内存中处于等待状态
7、操作系统的介绍
dos ：单用户单进程
Windows ：单用户多进程（早起的Windows）
unix ：多用户用进程
8、为什么要有操作系统？
1、封装了所有硬件的接口，使用户更加方便的使用
2、对于计算机内的所有资源，进行合理的调度和分配
9、多进程的模块
multiprocessing
Process
10、进程相关知识、操作
1）同步、异步、阻塞、非阻塞
同步：指发送一个请求,需要等待返回,然后才能够发送下一个请求，有个等待过程；
异步：指发送一个请求,不需要等待返回,随时可以再发送下一个请求，即不需要等待。
阻塞：做某件事情，直到完成，除非超时
非阻塞：尝试做，如果不能做，就不做（直接返回），如果能做，就做。
列子：小李喝了想喝水，于是去煮开水。
1、小李把水壶放到炉子上，等待水烧开。（同步阻塞）
小李感觉这样太费时间。
2、小李把水壶放到炉子上，去客厅看电视，时不时去厨房看看水开没有。（同步非阻塞）
小李还是觉得自己这样太累，于是买了把会响笛的那种水壶。水开之后，能发出声音。
3、小李把响水壶放到炉子上，等待水壶发出声音。（异步阻塞）
觉得这样傻等意义不大
4、小李把响水壶放到炉子上，去客厅看电视，水壶响之前不再去看它了，响了再去拿壶。（异步非阻塞）
这样真好。
2）进程的两种开启方法：
a、p = Process(target=None,args=(,) target ：是子进程要执行的任务，args：是父进程给子进程传递的参数
b、自定义类，继承Process父类
3）进程的常用方法
a、start() 开启一个进程 底层调用的是p.run() 这个方法
b、join() 异步变同步（就是让父进程停留在join这句话，等待子进程执行结束，父进程再继续执行）--->>>必须在start()后面
c、is_alive() 判断进程是否活着
d、terminate() 杀死进程
4）进程的常用属性
a、p.name = name 给p进程一个名字
b、p.pid 返回p进程的pid（获取当前进程的pid-->os.getpid() 获取当前进程的父进程的pid---->os.getppid() )
c、p.daemon = True 将p进程设置为守护进程。（True为守护进程，False为普通进程）---->>>必须在start()前面
守护进程的两个特点：
守护进程会随着父进程的代码执行结束而结束
守护进程不能再创建子进程
补充：1、多进程之间不能共享内存
2、如何把父进程和子进程之间的关系变为同步或者异步？
父进程执行join，就会变成同步（join必须放在start()后边），不执行join，父进程和子进程就是异步的关系
from multiprocessing import Process
def func(i):
global n
print(n) # 会报错，func函数的内存和if条件下的内存之间不能共享
if __name__ == '__main__':
n = 100
p = Process(target=func,args=(1,))
p.start()
以下为一些操作的代码：
from multiprocessing import Process # 导入多进程模块
import time
import random
def func(i):
time.sleep(1)
print('我是%s' % i)
if __name__ == '__main__': # pycharm中运行必须这行代码必不可少
l = []
addr = ['太原的','长治的','吕梁的','运城的']
for i in addr:
p = Process(target=func,args=(i,)) # 实例化一个子进程对象并传递相应的参数
p.start() # 开启子进程
l.append(p)
p.join() # 异步转成同步 （必须等待上一个执行完才能执行下一个）
# [i.join() for i in l] # 与p.join()作用一样，但是它的速度比较快
time.sleep(2)
print('我选%s' % random.choice(addr))
##########################开启子进程的一种方式#####################
from multiprocessing import Process
import os
import time
def func(i):
time.sleep(1)
print('这里是子进程，子进程的pid是%s，子进程的父进程的pid是%s' %(os.getpid(),os.getppid()))
if __name__ == '__main__':
for i in range(2):
p = Process(target=func,args=(i,))
p.start()
print('这里是父进程，父进程的pid是%s，父进程的父进程的pid是%s' % (os.getpid(),os.getppid()))
####################开启子进程的另外一种方式，以继承的方式###################
class MyProcess(Process):
def __init__(self,name):
super(MyProcess, self).__init__()
self.name = name
def run(self):
print('这里以继承类的方式开启的子进程,它是%s' % self.name)
if __name__ == '__main__':
p1 = MyProcess('guo')
p1.start() # 解释器告诉操作系统，去帮我开启一个子进程 就绪状态（start会自动调用MyProcess中的Run方法）
# p1.run() # 告诉操作系统，现在马上帮我执行这个子进程 执行
##########杀死子进程##############
from multiprocessing import Process
import time
def func():
print(123)
if __name__ == '__main__':
p = Process(target=func,)
p.start()
time.sleep(0.15) # 0.1不打印123,0.2都是False了，比较完美的结果了
p.terminate() # 杀死p进程
print('子进程是否还活着？',p.is_alive()) # is_alive()返回一个bool值，True就代表活着，否则就代表死了
time.sleep(1)
print('子进程是否还活着？',p.is_alive())
# 打印结果：
#123
#子进程是否还活着？ True
#子进程是否还活着？ False
####################守护进程####################
from multiprocessing import Process
import time
def func():
for i in range(10):
time.sleep(1)
print('子进程%s'% time.strftime('%H:%M:%S'))
if __name__ == '__main__':
p = Process(target=func)
p.daemon = True # 将p进程设置为守护进程，必须要在start之前设置(会随着父进程的结束而结束)
p.start()
time.sleep(5) # 只会产生4个子进程的结果
print('父进程')