并发编程:
    操作系统:(基于单核研究)

    多道技术:

        1、空间上的复用

            多个程序共用一个计算机

        2、时间上的复用

            切换+保存状态

            例如:洗衣 烧水 做饭

            切换:

                1、程序遇到IO操作系统会立刻剥夺着CPU的执行权限   IO:input、sleep、accept、recv...阻塞  日常生活中使用的软件通常都是IO密集型

                2、当你的程序长时间占用CPU的时候也会被操作系统剥夺CPU的执行权限

    进程理论:

        进程调度:

            时间片轮转法+多级反馈队列

        进程三状态:运行、就绪、阻塞

            ps:程序不会立刻进入运行状态,都会先在就绪态等待CPU的执行

        同步异步:指的是任务的提交方式

            同步:提交任务之后原地等待任务的返回结果  期间不做任何事

            异步:提交任务之后就立刻执行下一行代码  不等待任务的返回结果 >>> 结果的获取使用异步回调机制

        阻塞非阻塞:指的是程序的运行状态

            阻塞:阻塞态

            非阻塞:就绪态或者运行态

    创建进程的两种方式:

        使用Process实例化

        继承Process类重写run方法

        ps:windows在开启进程的时候必须在__main__代码块内,因为windows是以模块导入的方式从上执行代码

    什么是进程:正在运行的程序

        一个进程对应到内存中就是一块独立的内存空间

    join方法:主进程等待某个指定的子进程运行结束,不影响其他子进程的运行

    进程对象及其它方法:

        current_process().pid

        os.getpid

        os.getppid

        terminate()

        is_alive()

    守护进程:

        daemon:这一句必须放在start之前使用

    进程数据是隔离的

    互斥锁:

        多个进程操作一份数据的时候会出现数据错乱的现象

        避免?:将操作数据的部分加锁处理(会将并发变成串行牺牲了效率但是保证了数据的安全)

        强锁:acpuire()

        释放锁:release()

        

进程间的通信:

from multiprocessing import Queue
q = Queue(5) # 括号内可以传参数 表示的是这个队列的最大存储数
# 往队列中添加数据
q.put(1)
q.put(2)
# print(q.full()) # 判断队列是否满了
q.put(3)
q.put(4)
q.put(5)
q.put(6) # 当队列满了之后 再放入数据 不会报错 会原地等待 直到队列中有数据被取走(阻塞态)
print(q.get())
print(q.get())
print(q.get())
print(q.empty()) # 判断队列中的数据是否取完
print(q.get())
print(q.get())
print(q.empty())
print(q.get_nowait()) # 取值 没有值不等待直接报错
print(q.get()) # 当队列中的数据被取完之后 再次获取 程序会阻塞 直到有人往队列中放入值
"""
full
get_nowait
empty
都不适用于多进程的情况
"""

进程间通信IPC机制:

from multiprocessing import Process,Queue

def producer(q):
q.put('hello GF~') def consumer(q):
print(q.get()) if __name__ == '__main__':
q = Queue()
p = Process(target=producer,args=(q,))
c = Process(target=consumer, args=(q,))
p.start()
c.start() """
子进程放数据 主进程获取数据
两个子进程相互放 取数据
"""

生产者消费者模型:

from multiprocessing import Process,Queue,JoinableQueue
import random
import time def producer(name,food,q):
for i in range(10):
data = '%s生产了%s%s'%(name,food,i)
time.sleep(random.random())
q.put(data)
print(data) def consumer(name,q):
while True:
data = q.get()
if data == None:break
print('%s吃了%s'%(name,data))
time.sleep(random.random())
q.task_done() # 告诉队列你已经从队列中取出了一个数据 并且处理完毕了 if __name__ == '__main__':
q = JoinableQueue() p = Process(target=producer,args=('大厨','馒头',q))
p1 = Process(target=producer,args=('跟班','生蚝',q))
c = Process(target=consumer,args=('william',q))
c1 = Process(target=consumer,args=('john',q))
p.start()
p1.start()
c.daemon = True
c1.daemon = True
c.start()
c1.start()
p.join()
p1.join() q.join() # 等到队列中数据全部取出

线程:

    进程和线程都是虚拟单位,都是用来帮助我们形象的描述某种事物

    进程:资源单位

    线程:执行单位

        将内存比成加工厂,那么进程就是相当于工厂里面的车间,那么线程就是车间里面的流水线

        ps:每个进程都自带一个线程,线程才是真正的执行单位,进程只是在线程运行过程中提供代码运行所需要的资源

    为什么要有线程:

        开进程:

            1、申请内存空间  耗资源

            2、“拷贝代码”  耗资源

        开线程:

            一个进程内可以开多个线程,并且线程与线程之间数据是共享的

            ps:开启线程的开销要远远小于启动进程的开销

    开启线程的两种方式:

from threading import Thread
import time def task(name):
print('%s is running'%name)
time.sleep(3)
print('%s is over'%name)
# 开线程不需要在__main__代码块内 但是习惯性的还是写在__main__代码块内
t = Thread(target=task,args=('william',))
t.start() # 告诉操作系统开辟一个线程 线程的开销远远小于进程
# 小的代码执行完 线程就已经开启了
print('主')
from threading import Thread
import time class MyThread(Thread):
def __init__(self,name):
super().__init__()
self.name = name def run(self):
print('%s is running'%self.name)
time.sleep(3)
print('%s is over'%self.name) t = MyThread('john')
t.start()
print('主')

    线程对象方法:开启线程不需要在__main__代码块内,但是习惯性的还是写在__main__代码块内

from threading import Thread, current_thread, active_count
import time
import os def task(name, i):
print('%s is running'%name)
# print('子current_thread:',current_thread().name)
# print('子', os.getpid())
time.sleep(i) print('%s is over'%name)
# 开线程不需要在__main__代码块内 但是习惯性的还是写在__main__代码块内
t = Thread(target=task, args=('john',1))
t1 = Thread(target=task, args=('william',2))
t.start() # 告诉操作系统开辟一个线程 线程的开销远远小于进程
t1.start() # 告诉操作系统开辟一个线程 线程的开销远远小于进程
t1.join() # 主线程等待子线程运行完毕
print('当前正在活跃的线程数',active_count())
# 小的代码执行完 线程就已经开启了
print('主')
# print('主current_thread:',current_thread().name)
# print('主', os.getpid())

    守护线程:主线程的结束也就意味着进程的结束,主线程必须等待其它非守护线程的结束才能结束(意味着子线程在运行的时候需要使用进程中的资源,而主线程一旦结束了资源也就销毁了)

from threading import Thread,current_thread
import time def task(i):
print(current_thread().name)
time.sleep(i)
print('GG')
# for i in range(3):
# t = Thread(target=task,args=(i,))
# t.start()
t = Thread(target=task,args=(1,))
t.daemon = True
t.start()
print('主')

    线程间相互通信:

from threading import Thread

money = 666

def task():
global money
money = 999 t = Thread(target=task)
t.start()
t.join()
print(money) # money变成了999

    线程中的互斥锁:

        

from threading import Thread,Lock
import time n = 100 def task(mutex):
global n
mutex.acquire()
tmp = n
time.sleep(0.1)
n = tmp - 1
mutex.release() t_list = []
mutex = Lock()
for i in range(100):
t = Thread(target=task,args=(mutex,))
t.start()
t_list.append(t)
for t in t_list:
t.join()
print(n)

        

    线程中的小例子:

        

from threading import Thread
from multiprocessing import Process
import time
def foo():
print(123)
time.sleep(1)
print("end123") def bar():
print(456)
time.sleep(3)
print("end456") if __name__ == '__main__':
t1=Thread(target=foo)
t2=Thread(target=bar)
t1.daemon=True
t1.start()
t2.start()
print("main-------")

    这里需要注意的是:主线程要等待非守护线程的结束才会结束所以在这里面end123也是会输出的

python基础--线程、进程的更多相关文章

  1. python基础(16)-进程&线程&协程

    进程之multiprocessing模块 Process(进程) Process模块是一个创建进程的模块,借助这个模块,就可以完成进程的创建. 介绍 初始化参数 Process([group [, t ...

  2. python基础之进程、线程、协程篇

    一.多任务(多线程) 多线程特点:(1)线程的并发是利用cpu上下文的切换(是并发,不是并行)(2)多线程执行的顺序是无序的(3)多线程共享全局变量(4)线程是继承在进程里的,没有进程就没有线程(5) ...

  3. Python(线程进程3)

    四 协程 协程,又称微线程,纤程.英文名Coroutine.一句话说明什么是线程:协程是一种用户态的轻量级线程. 协程拥有自己的寄存器上下文和栈.协程调度切换时,将寄存器上下文和栈保存到其他地方,在切 ...

  4. python之线程进程协成

    线程与进程 什么是线程 线程是进程一个实体,是CPU调度和分派的基本单位,它是比进程更小的能独立运行的基本单位,线程自己基本上不拥有系统资源,只拥有一点在运行中必不可少的资源,但是它可与同属一个线程的 ...

  5. python基础(32):进程(二)

    1. multiprocess模块 仔细说来,multiprocess不是一个模块而是python中一个操作.管理进程的包. 之所以叫multi是取自multiple的多功能的意思,在这个包中几乎包含 ...

  6. Python自动化 【第九篇】:Python基础-线程、进程及python GIL全局解释器锁

    本节内容: 进程与线程区别 线程 a)  语法 b)  join c)  线程锁之Lock\Rlock\信号量 d)  将线程变为守护进程 e)  Event事件 f)   queue队列 g)  生 ...

  7. python基础23 -----进程和线程

    一.进程 1.什么是进程? 1.1 进程就是一个程序在一个数据集上的一次动态执行过程.进程一般由程序.数据集.进程控制块三部分组成. 1.2 程序是指进程需要完成那些功能以及如何完成. 1.3 数据集 ...

  8. Python菜鸟之路:Python基础-线程、进程、协程

    上节内容,简单的介绍了线程和进程,并且介绍了Python中的GIL机制.本节详细介绍线程.进程以及协程的概念及实现. 线程 基本使用 方法1: 创建一个threading.Thread对象,在它的初始 ...

  9. Python基础—线程、进程和协程

    今天已是学习Python的第十一天,来干一碗鸡汤继续今天的内容,今天的鸡汤是:超越别人对你的期望.本篇博客主要介绍以下几点内容: 线程的基本使用: 线程的锁机制: 生产者消费之模型(队列): 如何自定 ...

  10. python基础-守护进程、守护线程、守护非守护并行

    守护进程 1.守护子进程 主进程创建守护进程  其一:守护进程会在主进程代码执行结束后就终止  其二:守护进程内无法再开启子进程,否则抛出异常:AssertionError: daemonic pro ...

随机推荐

  1. VS2010版的Speex音频处理模块(附源码+测试demo)

    开源的Speex代码内部包含了VS2003,05,08工程,但是直接编译总有一些要设置的地方,虽说也不是很复杂,但是对于不是很了解VS的同学来说还是要折腾一阵,所以我弄了一个可以直接使用的版本,当然是 ...

  2. Django 操作Cookie与Session

    目录 Cookie Session Django中操作Cookie 基本操作 基于cookie的登录装饰器 Django中操作Session 基本操作 Session流程解析 基于session的登录 ...

  3. 大O法时间复杂度计算

    困惑的点——log,如何计算得出? ① 上限:用来表示该算法可能有的最高增长率. ② 大O表示法:如果某种算法的增长率上限(最差情况下)是f(n),那么说这种算法“在O(f(n))中”.n为输入规模. ...

  4. 我能不能理解成 ssh中service就相当于与jsp+servlet+dao中的servlet???

    转文 首先解释面上意思,service是业务层,dao是数据访问层.(Data Access Objects) 数据访问对象 1.Dao其实一般没有这个类,这一般是指java中MVC架构中的model ...

  5. iOS开发CATransform3D.h属性详解和方法使用

    1.CATransform3D简介 layer有个属性transform,是CATransform3D类型.可以使其在三维界面作平移.缩放和旋转单独或组合动画! CATransform3D结构体: / ...

  6. Linux 日期时间命令

    cal : 显示日历 -1 显示一个月的月历 -3 显示系统前一个月,当前月,下一个月的月历 -s  显示星期天为一个星期的第一天,默认的格式 -m 显示星期一为一个星期的第一天 -j  显示在当年中 ...

  7. Hack Tools

    Tools 2011-03-17 13:54:36|  分类: Security|举报|字号 订阅     Packet Shaper:Nemesis: a command line packet s ...

  8. js中控制流管理的四种方法

    引自http://es6.ruanyifeng.com/#docs/generator#yield--表达式 1.常用的回调方法 step1(function (value1) { step2(val ...

  9. 长按触发(PC端和移动端)

    $.fn.longPress = function(fn) { var timeout = undefined; var $this = this; for(var i = 0;i<$this. ...

  10. day43作业

    注册页面: <!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF ...