python_day10_并发

Posted

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了python_day10_并发相关的知识,希望对你有一定的参考价值。

#一 操作系统的作用:

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


以上是关于python_day10_并发的主要内容,如果未能解决你的问题,请参考以下文章

python_day10

PYTHON_DAY_05

python_day10 线程

python_day10 多线程 协程 IO模型

Python_Day10_进程线程协程

铁乐学python_Day41_线程01