python下线程以及锁

1、python多线程

 1 #encoding=utf-8
 2 """
 3 python多线程,并非真正意义上的多线程
 4 全局锁:在指定时间里,有且只有一个线程在运行
 5
 6
 7 """
 8 import threading
 9 import time
10
11 def test(p):
12     time.sleep(0.1)
13     print p
14
15 # a = threading.Thread(target=test)
16 # b = threading.Thread(target=test)
17 # a.start()
18 # b.start()
19 #
20 # a.join()
21 # b.join()
22
23 lst =[]
24 for i in xrange(0, 15):
25     th = threading.Thread(target=test, args=[i])
26     lst.append(th)
27
28 for i in lst:
29     i.start()
30
31
32 for i in lst:
33     i.join()
34 print "primary thread end!!!"

2、python下的锁

 1 #encoding=utf-8
 2
 3 """
 4 1、python全局锁:GLT
 5   python多线程在任意时刻下只有一个线程在运行,它是线程安全的
 6 """
 7
 8 import threading
 9
10 num = 0
11 def t():
12     global num
13     num +=1
14     print num
15
16 for i in xrange(0, 10):
17     d = threading.Thread(target=t)
18     d.start()
19
20
21 import time
22 b_time = time.time()
23 _a = threading.Thread(target=t)
24 _b = threading.Thread(target=t)
25 _a.start()
26 _b.start()
27
28 _a.join()
29 _b.join()
30
31 print time.time()-b_time
32
33 """
34 加锁:acquire()
35 解锁:release()
36 RLock()可重入锁
37
38
39 """
40 import threading
41 mlock = threading.Lock()
42 #mlock = threading.RLock()
43
44 num_01 = 0
45 def a():
46     global num_01
47     mlock.acquire()
48     num_01 += 1
49     mlock.release()
50     print num_01
51
52 for i in xrange(0, 10):
53     d = threading.Thread(target=a)
54     d.start()
55     
时间: 2024-10-07 09:39:18

python下线程以及锁的相关文章

Python Threading 线程/互斥锁/死锁/GIL锁

导入线程包 import threading 准备函数线程,传参数 t1 = threading.Thread(target=func,args=(args,)) 类继承线程,创建线程对象 class MyThread(threading.Thread) def run(self): pass if __name__ == "__main__": t = MyThread() t.start() 线程共享全面变量,但在共享全局变量时会出现数据错误问题使用 threading 模块中的

Python下进程与线程的原理及区别

对于所有的语言都可能会遇到进程和线程的问题,一般情况下线程是由进程产生的,一个进程产生多个线程来按照一定的规则(Python下根据CPU调度算法和全局进程锁)来利用CPU,我们称之为多线程模式:而一个进程在产生的同时,同时会生成一个主线程,如果程序生成多个进程,那么每个进程都会产生一个线程,多个程序按照一定的规则去利用CPU,我们称之为多进程模式.                 Python下多线程与多进程关系图原理如下所示:

Python的线程&进程&协程[0] -> 线程 -> 多线程锁的使用

锁与信号量 目录 添加线程锁 锁的本质 互斥锁与可重入锁 死锁的产生 锁的上下文管理 信号量与有界信号量 1 添加线程锁 由于多线程对资源的抢占顺序不同,可能会产生冲突,通过添加线程锁来对共有资源进行控制. 1 import atexit 2 from random import randrange 3 from threading import Thread, Lock, current_thread # or currentThread 4 from time import ctime, s

python线程互斥锁Lock(29)

在前一篇文章 python线程创建和传参 中我们介绍了关于python线程的一些简单函数使用和线程的参数传递,使用多线程可以同时执行多个任务,提高开发效率,但是在实际开发中往往我们会碰到线程同步问题,假如有这样一个场景:对全局变量累加1000000次,为了提高效率,我们可以使用多线程完成,示例代码如下: # !usr/bin/env python # -*- coding:utf-8 _*- """ @Author:何以解忧 @Blog(个人博客地址): shuopython

线程中锁的使用---Python

1.普通同步 用threading.Lock()创建锁,用acquire()申请锁,每次只有一个线程获得锁,其他线程必须等此线程release()后才能获得锁 RLock允许在同一线程中被多次acquire.而Lock却不允许这种情况.注意:如果使用RLock,那么acquire和release必须成对出现,即同一线程中调用了n次acquire,必须调用n次的release才能真正释放所占用的琐 2.条件同步 Condition(条件变量)通常与一个锁关联.需要在多个Contidion中共享一个

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:

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

今天已是学习Python的第十一天,来干一碗鸡汤继续今天的内容,今天的鸡汤是:超越别人对你的期望.本篇博客主要介绍以下几点内容: 线程的基本使用: 线程的锁机制: 生产者消费之模型(队列): 如何自定义线程池: 进程的基本使用: 进程的锁机制: 进程之间如何实现数据共享: 进程池: 协程的基本使用. 一.线程 1.创建线程 上篇博客已经介绍过如何创建多线程的程序,在这里在复习一下如何创建线程过程以及线程的一些方法: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 1

Python:线程

Python的线程是真正的Posix Thread,而不是模拟出来的线程. Python的标准库提供了两个模块:_thread和threading,_thread是低级模块,threading是高级模块,对_thread进行了封装.绝大多数情况下,我们只需要使用threading这个高级模块. 启动一个线程就是把一个函数传入并创建Thread实例,然后调用start()开始执行: import time, threading # 新线程执行的代码: def loop(): print('thre

聊一下Python的线程 & GIL

再来聊一下Python的线程 参考这篇文章 https://www.zhihu.com/question/23474039/answer/24695447 简单地说就是作为可能是仅有的支持多线程的解释型语言(perl的多线程是残疾,PHP没有多线程),Python的多线程是有compromise的,在任意时间只有一个Python解释器在解释Python bytecode.Ruby也是有thread支持的,而且至少Ruby MRI是有GIL的. 首先要了解 GIL,全称 Global Interp