python線程中的數據_python多線程怎樣同步

㈠ python中的各種鎖

大致羅列一下：
一、全局解釋器鎖（GIL）
1、什麼是全局解釋器鎖
每個CPU在同一時間只能執行一個線程，那麼其他的線程就必須等待該線程的全局解釋器，使用權消失後才能使用全局解釋器，即使多個線程直接不會相互影響在同一個進程下也只有一個線程使用cpu，這樣的機制稱為全局解釋器鎖（GIL）。GIL的設計簡化了CPython的實現，使的對象模型包括關鍵的內建類型，如：字典等，都是隱含的，可以並發訪問的，鎖住全局解釋器使得比較容易的實現對多線程的支持，但也損失了多處理器主機的並行計算能力。
2、全局解釋器鎖的好處
1）、避免了大量的加鎖解鎖的好處
2）、使數據更加安全，解決多線程間的數據完整性和狀態同步
3、全局解釋器的缺點
多核處理器退化成單核處理器，只能並發不能並行。
4、GIL的作用：
多線程情況下必須存在資源的競爭，GIL是為了保證在解釋器級別的線程唯一使用共享資源（cpu）。
二、同步鎖
1、什麼是同步鎖？
同一時刻的一個進程下的一個線程只能使用一個cpu，要確保這個線程下的程序在一段時間內被cpu執，那麼就要用到同步鎖。
2、為什麼用同步鎖？
因為有可能當一個線程在使用cpu時，該線程下的程序可能會遇到io操作，那麼cpu就會切到別的線程上去，這樣就有可能會影響到該程序結果的完整性。
3、怎麼使用同步鎖？
只需要在對公共數據的操作前後加上上鎖和釋放鎖的操作即可。
4、同步鎖的所用：
為了保證解釋器級別下的自己編寫的程序唯一使用共享資源產生了同步鎖。
三、死鎖
1、什麼是死鎖？
指兩個或兩個以上的線程或進程在執行程序的過程中，因爭奪資源或者程序推進順序不當而相互等待的一個現象。
2、死鎖產生的必要條件？
互斥條件、請求和保持條件、不剝奪條件、環路等待條件
3、處理死鎖的基本方法？
預防死鎖、避免死鎖（銀行家演算法）、檢測死鎖（資源分配）、解除死鎖：剝奪資源、撤銷進程
四、遞歸鎖
在Python中為了支持同一個線程中多次請求同一資源，Python提供了可重入鎖。這個RLock內部維護著一個Lock和一個counter變數，counter記錄了acquire的次數，從而使得資源可以被多次require。直到一個線程所有的acquire都被release，其他的線程才能獲得資源。遞歸鎖分為可遞歸鎖與非遞歸鎖。
五、樂觀鎖
假設不會發生並發沖突，只在提交操作時檢查是否違反數據完整性。
六、悲觀鎖
假定會發生並發沖突，屏蔽一切可能違反數據完整性的操作。
python常用的加鎖方式：互斥鎖、可重入鎖、迭代死鎖、互相調用死鎖、自旋鎖大致羅列一下：
一、全局解釋器鎖（GIL）
1、什麼是全局解釋器鎖
每個CPU在同一時間只能執行一個線程，那麼其他的線程就必須等待該線程的全局解釋器，使用權消失後才能使用全局解釋器，即使多個線程直接不會相互影響在同一個進程下也只有一個線程使用cpu，這樣的機制稱為全局解釋器鎖（GIL）。GIL的設計簡化了CPython的實現，使的對象模型包括關鍵的內建類型，如：字典等，都是隱含的，可以並發訪問的，鎖住全局解釋器使得比較容易的實現對多線程的支持，但也損失了多處理器主機的並行計算能力。
2、全局解釋器鎖的好處
1）、避免了大量的加鎖解鎖的好處
2）、使數據更加安全，解決多線程間的數據完整性和狀態同步
3、全局解釋器的缺點
多核處理器退化成單核處理器，只能並發不能並行。
4、GIL的作用：
多線程情況下必須存在資源的競爭，GIL是為了保證在解釋器級別的線程唯一使用共享資源（cpu）。
二、同步鎖
1、什麼是同步鎖？
同一時刻的一個進程下的一個線程只能使用一個cpu，要確保這個線程下的程序在一段時間內被cpu執，那麼就要用到同步鎖。
2、為什麼用同步鎖？
因為有可能當一個線程在使用cpu時，該線程下的程序可能會遇到io操作，那麼cpu就會切到別的線程上去，這樣就有可能會影響到該程序結果的完整性。
3、怎麼使用同步鎖？
只需要在對公共數據的操作前後加上上鎖和釋放鎖的操作即可。
4、同步鎖的所用：
為了保證解釋器級別下的自己編寫的程序唯一使用共享資源產生了同步鎖。
三、死鎖
1、什麼是死鎖？
指兩個或兩個以上的線程或進程在執行程序的過程中，因爭奪資源或者程序推進順序不當而相互等待的一個現象。
2、死鎖產生的必要條件？
互斥條件、請求和保持條件、不剝奪條件、環路等待條件
3、處理死鎖的基本方法？
預防死鎖、避免死鎖（銀行家演算法）、檢測死鎖（資源分配）、解除死鎖：剝奪資源、撤銷進程
四、遞歸鎖
在Python中為了支持同一個線程中多次請求同一資源，Python提供了可重入鎖。這個RLock內部維護著一個Lock和一個counter變數，counter記錄了acquire的次數，從而使得資源可以被多次require。直到一個線程所有的acquire都被release，其他的線程才能獲得資源。遞歸鎖分為可遞歸鎖與非遞歸鎖。
五、樂觀鎖
假設不會發生並發沖突，只在提交操作時檢查是否違反數據完整性。
六、悲觀鎖
假定會發生並發沖突，屏蔽一切可能違反數據完整性的操作。
python常用的加鎖方式：互斥鎖、可重入鎖、迭代死鎖、互相調用死鎖、自旋鎖

㈡ python多線程怎樣同步

鎖機制
�6�9�6�9threading的Lock類，用該類的acquire函數進行加鎖，用realease函數進行解鎖

import threading
import time

class Num:
def __init__(self):
self.num = 0
self.lock = threading.Lock()
def add(self):
self.lock.acquire()#加鎖，鎖住相應的資源
self.num += 1
num = self.num
self.lock.release()#解鎖，離開該資源
return num

n = Num()
class jdThread(threading.Thread):
def __init__(self,item):
threading.Thread.__init__(self)
self.item = item
def run(self):
time.sleep(2)
value = n.add()#將num加1，並輸出原來的數據和+1之後的數據
print(self.item,value)

for item in range(5):
t = jdThread(item)
t.start()
t.join()#使線程一個一個執行
�6�9�6�9當一個線程調用鎖的acquire()方法獲得鎖時，鎖就進入「locked」狀態。每次只有一個線程可以獲得鎖。如果此時另一個線程試圖獲得這個鎖，該線程就會變為「blocked」狀態，稱為「同步阻塞」（參見多線程的基本概念）。
�6�9�6�9直到擁有鎖的線程調用鎖的release()方法釋放鎖之後，鎖進入「unlocked」狀態。線程調度程序從處於同步阻塞狀態的線程中選擇一個來獲得鎖，並使得該線程進入運行（running）狀態。

信號量
�6�9�6�9信號量也提供acquire方法和release方法，每當調用acquire方法的時候，如果內部計數器大於0，則將其減1，如果內部計數器等於0，則會阻塞該線程，知道有線程調用了release方法將內部計數器更新到大於1位置。

import threading
import time
class Num:
def __init__(self):
self.num = 0
self.sem = threading.Semaphore(value = 3)
#允許最多三個線程同時訪問資源

def add(self):
self.sem.acquire()#內部計數器減1
self.num += 1
num = self.num
self.sem.release()#內部計數器加1
return num

n = Num()
class jdThread(threading.Thread):
def __init__(self,item):
threading.Thread.__init__(self)
self.item = item
def run(self):
time.sleep(2)
value = n.add()
print(self.item,value)

for item in range(100):
t = jdThread(item)
t.start()
t.join()
條件判斷
�6�9�6�9所謂條件變數，即這種機制是在滿足了特定的條件後，線程才可以訪問相關的數據。
�6�9�6�9它使用Condition類來完成，由於它也可以像鎖機制那樣用，所以它也有acquire方法和release方法，而且它還有wait，notify，notifyAll方法。

"""
一個簡單的生產消費者模型，通過條件變數的控制產品數量的增減，調用一次生產者產品就是+1，調用一次消費者產品就會-1.
"""

"""
使用 Condition 類來完成，由於它也可以像鎖機制那樣用，所以它也有 acquire 方法和 release 方法，而且它還有
wait， notify， notifyAll 方法。
"""

import threading
import queue,time,random

class Goods:#產品類
def __init__(self):
self.count = 0
def add(self,num = 1):
self.count += num
def sub(self):
if self.count>=0:
self.count -= 1
def empty(self):
return self.count <= 0

class Procer(threading.Thread):#生產者類
def __init__(self,condition,goods,sleeptime = 1):#sleeptime=1
threading.Thread.__init__(self)
self.cond = condition
self.goods = goods
self.sleeptime = sleeptime
def run(self):
cond = self.cond
goods = self.goods
while True:
cond.acquire()#鎖住資源
goods.add()
print("產品數量:",goods.count,"生產者線程")
cond.notifyAll()#喚醒所有等待的線程--》其實就是喚醒消費者進程
cond.release()#解鎖資源
time.sleep(self.sleeptime)

class Consumer(threading.Thread):#消費者類
def __init__(self,condition,goods,sleeptime = 2):#sleeptime=2
threading.Thread.__init__(self)
self.cond = condition
self.goods = goods
self.sleeptime = sleeptime
def run(self):
cond = self.cond
goods = self.goods
while True:
time.sleep(self.sleeptime)
cond.acquire()#鎖住資源
while goods.empty():#如無產品則讓線程等待
cond.wait()
goods.sub()
print("產品數量:",goods.count,"消費者線程")
cond.release()#解鎖資源

g = Goods()
c = threading.Condition()

pro = Procer(c,g)
pro.start()

con = Consumer(c,g)
con.start()
同步隊列
�6�9�6�9put方法和task_done方法，queue有一個未完成任務數量num，put依次num+1，task依次num-1.任務都完成時任務結束。

import threading
import queue
import time
import random

'''
1.創建一個 Queue.Queue() 的實例，然後使用數據對它進行填充。
2.將經過填充數據的實例傳遞給線程類，後者是通過繼承 threading.Thread 的方式創建的。
3.每次從隊列中取出一個項目，並使用該線程中的數據和 run 方法以執行相應的工作。
4.在完成這項工作之後，使用 queue.task_done() 函數向任務已經完成的隊列發送一個信號。
5.對隊列執行 join 操作，實際上意味著等到隊列為空，再退出主程序。
'''

class jdThread(threading.Thread):
def __init__(self,index,queue):
threading.Thread.__init__(self)
self.index = index
self.queue = queue

def run(self):
while True:
time.sleep(1)
item = self.queue.get()
if item is None:
break
print("序號：",self.index,"任務",item,"完成")
self.queue.task_done()#task_done方法使得未完成的任務數量-1

q = queue.Queue(0)
'''
初始化函數接受一個數字來作為該隊列的容量，如果傳遞的是
一個小於等於0的數，那麼默認會認為該隊列的容量是無限的.
'''
for i in range(2):
jdThread(i,q).start()#兩個線程同時完成任務

for i in range(10):
q.put(i)#put方法使得未完成的任務數量+1

㈢ python多線程訪問資料庫，應該怎麼使用

連接對象可以是同一個，指針不能是同一個。
假設conn是你的連接對象
每個線程使用cur=conn.cursor()來獲得指針。
如果有鎖操作的話，有可能產生等待。這個是資料庫級別要處理的問題。看你具體業務吧，比如你需要原子操作，連續寫，中間不能斷的，那你得注意使用事務，或者自己在寫的時候鎖表。這些問題自己搭一個環境一測便知。

㈣求助，python的資料庫和多線程方面的問題

連接對象可以是同一個,指針不能是同一個。假設conn是你的連接對象每個線程使用cur=conn.cursor()來獲得指針。

㈤深入解析Python中的線程同步方法

深入解析Python中的線程同步方法
同步訪問共享資源
在使用線程的時候，一個很重要的問題是要避免多個線程對同一變數或其它資源的訪問沖突。一旦你稍不留神，重疊訪問、在多個線程中修改（共享資源）等這些操作會導致各種各樣的問題；更嚴重的是，這些問題一般只會在比較極端（比如高並發、生產伺服器、甚至在性能更好的硬體設備上）的情況下才會出現。
比如有這樣一個情況：需要追蹤對一事件處理的次數
counter = 0

def process_item(item):
global counter
... do something with item ...
counter += 1
如果你在多個線程中同時調用這個函數，你會發現counter的值不是那麼准確。在大多數情況下它是對的，但有時它會比實際的少幾個。
出現這種情況的原因是，計數增加操作實際上分三步執行:
解釋器獲取counter的當前值計算新值將計算的新值回寫counter變數
考慮一下這種情況：在當前線程獲取到counter值後，另一個線程搶佔到了CPU，然後同樣也獲取到了counter值，並進一步將counter值重新計算並完成回寫；之後時間片重新輪到當前線程（這里僅作標識區分，並非實際當前），此時當前線程獲取到counter值還是原來的，完成後續兩步操作後counter的值實際只加上1。
另一種常見情況是訪問不完整或不一致狀態。這類情況主要發生在一個線程正在初始化或更新數據時，另一個進程卻嘗試讀取正在更改的數據。
原子操作
實現對共享變數或其它資源的同步訪問最簡單的方法是依靠解釋器的原子操作。原子操作是在一步完成執行的操作，在這一步中其它線程無法獲得該共享資源。
通常情況下，這種同步方法只對那些只由單個核心數據類型組成的共享資源有效，譬如，字元串變數、數字、列表或者字典等。下面是幾個線程安全的操作：
讀或者替換一個實例屬性讀或者替換一個全局變數從列表中獲取一項元素原位修改一個列表（例如：使用append增加一個列表項）從字典中獲取一項元素原位修改一個字典（例如：增加一個字典項、調用clear方法）
注意，上面提到過，對一個變數或者屬性進行讀操作，然後修改它，最終將其回寫不是線程安全的。因為另外一個線程會在這個線程讀完卻沒有修改或回寫完成之前更改這個共享變數/屬性。
鎖
鎖是Python的threading模塊提供的最基本的同步機制。在任一時刻，一個鎖對象可能被一個線程獲取，或者不被任何線程獲取。如果一個線程嘗試去獲取一個已經被另一個線程獲取到的鎖對象，那麼這個想要獲取鎖對象的線程只能暫時終止執行直到鎖對象被另一個線程釋放掉。
鎖通常被用來實現對共享資源的同步訪問。為每一個共享資源創建一個Lock對象，當你需要訪問該資源時，調用acquire方法來獲取鎖對象（如果其它線程已經獲得了該鎖，則當前線程需等待其被釋放），待資源訪問完後，再調用release方法釋放鎖：
lock = Lock()

lock.acquire() #: will block if lock is already held
... access shared resource
lock.release()

注意，即使在訪問共享資源的過程中出錯了也應該釋放鎖，可以用try-finally來達到這一目的：
lock.acquire()
try:
... access shared resource
finally:
lock.release() #: release lock, no matter what

在Python 2.5及以後的版本中，你可以使用with語句。在使用鎖的時候，with語句會在進入語句塊之前自動的獲取到該鎖對象，然後在語句塊執行完成後自動釋放掉鎖：
from __future__ import with_statement #: 2.5 only

with lock:
... access shared resource

acquire方法帶一個可選的等待標識，它可用於設定當有其它線程佔有鎖時是否阻塞。如果你將其值設為False，那麼acquire方法將不再阻塞，只是如果該鎖被佔有時它會返回False:
if not lock.acquire(False):
... 鎖資源失敗
else:
try:
... access shared resource
finally:
lock.release()

你可以使用locked方法來檢查一個鎖對象是否已被獲取，注意不能用該方法來判斷調用acquire方法時是否會阻塞，因為在locked方法調用完成到下一條語句（比如acquire）執行之間該鎖有可能被其它線程佔有。
if not lock.locked():
#: 其它線程可能在下一條語句執行之前佔有了該鎖
lock.acquire() #: 可能會阻塞

簡單鎖的缺點
標準的鎖對象並不關心當前是哪個線程佔有了該鎖；如果該鎖已經被佔有了，那麼任何其它嘗試獲取該鎖的線程都會被阻塞，即使是佔有鎖的這個線程。考慮一下下面這個例子：
lock = threading.Lock()

def get_first_part():
lock.acquire()
try:
... 從共享對象中獲取第一部分數據
finally:
lock.release()
return data

def get_second_part():
lock.acquire()
try:
... 從共享對象中獲取第二部分數據
finally:
lock.release()
return data

示例中，我們有一個共享資源，有兩個分別取這個共享資源第一部分和第二部分的函數。兩個訪問函數都使用了鎖來確保在獲取數據時沒有其它線程修改對應的共享數據。
現在，如果我們想添加第三個函數來獲取兩個部分的數據，我們將會陷入泥潭。一個簡單的方法是依次調用這兩個函數，然後返回結合的結果：

def get_both_parts():
first = get_first_part()
seconde = get_second_part()
return first, second

這里的問題是，如有某個線程在兩個函數調用之間修改了共享資源，那麼我們最終會得到不一致的數據。最明顯的解決方法是在這個函數中也使用lock:
def get_both_parts():
lock.acquire()
try:
first = get_first_part()
seconde = get_second_part()
finally:
lock.release()
return first, second

然而，這是不可行的。裡面的兩個訪問函數將會阻塞，因為外層語句已經佔有了該鎖。為了解決這個問題，你可以通過使用標記在訪問函數中讓外層語句釋放鎖，但這樣容易失去控制並導致出錯。幸運的是，threading模塊包含了一個更加實用的鎖實現：re-entrant鎖。
Re-Entrant Locks (RLock)

RLock類是簡單鎖的另一個版本，它的特點在於，同一個鎖對象只有在被其它的線程佔有時嘗試獲取才會發生阻塞；而簡單鎖在同一個線程中同時只能被佔有一次。如果當前線程已經佔有了某個RLock鎖對象，那麼當前線程仍能再次獲取到該RLock鎖對象。
lock = threading.Lock()
lock.acquire()
lock.acquire() #: 這里將會阻塞

lock = threading.RLock()
lock.acquire()
lock.acquire() #: 這里不會發生阻塞

RLock的主要作用是解決嵌套訪問共享資源的問題，就像前面描述的示例。要想解決前面示例中的問題，我們只需要將Lock換為RLock對象，這樣嵌套調用也會OK.
lock = threading.RLock()

def get_first_part():
... see above

def get_second_part():
... see above

def get_both_parts():
... see above

這樣既可以單獨訪問兩部分數據也可以一次訪問兩部分數據而不會被鎖阻塞或者獲得不一致的數據。
注意RLock會追蹤遞歸層級，因此記得在acquire後進行release操作。
Semaphores

信號量是一個更高級的鎖機制。信號量內部有一個計數器而不像鎖對象內部有鎖標識，而且只有當佔用信號量的線程數超過信號量時線程才阻塞。這允許了多個線程可以同時訪問相同的代碼區。
semaphore = threading.BoundedSemaphore()
semaphore.acquire() #: counter減小

... 訪問共享資源
semaphore.release() #: counter增大

當信號量被獲取的時候，計數器減小；當信號量被釋放的時候，計數器增大。當獲取信號量的時候，如果計數器值為0，則該進程將阻塞。當某一信號量被釋放，counter值增加為1時，被阻塞的線程（如果有的話）中會有一個得以繼續運行。
信號量通常被用來限制對容量有限的資源的訪問，比如一個網路連接或者資料庫伺服器。在這類場景中，只需要將計數器初始化為最大值，信號量的實現將為你完成剩下的事情。
max_connections = 10

semaphore = threading.BoundedSemaphore(max_connections)

如果你不傳任何初始化參數，計數器的值會被初始化為1.
Python的threading模塊提供了兩種信號量實現。Semaphore類提供了一個無限大小的信號量，你可以調用release任意次來增大計數器的值。為了避免錯誤出現，最好使用BoundedSemaphore類，這樣當你調用release的次數大於acquire次數時程序會出錯提醒。
線程同步

鎖可以用在線程間的同步上。threading模塊包含了一些用於線程間同步的類。
Events

一個事件是一個簡單的同步對象，事件表示為一個內部標識(internal flag)，線程等待這個標識被其它線程設定，或者自己設定、清除這個標識。
event = threading.Event()

#: 一個客戶端線程等待flag被設定
event.wait()

#: 服務端線程設置或者清除flag
event.set()
event.clear()

一旦標識被設定，wait方法就不做任何處理（不會阻塞），當標識被清除時，wait將被阻塞直至其被重新設定。任意數量的線程可能會等待同一個事件。
Conditions

條件是事件對象的高級版本。條件表現為程序中的某種狀態改變，線程可以等待給定條件或者條件發生的信號。
下面是一個簡單的生產者/消費者實例。首先你需要創建一個條件對象：

#: 表示一個資源的附屬項
condition = threading.Condition()
生產者線程在通知消費者線程有新生成資源之前需要獲得條件：
#: 生產者線程
... 生產資源項
condition.acquire()
... 將資源項添加到資源中
condition.notify() #: 發出有可用資源的信號
condition.release()
消費者必須獲取條件（以及相關聯的鎖），然後嘗試從資源中獲取資源項：
#: 消費者線程
condition.acquire()
while True:
...從資源中獲取資源項
if item:
break
condition.wait() #: 休眠，直至有新的資源
condition.release()
... 處理資源

wait方法釋放了鎖，然後將當前線程阻塞，直到有其它線程調用了同一條件對象的notify或者notifyAll方法，然後又重新拿到鎖。如果同時有多個線程在等待，那麼notify方法只會喚醒其中的一個線程，而notifyAll則會喚醒全部線程。
為了避免在wait方法處阻塞，你可以傳入一個超時參數，一個以秒為單位的浮點數。如果設置了超時參數，wait將會在指定時間返回，即使notify沒被調用。一旦使用了超時，你必須檢查資源來確定發生了什麼。
注意，條件對象關聯著一個鎖，你必須在訪問條件之前獲取這個鎖；同樣的，你必須在完成對條件的訪問時釋放這個鎖。在生產代碼中，你應該使用try-finally或者with.
可以通過將鎖對象作為條件構造函數的參數來讓條件關聯一個已經存在的鎖，這可以實現多個條件公用一個資源：
lock = threading.RLock()
condition_1 = threading.Condition(lock)
condition_2 = threading.Condition(lock)

互斥鎖同步
我們先來看一個例子：
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import time, threading

# 假定這是你的銀行存款:
balance = 0
muxlock = threading.Lock()

def change_it(n):
# 先存後取，結果應該為0:
global balance
balance = balance + n
balance = balance - n

def run_thread(n):
# 循環次數一旦多起來，最後的數字就變成非0
for i in range(100000):
change_it(n)

t1 = threading.Thread(target=run_thread, args=(5,))
t2 = threading.Thread(target=run_thread, args=(8,))
t3 = threading.Thread(target=run_thread, args=(9,))
t1.start()
t2.start()
t3.start()
t1.join()
t2.join()
t3.join()
print balance

結果 :

[/data/web/test_python]$ python multhread_threading.py
0
[/data/web/test_python]$ python multhread_threading.py
61
[/data/web/test_python]$ python multhread_threading.py
0
[/data/web/test_python]$ python multhread_threading.py
24

上面的例子引出了多線程編程的最常見問題：數據共享。當多個線程都修改某一個共享數據的時候，需要進行同步控制。
線程同步能夠保證多個線程安全訪問競爭資源，最簡單的同步機制是引入互斥鎖。互斥鎖為資源引入一個狀態：鎖定/非鎖定。某個線程要更改共享數據時，先將其鎖定，此時資源的狀態為「鎖定」，其他線程不能更改；直到該線程釋放資源，將資源的狀態變成「非鎖定」，其他的線程才能再次鎖定該資源。互斥鎖保證了每次只有一個線程進行寫入操作，從而保證了多線程情況下數據的正確性。

threading模塊中定義了Lock類，可以方便的處理鎖定：
#創建鎖mutex = threading.Lock()
#鎖定mutex.acquire([timeout])
#釋放mutex.release()

其中，鎖定方法acquire可以有一個超時時間的可選參數timeout。如果設定了timeout，則在超時後通過返回值可以判斷是否得到了鎖，從而可以進行一些其他的處理。
使用互斥鎖實現上面的例子的代碼如下：
balance = 0
muxlock = threading.Lock()

def change_it(n):
# 獲取鎖，確保只有一個線程操作這個數
muxlock.acquire()
global balance
balance = balance + n
balance = balance - n
# 釋放鎖，給其他被阻塞的線程繼續操作
muxlock.release()

def run_thread(n):
for i in range(10000):
change_it(n)

加鎖後的結果，就能確保數據正確：
[/data/web/test_python]$ python multhread_threading.py
0
[/data/web/test_python]$ python multhread_threading.py
0
[/data/web/test_python]$ python multhread_threading.py
0
[/data/web/test_python]$ python multhread_threading.py
0

㈥ python多線程程序，為什麼數據處理結果不正確

如果你的代碼是CPU密集型，多個線程的代碼很有可能是線性執行的。所以這種情況下多線程是雞肋，效率可能還不如單線程因為有context switch 但是：如果你的代碼是IO密集型，多線程可以明顯提高效率。例如製作爬蟲

㈦一文帶你讀懂Python線程

Python線程

進程有很多優點，它提供了多道編程，可以提高計算機CPU的利用率。既然進程這么優秀，為什麼還要線程呢？其實，仔細觀察就會發現進程還是有很多缺陷的。

主要體現在一下幾個方面：

進程只能在一個時間做一個任務，如果想同時做兩個任務或多個任務，就必須開啟多個進程去完成多個任務。

進程在執行的過程中如果阻塞，例如等待輸入，整個進程就會掛起，即使進程中有些工作不依賴於輸入的數據，也將無法執行。

每個進程都有自己的獨立空間，所以多進程的創建，銷毀相比於多線程更加耗時，也更加佔用系統資源。

進程是資源分配的最小單位，線程是CPU調度的最小單位，每一個進程中至少有一個線程。

線程與進程的區別

可以歸納為以下4點：

1）地址空間：進程間相互獨立的每個進程都有自己獨立的內存空間，也就是說一個進程內的數據在另一個進程是不可見的。但同一進程中的各線程間數據是共享的。

2）通信：由於每個進程有自己獨立的內存空間，所以進程間通信需要IPC，而進程內的數據對於多個線程來說是共享的，每個線程都可以訪問，所以為了保證數據的一致性，需要使用鎖。

3）調度和切換：線程上下文切換比進程上下文切換要快得多。

4）在多線程操作系統中，進程不是一個可執行的實體，它主要的功能是向操作系統申請一塊內存空間，然後在內存空間中開線程來執行任務，相當於一個容器，容器中的線程才是真正的執行體。一個進程可以包含多個線程，而一個線程是不能包含進程的。因為進程是系統分配資源的最小單位，所以線程不能向操作系統申請自己的空間，但一個線程內可以包含多個線程。

導航:首頁 > 編程語言 > python線程中的數據

python線程中的數據

與python線程中的數據相關的資料