标签：head span 特点 最小 轮询 art cti 复用 day
#一 操作系统的作用：1：隐藏丑陋复杂的硬件接口，提供良好的抽象接口
2：管理、调度进程，并且将多个进程对硬件的竞争变得有序
#二 多道技术：
1.产生背景：针对单核，实现并发
ps：
现在的主机一般是多核，那么每个核都会利用多道技术
有4个cpu，运行于cpu1的某个程序遇到io阻塞，会等到io结束再重新调度，会被调度到4个
cpu中的任意一个，具体由操作系统调度算法决定。
2.空间上的复用：如内存中同时有多道程序
3.时间上的复用：复用一个cpu的时间片
强调：遇到io切，占用cpu时间过长也切，核心在于切之前将进程的状态保存下来，这样
才能保证下次切换回来时，能基于上次切走的位置继续运行
多道程序设计：
在不同用户遇到IO进行切换操作，当用户A IO阻塞时，切换到B用户，当B执行完再处理A
SPOOLING： 外部设备联机操作
分时操作系统： 多个联机操作 + 多道程序设计 类似原先网吧的分屏技术
程序是程序， 程序运行才会产生进程
进程： 本质上就是一段程序运行过程（一段抽象概念） 就是一个过程
定义： 进程就是一个程序在数据集上的一次动态执行过程
进程一般是由程序、数据集、进程控制块三部分组成
数据集： 程序运行过程中所需的一切数据资源
进程控制块： 目的是用于切换，状态保存，恢复操作
进程切换： IO切换，时间轮询切换
进程：最小的资源单元
线程：最小的执行单元，微进程 (运行实例)
特点：共享整个进程的内存，数据集
单个的线程不可能脱离进程而存在
一个线程可以创建和撤销另一个线程；同一个进程中的多个线程之间可以并发执行
一个进程至少得有一个线程
程序运行在内存中，CPU在取内存中的数据拿出并执行，
程序计数器： 真正保存的就是一个内存地址， 上下文切换的时候在取出上一次的运行状态，并进程恢复执行操作
############# 进程运行，生成子线程，主子线程开始顺序运行，遇至 IO阻塞开始执行下一条。
import threading
import time
def Tv():
print(time.ctime())
print('look Tv')
time.sleep(2)
print(time.ctime())
# 生成一个对象
T=threading.Thread(target=Tv)
# 跟socket一样调用threading父类的start方法执行
T.start()
print('start ')# 结果
Thu Jan 18 15:00:50 2018 look Tv start Thu Jan 18 15:00:52 2018
############ 线程之间可以并发执行 顺序执行 ，执行完主线程然后再执行子线程，直到程序退出
import threading
import time
def Tv():
print('tv show start time ',time.ctime())
print('look Tv')
time.sleep(2)
print('tv show end time ',time.ctime())
def Eat():
print('eat start time ',time.ctime())
print('eat ')
time.sleep(2)
print('eat end time ',time.ctime())
# 生成一个对象
T=threading.Thread(target=Tv)
# 跟socket一样调用threading父类的start方法执行
T.start()
T2=threading.Thread(target=Eat)
T2.start()
print('start ')# 结果
tv show start time Thu Jan 18 15:06:00 2018 look Tv eat start time Thu Jan 18 15:06:00 2018 eat start tv show end time Thu Jan 18 15:06:02 2018 eat end time Thu Jan 18 15:06:02 2018
######## 当程序中有join时，会先执行子线程的程序，最后再去执行主线程的代码，并发运行
import threading
import time
def Tv():
print('tv show start time ',time.ctime())
print('look Tv')
time.sleep(2)
print('tv show end time ',time.ctime())
def Eat():
print('eat start time ',time.ctime())
print('eat ')
time.sleep(2)
print('eat end time ',time.ctime())
# 生成一个对象
T=threading.Thread(target=Tv)
T2=threading.Thread(target=Eat)
T.start()
T2.start()
T.join()
T2.join()
print('start ')# 结果
tv show start time Thu Jan 18 15:14:15 2018 look Tv eat start time Thu Jan 18 15:14:15 2018 eat tv show end time Thu Jan 18 15:14:17 2018 eat end time Thu Jan 18 15:14:17 2018 start
######## 如果join在start前，那么就会先执行子线程中的程序 然后再执行下一段子线程，就无法实现并发的效果了
setDaemon(True) 守护线程
当主线程退出之后，子线程也会直接跟着退出
其它方法：
Thread实例对象的方法 # isAlive(): 返回线程是否活动的。 # getName(): 返回线程名。 # setName(): 设置线程名。
# 继承 threading.Thread 需要重写一下run方法
class Mythread(threading.Thread):
def __init__(self,num):
# 继承父类的 init方法
threading.Thread.__init__(self)
self.num = num
# 重写run方法 跟sockserver的header方法一样
def run(self):
print('测试一下: %s' %self.num)
time.sleep(2)
if __name__ == '__main__':
t1=Mythread(11111)
t2=Mythread(22222)
t1.start() # 使用start方法，类继承方法必须要有run方法
t2.start()
print(t1.getName()) # Thread-1
t1.setName('test_Thread')
print(t1.getName()) # test_Thread
print('主线程跑起来')# 结果
测试一下: 11111 测试一下: 22222 主线程跑起来
标签：head span 特点 最小 轮询 art cti 复用 day
原文地址：http://blog.51cto.com/xiong51/2062515
