python gil 还会有锁冲突吗_“python有了GIL，为什么还有线程锁？“

“python有了GIL，为什么还有线程锁？“

python gil教程2020-10-07 06:24:23人已围观

有没有易懂的 Python 多线程爬虫代码

Python 序并行化方面多少声名狼藉。撇开技术上的问题如线程的实现和 GIL1，我觉得错教学指导才是主要问题。常见的经典 Python 多线程、多进程教程多显得偏“重”。而且往往隔靴搔痒，没有深入探讨日常工作中最有用的内容。

传统的例子

简单搜索下“Python 多线程教程”，不难发现几乎所有的教程都给出涉及类和队列的例子：

#Example.py'''

Standard Producer/Consumer Threading Pattern

'''import time

import threading

import Queue

class Consumer(threading.Thread):

def __init__(self, queue):

threading.Thread.__init__(self)

self._queue = queue

def run(self):

while True:

# queue.get() blocks the current thread until

# an item is retrieved.

msg = self._queue.get()

# Checks if the current message is

# the "Poison Pill"

if isinstance(msg, str) and msg == 'quit': # if so, exists the loop

break

# "Processes" (or in our case, prints) the queue item

print "I'm a thread, and I received %s!!" % msg # Always be friendly!

print 'Bye byes!'def Producer():

# Queue is used to share items between

# the threads.

queue = Queue.Queue() # Create an instance of the worker

worker = Consumer(queue) # start calls the internal run() method to

# kick off the thread

worker.start()

# variable to keep track of when we started

start_time = time.time()

# While under 5 seconds..

while time.time() - start_time < 5:

# "Produce" a piece of work and stick it in

# the queue for the Consumer to process

queue.put('something at %s' % time.time()) # Sleep a bit just to avoid an absurd number of messages

time.sleep(1) # This the "poison pill" method of killing a thread.

queue.put('quit') # wait for the thread to close down

worker.join()if __name__ == '__main__':

Producer()

哈，看起来有些像 Java 不是吗？

我并不是说使用生产者/消费者模型处理多线程/多进程任务是错误的(事实上，这一模型自有其用武之地)。只是，处理日常脚本任务时我们可以使用更有效率的模型。

问题在于…

首先，你需要一个样板类；

其次，你需要一个队列来传递对象；

而且，你还需要在通道两端都构建相应的方法来协助其工作(如果需想要进行双向通信或是保存结果还需要再引入一个队列)。

worker 越多，问题越多

按照这一思路，你现在需要一个 worker 线程的线程池。下面是一篇 IBM 经典教程中的例子——在进行网页检索时通过多线程进行加速。

#Example2.py'''

A more realistic thread pool example

'''import time

import threading

import Queue

import urllib2

class Consumer(threading.Thread):

def __init__(self, queue):

threading.Thread.__init__(self)

self._queue = queue

def run(self):

while True:

content = self._queue.get()

if isinstance(content, str) and content == 'quit': break

response = urllib2.urlopen(content) print 'Bye byes!'def Producer():

urls = [ 'http', 'httcom'

'ala.org', 'hle.com'

# etc..

]

queue = Queue.Queue()

worker_threads = build_worker_pool(queue, 4)

start_time = time.time() # Add the urls to process

for url in urls:

queue.put(url)

# Add the poison pillv

for worker in worker_threads:

queue.put('quit') for worker in worker_threads:

worker.join() print 'Done! Time taken: {}'.format(time.time() - start_time)def build_worker_pool(queue, size):

workers = [] for _ in range(size):

worker = Consumer(queue)

worker.start()

workers.append(worker) return workersif __name__ == '__main__':

Producer()

这段代码能正确的运行，但仔细看看我们需要做些什么：构造不同的方法、追踪一系列的线程，还有为了解决恼人的死锁问题，我们需要进行一系列的 join 操作。这还只是开始……

至此我们回顾了经典的多线程教程，多少有些空洞不是吗？样板化而且易出错，这样事倍功半的风格显然不那么适合日常使用，好在我们还有更好的方法。

何不试试 map

map 这一小巧精致的函数是简捷实现 Python 程序并行化的关键。map 源于 Lisp 这类函数式编程语言。它可以通过一个序列实现两个函数之间的映射。

urls = ['ho.com', 'htdit.com']

results = map(urllib2.urlopen, urls)

上面的这两行代码将 urls 这一序列中的每个元素作为参数传递到 urlopen 方法中，并将所有结果保存到 results 这一列表中。其结果大致相当于：

results = []for url in urls:

results.append(urllib2.urlopen(url))

map 函数一手包办了序列操作、参数传递和结果保存等一系列的操作。

为什么这很重要呢？这是因为借助正确的库，map 可以轻松实现并行化操作。

在 Python 中有个两个库包含了 map 函数： multiprocessing 和它鲜为人知的子库 multiprocessing.dummy.

这里多扯两句： multiprocessing.dummy？ mltiprocessing 库的线程版克隆？这是虾米？即便在 multiprocessing 库的官方文档里关于这一子库也只有一句相关描述。而这句描述译成人话基本就是说:"嘛，有这么个东西，你知道就成."相信我，这个库被严重低估了！

dummy 是 multiprocessing 模块的完整克隆，唯一的不同在于 multiprocessing 作用于进程，而 dummy 模块作用于线程(因此也包括了 Python 所有常见的多线程限制)。

所以替换使用这两个库异常容易。你可以针对 IO 密集型任务和 CPU 密集型任务来选择不同的库。2

动手尝试

使用下面的两行代码来引用包含并行化 map 函数的库：

from multiprocessing import Poolfrom multiprocessing.dummy import Pool as ThreadPool

实例化 Pool 对象：

pool = ThreadPool()

这条简单的语句替代了 example2.py 中 build_worker_pool 函数 7 行代码的工作。它生成了一系列的 worker 线程并完成初始化工作、将它们储存在变量中以方便访问。

Pool 对象有一些参数，这里我所需要关注的只是它的第一个参数：processes. 这一参数用于设定线程池中的线程数。其默认值为当前机器 CPU 的核数。

一般来说，执行 CPU 密集型任务时，调用越多的核速度就越快。但是当处理网络密集型任务时，事情有有些难以预计了，通过实验来确定线程池的大小才是明智的。

pool = ThreadPool(4) # Sets the pool size to 4

线程数过多时，切换线程所消耗的时间甚至会超过实际工作时间。对于不同的工作，通过尝试来找到线程池大小的最优值是个不错的主意。

创建好 Pool 对象后，并行化的程序便呼之欲出了。我们来看看改写后的 example2.py

import urllib2

from multiprocessing.dummy import Pool as ThreadPool

urls = [ 'httorg',

'hon.org/about/',

'hnlamp.com/pub/a/python/2003/04/17/metaclasses.html',

# etc..

]

# Make the Pool of workers

pool = ThreadPool(4)

# Open the urls in their own threads

# and return the results

results = pool.map(urllib2.urlopen, urls)

#close the pool and wait for the work to finish

pool.close()

pool.join()

实际起作用的代码只有 4 行，其中只有一行是关键的。map 函数轻而易举的取代了前文中超过 40 行的例子。为了更有趣一些，我统计了不同方法、不同线程池大小的耗时情况。

# results = [] # for url in urls:# result = urllib2.urlopen(url)# results.append(result)# # ------- VERSUS ------- # # # ------- 4 Pool ------- # # pool = ThreadPool(4) # results = pool.map(urllib2.urlopen, urls)# # ------- 8 Pool ------- # # pool = ThreadPool(8) # results = pool.map(urllib2.urlopen, urls)# # ------- 13 Pool ------- # # pool = ThreadPool(13) # results = pool.map(urllib2.urlopen, urls)

结果：

# Single thread: 14.4 Seconds # 4 Pool: 3.1 Seconds# 8 Pool: 1.4 Seconds# 13 Pool: 1.3 Seconds

很棒的结果不是吗？这一结果也说明了为什么要通过实验来确定线程池的大小。在我的机器上当线程池大小大于 9 带来的收益就十分有限了。

python有了GIL，为什么还有线程锁？

GIL是限制同一个有一个进入Python解释。。。。

而线程锁是由于在线程进行数据操作时数据操作的安全性(同一个进程中线程之间可以共用信息，如果同时对数据进行操作，则会出现公共数据错误)

其实线程锁完全可以替代GIL，但是Python的后续功能模块都是加在GIL基础上的，所以无法更改或去掉GIL,这就是Python语言最大的bug…只能用多进程或协程改善，或者直接用其他语言写这部分

零基础学Python应该学习哪些入门知识

1、Python入学

Python的特性、优点、缺点、前及 python能做些？

2、Python环境安装

一键安装Python的环境，写出第一段Python代码

3、理解什么是写代码与Python的基本类型

Python的基本类型，包括整形、浮点型；10、8、2、16进制数的意义和转换关系；布尔类型；字符串与字符串常见运算操作

4、Python中表示“组”的概念与定义

了解“组”的概念，以及在Python中用来表示“组”的一些类型，包括：元组、列表、集合和字典。

5、变量与运算符

了解变量的意义与七种运算符，并对每一种运算符的扩展做出详细的讲解

6、分支、循环、条件与枚举

代码的基本逻辑结构，包括条件控制(if else)、循环控制(for in 、while)、表达式与运算符的优先级。此外，还有Python的枚举类型以及Python编码的规范。

7、包、模块、函数与变量作用域

了解Python代码的组织结构核心：包、模块与函数。需要对Python代码的组织结构有一个非常清晰的认识。重点是函数，除了了解函数的基本概念外，还需要了解Python灵活的函数参数机制(默认参数、关键字参数与列表参数)。

8、Python函数

函数是所有语言中都具备的基本代码组织结构。函数的重要性不言而喻。而对于Python来说，函数的用法及其灵活，远比其他语言要强大很多。了解Python函数的定义、调用、序列解包、必须参数、关键字参数、默认参数等诸多内容。

9、高级部分：面向对象

了解面向对象的概念。包括面向对象的三大特性(继承、封装、多态)、类的基本构成元素、python的内置类属性、方法重写、运算符重载、静态方法等

10、正则表达式与JSON

正则表达式也是文本解析中非常重要的知识点。了解如何在Python中编写正则表达式与常见的正则表达式。此外，重点了解包括JSON对象，JSON字符串，Python类型与JSON的转换。

11、Python的高级语法与用法

了解Python进阶部分的高级特性，如枚举、闭包

12、函数式编程： 匿名函数、高阶函数、装饰器

进一步了解函数式编程的lambda、mapeduce、filter以及装饰器

13、实战：原生爬虫

学习如何访问网络数据、获取与解析网络数据、爬虫的基本原理解释。并用最基础语法不使用爬虫框架的原生爬虫项目。

14、Pythonic与Python杂记

了解扩展Python的优秀写法，学会如何写出优质的Pythonic风格的代码。包括：如何让字典保持有序、lmbda表达式的应用等高级Python知识

为什么很多人对Python的GIL耿耿于怀

在python的原始解释器CPython中存在着GIL(Global Interpreter Lock，解锁)，因此在解释python代码会产生互斥锁来限制线程对共享资源的访问，直到解释器遇到I/O操作或者操作次数达到一定数目时才会释放GIL。

所以，虽然CPython的线程库直接封装了系统的原生线程，但CPython整体作为一个进程，同一时间只会有一个获得GIL的线程在跑，其他线程则处于等待状态。这就造成了即使在多核CPU中，多线程也只是做着分时切换而已。

Python的GIL是什么，怎么来的，对性能的影响

#! /usr/bin/python

from threading import Thread

import time

def my_counter():

i = 0

for _ in range(100000000):

i = i   1

return True

def main():

thread_array = {}

start_time = time.time()

for tid in range(2):

t = Thread(target=my_counter)

t.start()

t.join()

end_time = time.time()

print("Total time: {}".format(end_time - start_time))

if __name__ == '__main__':

main()

版权声明：本站所有文章皆为原创，欢迎转载或转发，请保留网站地址和作者信息。