python如何避免死锁_Python多线程及死锁预防

线程(英语：thread)是操作系统能够进行运算调度的最小单位。

并发：指的是任务数比cpu核数多的时候，通过内核调度，实现用多个任务“一起”执行。

并行：指的是任务数小于等于cpu核数，即任务真的是一起执行的。

同步： 就是协同步调，按预定的先后次序进行运行。

互斥锁： 解决线程之间资源竞争不安全问题。

死锁： 多个线程获取多个锁，造成A需要B持有的锁，B需要A持有的锁。

防止死锁: 程序设计时要尽量避免, 添加超时时间,为程序中的每一个锁分配一个唯一的id。

同步源语：

当一个进程调用一个send原语时，在消息开始发送后，发送进程便处于阻塞状态，直至消息完全发送完毕，send原语的后继语句才能继续执行。当一个进程调用一个receive原语时，并不立即返回控制，而是等到把消息实际接收下来，并把它放入指定的接收区，才返回控制，继续执行该原语的后继指令。在这段时间它一直处于阻塞状态。上述的send和receive被称为同步通信原语或阻塞通信原语。

python多线程之间共享数据

全局变量

传递参数

使用queue

创建基本的线程

# Code to execute in an independent thread

import time

def countdown(n):

while n > 0:

print('T-minus', n)

n -= 1

time.sleep(5)

# Create and launch a thread

from threading import Thread

t = Thread(target=countdown, args=(10,))

t.start()

默认，主线程会等待子线程执行完之后执行。

Queue 线程之间通信

from queue import Queue

from threading import Thread

# A thread that produces data

def producer(out_q):

while True:

# Produce some data

...

out_q.put(data)

# A thread that consumes data

def consumer(in_q):

while True:

# Get some data

data = in_q.get()

# Process the data

...

# Create the shared queue and launch both threads

q = Queue()

t1 = Thread(target=consumer, args=(q,))

t2 = Thread(target=producer, args=(q,))

t1.start()

t2.start()

Queue 对象已经包含了必要的锁。

给原子性操作加锁

import threading

class SharedCounter:

'''

A counter object that can be shared by multiple threads.

'''

def __init__(self, initial_value = 0):

self._value = initial_value

self._value_lock = threading.Lock()

def incr(self,delta=1):

'''

Increment the counter with locking

'''

with self._value_lock:

self._value += delta

def decr(self,delta=1):

'''

Decrement the counter with locking

'''

with self._value_lock:

self._value -= delta

使用threading.Lock()可以得到一个互斥锁。

# 创建锁

mutex = threading.Lock()

# 锁定

mutex.acquire()

# 释放

mutex.release()

一个线程获取多个锁如何避免死锁

将获取锁的顺序规定，如，id(lock)从小到大排序。

import threading

from contextlib import contextmanager

import time

# Thread-local state to stored information on locks already acquired

_local = threading.local()

@contextmanager

def acquire(flag, *locks):

print(flag, 'start......................')

# Sort locks by object identifier

locks = sorted(locks, key=lambda x: id(x))

# Make sure lock order of previously acquired locks is not violated

acquired = getattr(_local, 'acquired', [])

if acquired and max(id(lock) for lock in acquired) >= id(locks[0]):

raise RuntimeError('Lock Order Violation')

# Acquire all of the locks

acquired.extend(locks)

print(flag, 'acquired:', acquired)

_local.acquired = acquired

try:

for lock in locks:

print(flag, 'start lock acquired for:', lock)

lock.acquire()

print(flag, 'end lock acquired for:', lock)

print(flag, 'end......................')

yield

finally:

# Release locks in reverse order of acquisition

for lock in reversed(locks):

lock.release()

del acquired[-len(locks):]

import threading

x_lock = threading.Lock()

y_lock = threading.Lock()

g_num = 0

def thread_1():

cur_tim = time.time()

FLAG = True

global g_num

while FLAG:

if time.time() - cur_tim > 1:

FLAG = False

with acquire('thread1', y_lock, x_lock):

print('Thread-1')

g_num += 1

def thread_2():

cur_tim = time.time()

FLAG = True

global g_num

while FLAG:

if time.time() - cur_tim > 1:

FLAG = False

with acquire('thread2',y_lock, x_lock):

print('Thread-2')

g_num += 1

t1 = threading.Thread(target=thread_1)

t1.start()

t2 = threading.Thread(target=thread_2)

t2.start()

time.sleep(2)