python基础之并发编程(一)

以下是“python基础之并发编程(一)”的完整攻略：

什么是并发编程

并发指的是程序的多个部分可以同时执行的能力。在计算机领域中，指的是通过多个线程或进程实现并行计算和任务处理。

并发编程是指在同一时间段内处理多个计算任务的编程方式，它涉及到多个线程或进程之间的协调和通信。在Python中，使用多线程和多进程都能实现并发编程。

Python中的多线程并发编程

Python中，使用threading模块可以方便地创建和管理线程。使用多线程可以提高程序的效率，特别是在需要同时进行多个任务或操作时。

创建线程的方式

1. 创建线程对象，并调用线程对象的start()方法

```python
import threading

def func1():
print('线程1执行')

def func2():
print('线程2执行')

threads = []
t1 = threading.Thread(target=func1)
t2 = threading.Thread(target=func2)
threads.append(t1)
threads.append(t2)

for t in threads:
t.start()

```

1. 通过继承Thread类，重写run()方法

```python
import threading

class myThread(threading.Thread):
def init(self, threadID, name):
threading.Thread.init(self)
self.threadID = threadID
self.name = name
def run(self):
print("开始线程：" + self.name)

thread1 = myThread(1, "Thread-1")
thread2 = myThread(2, "Thread-2")

thread1.start()
thread2.start()
```

线程的同步与互斥

多个线程共同修改同一个资源时，为避免数据混乱和冲突，需要使用线程同步和互斥操作来协调资源的访问和修改。

1. 线程同步操作：多个线程执行时，有些线程需要等待其他线程执行完成后才能继续执行。这种情况下，通常使用threading模块提供的锁（Lock或RLock）和条件变量（Condition）机制进行同步操作。

```python
import threading

class SharedCounter:
def init(self, initial_value = 0):
self.value = initial_value
self.lock = threading.Lock()
def incr(self):
with self.lock:
self.value += 1
return self.value

total = SharedCounter()

def add():
for i in range(10):
total.incr()
print(total.value)

threads = []

for i in range(10):
t = threading.Thread(target=add)
t.start()
threads.append(t)

for t in threads:
t.join()
```

1. 线程互斥操作：多个线程不允许同时访问同一资源，即在某个线程使用该资源时，其他线程不能再次访问该资源。可以使用锁机制（Lock或RLock）进行互斥操作。

```python
import threading

class Phone():
def init(self):
self.lock = threading.Lock()
def pick_up(self):
self.lock.acquire()
print("{} pick up the phone".format(threading.current_thread().name))
self.lock.release()

phone = Phone()

def caller():
for i in range(3):
with phone.lock:
print("{} make a calling".format(threading.current_thread().name))
phone.pick_up()

threads = []

for i in range(2):
t = threading.Thread(target=caller)
t.start()
threads.append(t)

for t in threads:
t.join()
```

Python中的多进程并发编程

Python中，使用multiprocessing模块可以方便地创建和管理进程。使用多进程可以充分利用多核CPU，加快程序的运行效率。

创建进程的方式

1. 创建进程对象，并调用进程对象的start()方法

```python
import multiprocessing

def worker():
print('我的进程ID是：{}'.format(multiprocessing.current_process().name))

processes = []

for i in range(5):
p = multiprocessing.Process(target=worker)
processes.append(p)
p.start()

for p in processes:
p.join()
```

1. 通过继承Process类，重写run()方法

```python
import multiprocessing

class myProcess(multiprocessing.Process):
def init(self, name):
multiprocessing.Process.init(self)
self.name = name
def run(self):
print('我的进程ID是：{}'.format(self.name))

processes = []

for i in range(5):
p = myProcess(i)
processes.append(p)
p.start()

for p in processes:
p.join()
```

进程的同步与互斥

多个进程共同修改同一个资源时，为避免数据混乱和冲突，需要使用进程同步和互斥操作来协调资源的访问和修改。与线程不同的是，进程间通常使用multiprocessing模块提供的管道（Pipe）和队列（Queue）机制来进行进程间通信。

1. 进程同步：多个进程执行时，有些进程需要等待其他进程执行完成后才能继续执行。这种情况下，可以使用进程同步机制，如使用Lock实现进程同步。

```python
import multiprocessing

def add(local_lock, shared_var):
for i in range(10):
local_lock.acquire()
shared_var.value += 1
local_lock.release()

local_lock = multiprocessing.Lock()
shared_var = multiprocessing.Value('i', 0)

processes = []

for i in range(10):
p = multiprocessing.Process(target=add, args=(local_lock, shared_var))
processes.append(p)
p.start()

for p in processes:
p.join()

print('Result:', shared_var.value)
```

1. 进程互斥：多个进程不允许同时访问同一资源，即在某个进程使用该资源时，其他进程不能再次访问该资源。这种情况下，通常使用锁机制（Lock或RLock）进行互斥操作。

```python
import multiprocessing

def print_num(lock, num):
lock.acquire()
print(num)
lock.release()

lock = multiprocessing.Lock()

processes = []

for i in range(5):
p = multiprocessing.Process(target=print_num, args=(lock, i))
processes.append(p)
p.start()

for p in processes:
p.join()
```

以上就是Python基础之并发编程的完整攻略。其中，代码示例1演示了线程同步操作，实现了共享计数器。代码示例2演示了线程互斥操作，模拟了电话拨打过程，确保同时只能有一个线程拨打。代码示例3演示了进程同步操作，实现了共享变量累加器。代码示例4演示了进程互斥操作，使用了进程锁确保同一时间只能有一个进程访问被锁定的资源。