python_day10_并发

Posted 2020-10-21

#一 操作系统的作用：

    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
	主线程跑起来