python多线程

Python程序中的线程操作-锁 一、同步锁 1.1 多个线程抢占资源的情况 from threading import Thread import os,time def work(): global n temp=n time.sleep(0.1) n=temp-1 if __name__ == '__main__': n=100 l=[] for i in range(100): p=Thread(target=work) l.append(p) p.start() for p in l: p.join() print(n) #结果可能为99 1.1.1 对公共数据的操作 import threading R=threading.Lock() R.acquire() ''' 对公共数据的操作 ''' R.release() 1.2 同步锁的引用 from threading import Thread,Lock import os,time def work(): global n lock.acquire() temp=n time.sleep(0.1) n=temp-1 lock.release() if __name__ == '__main__': lock=Lock() n=100 l=[] for i in range(100): p=Thread(target

目标：让服务端能够支持高并发+高性能一、 操作系统发展史 多道技术（*****） 产生背景：想要在单核下实现并发 多道技术的核心： 1、空间上的复用（具体指的是内存中同时读入多道程序，多道程序的内存空间是物理隔离） 2、时间上的复用（复用cpu的时间） 切换+保存状态=》并发 切换： 1、遇到IO切换（可以提升效率） 2、运行时间过长或者有一个优先级更高的进程抢走了cpu（反而会降低效率） 二、进程 （参考博客： https://www.cnblogs.com/linhaifeng/articles/7428874.html ） 1、进程理论（*****） 1、进程与程序区别 2、并发与并行 并发：看起来同时运行，单核就可以实现并发，但是单核无法实现并行 并行：真正意义上的同时运行，一个cpu同一时刻只能做一件事 只有多核才能同时做多件事，即并行的效果 串行：按照固定的顺序一个个地执行 3、不同操作系统开启子进程的区别 4、一个进程的三种运行状态 2、开启进程的两种方式（*****） #方式一 from multiprocessing import Process import time def task(name): print('%s is running' %name) time.sleep(3) print('%s is done' %name) if __name__ =

本段源码可以学习的地方： 1. 考虑到效率问题，可以通过上下文的机制，在属性被访问的时候临时构建； 2. 可以重写一些魔术方法，比如 __new__ 方法，在调用 object. __new__ (cls) 前后进行属性的一些小设置； 3. 在本库中使用的重写魔术方法，上下文这两种基础之上，我们可以想到函数装饰器，类装饰器，异常捕获，以及两种上下文的结构； 灵活运用这些手法，可以让我们在代码架构上更上一层，能够更加省时省力。 1 from weakref import ref # ref用在了构造大字典元素元组的第一个位置即 (ref(Thread), 线程字典) 2 from contextlib import contextmanager # 上下文管理，用来确保__dict__属性的存在 3 from threading import current_thread, RLock 4 __all__ = ["local"] 5 6 class _localimpl: # local()._local__impl = _localimpl() # local()实例的属性_local__impl就是这个类的实例 7 """一个管理线程字典的类""" 8 __slots__ = 'key', 'dicts', 'localargs', 'locallock', '__weakref

线程和进程的操作是由程序触发系统接口，最后的执行者是系统；协程的操作则是程序员。 协程存在的意义：对于多线程应用，CPU通过切片的方式来切换线程间的执行，线程切换时需要耗时（保存状态，下次继续）。协程，则只使用一个线程，在一个线程中规定某个代码块执行顺序。 协程的适用场景：当程序中存在大量不需要CPU的操作时（IO），适用于协程； event loop是协程执行的控制点， 如果你希望执行协程， 就需要用到它们。 event loop提供了如下的特性： 　　1、注册、执行、取消延时调用(异步函数) 　　2、创建用于通信的client和server协议(工具) 　　3、创建和别的程序通信的子进程和协议(工具) 　　4、把函数调用送入线程池中 协程示例一： 1 #!/usr/bin/env python 2 # -*- coding:utf-8 -*- 3 """ 4 协程示例 5 """ 6 import asyncio 7 8 async def test1(): 9 print("test1, starting") 10 await test2() 11 print("test1, ending") 12 13 async def test2(): 14 print("test2 start") 15 16 loop = asyncio.get_event_loop()

Anthony Minssale/文 Seven /译 VoIP通信，与传统的电话技术相比，不仅仅在于绝对的资费优势，更重要的是很容易地通过开发相应的软件，使其与企业的业务逻辑紧密集成。Asterisk作为开源VoIP软件的代表，以其强大的功能及相对低廉的建设成本，受到了全世界开发者的青睐。而FreeSWITCH作为VoIP领域的新秀，在性能、稳定性及可伸缩性等方面则更胜一筹。本文原文在 http://www.freeswitch.org/node/117 ， 发表于2008年4月，相对日新月异的技术来讲，似乎有点过时。但本文作为FreeSWITCH背后的故事，仍很有翻译的必要。因此，本人不揣鄙陋，希望与大家共读此文，请不吝批评指正。 –译者注 FreeSWITCH 与 Asterisk 两者有何不同？为什么又重新开发一个新的应用程序呢？最近，我听到很多这样的疑问。 为此，我想对所有在该问题上有疑问的电话专家和爱好者们解释一下。我曾有大约三年的时间用在开发 Asterisk 上，并最终成为了 FreeSWITCH 的作者。因此，我对两者都有相当丰富的经验。首先，我想先讲一点历史以及我在 Asterisk 上的经验；然后，再来解释我开发FreeSWITCH的动机以及我是如何以另一种方式实现的。 我从2003年开始接触 Asterisk，当时它还不到1.0版。那时对我来讲

目录 (?) [-] Go语言的并发和并行 goroutine是在并行吗 并行和并发 真正的并行 一个小问题 runtime调度器 总结 开启多核的实验 Go语言的并发和并行 不知道你有没有注意到一个现象，还是这段代码，如果我跑在两个goroutines里面的话: var quit chan int = make ( chan int ) func loop () { for i := 0 ; i < 10 ; i ++ { fmt . Printf ( "%d " , i ) } quit <- 0 } func main () { // 开两个goroutine跑函数loop, loop函数负责打印10个数 go loop () go loop () for i := 0 ; i < 2 ; i ++ { <- quit } } 我们观察下输出: 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 这是不是有什么问题？? 以前我们用线程去做类似任务的时候，系统的线程会抢占式地输出， 表现出来的是乱序地输出。而goroutine为什么是这样输出的呢？ goroutine是在并行吗？ 我们找个例子测试下: package main import "fmt" import "time" var quit chan int func foo ( id int

Python的GIL锁 - Python内置的一个全局解释器锁，锁的作用就是保证同一时刻一个进程中只有一个线程可以被cpu调度。 为什么有这把GIL锁？ 答：Python语言的创始人在开发这门语言时，目的快速把语言开发出来，如果加上GIL锁（C语言加锁），　　　　切换时按照100条字节指令来进行线程间的切换。 一、锁： Lock 1、一次放一个 　　threading.Lock 线程安全，多线程操作时，内部会让所有线程排队处理。如：list/dict/ Queue 线性不安全 + 人 =》 排队处理 import threading v = [] def func(arg): v.append(arg) # 线程安全 print(v) for i in range(10): t =threading.Thread(target=func,args=(i,)) t.start() 线性安全 import threading import time v = [] lock = threading.Lock() def func(arg): lock.acquire() v.append(arg) time.sleep(0.01) m = v[-1] print(arg,m) lock.release() for i in range(10): t =threading.Thread

对Python多线程实现同步机制及其遇到的一些问题。本文给出了样例代码 ，主要包括Condition,Event and Queue三种机制 1. 锁机制 threading的Lock类，用该类的acquire函数进行加锁，用realease函数进行解锁，当一个线程调用锁的acquire()方法获得锁时，锁就进入“locked”状态。每次只有一个线程可以获得锁。如果此时另一个线程试图获得这个锁，该线程就会变为“blocked”状态，称为“同步阻塞” 在此没有给出样例后面条件 2.条件 Contidion 代码段： class Reader(threading.Thread): def __init__(self, condition, data): threading.Thread.__init__(self) self.condition = condition self.data = data pass def run(self): while True: with self.condition: print("waiting...") self.condition.wait() msg = self.data.pop() if "exit" == str(msg).lower(): print ("exit") break print("read date:{}"

老规矩，先理解概念 冯诺依曼体系： 　　输入设备：键盘、鼠标 　　存储器：内存 　　输出设备：显示器、投影仪、打印机 程序：一个包含了代码片被编译后的文件 进程：系统通过解析程序文件 加载到内存中 的对象，进程是 资源 分配和调度的 基本单位 (分配cpu， 分配内存大小，它由系统进行调度)，进程中包含 指令 (if, for…)、 数据 (变量,函数…)、 线程 (他也是线程的容器)，他是操作系统结构的基础。 线程：进程中真正干活的人，线程是 资源调度 的最小单元，是 程序 执行流的最小单元，线程中包含 线程id 、 当前指令的指针 (线程会切换，再次运行还能从阻塞的位置继续)， 寄存器集合 (线程切换，这个线程执行的结果进行保存)、 堆栈 (栈是先进后出，执行一个函数要先生成函数对象->函数压栈->变量引用压栈->调用函数->弹出栈顶，线程执行的其实也就是函数中大代码片，从Thread的target参数就能看出来，它接收的是一个函数或则方法) 进程 注释： 1：每一个进程都认为自己独占所有的计算机硬件资源() 2: 进程间不共享数据(这里就要解决进程间通信的问题) 线程 注释：上边已经大致讲了一下线程，这里再说一下线程的特点 1：一个进程中可以有多个线程，同一个进程中的线程共享数据资源(这里需要学好python中的作用域，因为python是用作用域来控制进程中的资源

收拾了一下自己学习Python过程中的笔记，将Python面试过程中经常涉及到的一些问题整理出来。没有总结到的知识点，欢迎大家在评论里提出来，本文长期更新。 1、Python基本语法 1、@staticmethod 和 @classmethod Python中有三种方法，实例方法、类方法(@classmethod)、静态方法(@staticmethod)。 类方法的第一个参数是cls，表示该类的一个实例，静态方法基本上和一个全局函数相同 class A(object): def foo(self, x): print("executing foo(%s,%s)" % (self, x)) print('self:', self) @classmethod def class_foo(cls, x): print("executing class_foo(%s,%s)" % (cls, x)) print('cls:', cls) @staticmethod def static_foo(x): print("executing static_foo(%s)" % x) a = A() print(a.foo(1)) print(a.class_foo(1)) print(a.static_foo(1)) 2、迭代器和生成器 迭代器：是访问集合元素的一种方式