◆ 进程:
An executing instance of a program is called a process.
Each process provides the resources needed to execute a program. A process has a virtual address space, executable code, open handles to system objects, a security context, a unique process identifier, environment variables, a priority class, minimum and maximum working set sizes, and at least one thread of execution. Each process is started with a single thread, often called the primary thread, but can create additional threads from any of its threads.
程序并不能单独运行,只有将程序装载到内存中,系统为它分配资源才能运行,而这种执行的程序就称之为进程。程序和进程的区别就在于:程序是指令的集合,它是进程运行的静态描述文本;进程是程序的一次执行活动,属于动态概念。
在多道编程中,我们允许多个程序同时加载到内存中,在操作系统的调度下,可以实现并发地执行。这是这样的设计,大大提高了CPU的利用率。进程的出现让每个用户感觉到自己独享CPU,因此,进程就是为了在CPU上实现多道编程而提出的。
多道程序设计:
在计算机内存中同时存放几道相互独立的程序,使它们在管理程序控制之下,相互穿插的运行。 两个或两个以上程序在计算机系统中同处于开始到结束之间的状态。这就称为多道程序设计。多道程序技术运行的特征:多道、宏观上并行、微观上串行。
★ 进程的缺陷:
进程有很多缺陷,主要体现在两点上:
• 进程只能在一个时间干一件事,如果想同时干两件事或多件事,进程就无能为力了。
• 进程在执行的过程中如果阻塞,例如等待输入,整个进程就会挂起,即使进程中有些工作不依赖于输入的数据,也将无法执行。
例如,我们在使用qq聊天, qq做为一个独立进程如果同一时间只能干一件事,那他如何实现在同一时刻 即能监听键盘输入、又能监听其它人给你发的消息、同时还能把别人发的消息显示在屏幕上呢?
这就需要线程来解决。
◆ 线程:
操作系统能够进行运算调度的最小单位。它被包含在进程之中,是进程中的实际运作单位。一条线程指的是进程中一个单一顺序的控制流,一个进程中可以并发多个线程,每条线程并行执行不同的任务。
原理:CPU给你一种幻觉,它在同时做多个计算操作(执行多个线程)。实际上,CPU记录了每个线程的执行上下文,然后在多个线程中进行快速切换。
A thread is an execution context, which is all the information a CPU needs to execute a stream of instructions., while a process is a bunch of resources associated with a computation.
A process can have one or many threads.
◆ 进程与线程的区别:
1、同一进程中的不同线程,可以共享进程的地址空间;不同的进程间独占自己的地址空间
2、同一进程中的不同线程,可以直接获得进程的数据;进程只能从父进程中复制一份数据给自己使用。
3、同一进程中的不同线程,可以直接和其他线程交互;进程只能通过进程内通讯和其他进程交互。
4、新的线程很容易被创建;新进程的创建需要复制父进程。
5、同一进程中的不同线程,可以实现相互控制;进程只能控制其子进程。
6、主线程的变化可以改变其他线程的运行;父进程的改变不会影响子进程。
◆ Python GIL(Global Interpreter Lock):
In CPython, the global interpreter lock, or GIL, is a mutex that prevents multiple native threads from executing Python bytecodes at once. This lock is necessary mainly because CPython’s memory management is not thread-safe. (However, since the GIL exists, other features have grown to depend on the guarantees that it enforces.)
上面的核心意思就是,无论你启多少个线程,你有多少个cpu, Python在执行的时候会淡定的在同一时刻只允许一个线程运行。
这篇文章透彻的剖析了GIL对python多线程的影响,强烈推荐看一下:http://www.dabeaz.com/python/UnderstandingGIL.pdf
◆ 线程调用的两种方式:
★ 直接调用,将要执行的方法作为参数传给Thread的构造方法
def action(arg):
time.sleep(1)
print 'the arg is:%s\r' %arg
for i in xrange(4):
t =threading.Thread(target=action,args=(i,))
t.start()
print 'main thread end!'
★ 继承式调用,从Thread继承,并重写run()
# coding:utf-8
import threading
import time
class MyThread(threading.Thread):
def __init__(self,arg):
super(MyThread, self).__init__()#注意:一定要显式的调用父类的初始化函数。
self.arg=arg
def run(self):#定义每个线程要运行的函数
time.sleep(1)
print 'the arg is:%s\r' % self.arg
for i in xrange(4):
t =MyThread(i)
t.start()
print 'main thread end!'
◆ 构造方法:
Thread(group=None, target=None, name=None, args=(), kwargs={})
group: 线程组,目前还没有实现,库引用中提示必须是None;
target: 要执行的方法;
name: 线程名;
args/kwargs: 要传入方法的参数。
◆ 实例方法:
★ isAlive(): 返回线程是否在运行。正在运行指启动后、终止前。
★ get/setName(name): 获取/设置线程名。
★ is/setDaemon(bool): 获取/设置是后台线程(默认前台线程(False))。(在start之前设置)
如果是后台线程,主线程执行过程中,后台线程也在进行,主线程执行完毕后,后台线程不论成功与否,主线程和后台线程均停止
如果是前台线程,主线程执行过程中,前台线程也在进行,主线程执行完毕后,等待前台线程也执行完成后,程序停止
★ start(): 启动线程。
★ join([timeout]): 阻塞当前上下文环境的线程,直到调用此方法的线程终止或到达指定的timeout(可选参数)。
◆ is/setDaemon(bool):
serDeamon(True)后台线程,主线程执行过程中,后台线程也在进行,主线程执行完毕后,后台线程不论成功与否,均停止。
示例:
# coding:utf-8
import threading
import time
def action(arg):
time.sleep(1)
print 'sub thread start!the thread name is:%s\r' % threading.currentThread().getName()
print 'the arg is:%s\r' %arg
for i in xrange(4):
t =threading.Thread(target=action,args=(i,))
t.setDaemon(True)#设置线程为后台线程
t.start()
print 'main_thread end!'
执行结果:
main_thread end!
◆ join()
阻塞当前上下文环境的线程,直到调用此方法的线程终止或到达指定的timeout,即使设置了setDeamon(True)主线程依然要等待子线程结束。
#coding:utf-8
import threading
import time
def action(arg):
time.sleep(arg)
print 'the sub thread name is:%s ' % threading.currentThread().getName()
print 'the sleep time is:%ss ' %arg
thread_list = [] #线程存放列表
for i in xrange(2):
t =threading.Thread(target=action,args=(i,))
t.setDaemon(True)
thread_list.append(t)
for t in thread_list:
t.start()
for t in thread_list:
t.join()
print 'main_thread end!'
执行结果:
the sub thread name is:Thread-1
the sleep time is:0s
the sub thread name is:Thread-2
the sleep time is:1s
main_thread end!
join不妥当的用法,使多线程编程顺序执行:
#coding:utf-8
import threading
import time
def action(arg):
time.sleep(1)
print 'sub thread start!the thread name is:%s ' % threading.currentThread().getName()
print 'the arg is:%s ' %arg
for i in xrange(2):
t =threading.Thread(target=action,args=(i,))
t.setDaemon(True)
t.start()
t.join()
print 'main_thread end!'
运行结果:
sub thread start!the thread name is:Thread-1
the arg is:0
sub thread start!the thread name is:Thread-2
the arg is:1
注:共运行了2秒才结束!!每个线程都被上一个线程的join阻塞,使得“多线程”失去了多线程意义。
◆ 线程的锁
由于线程之间随机调度:某线程可能在执行n条后,CPU接着执行其他线程。为了多个线程同时操作一个内存中的资源时不产生混乱,我们使用锁。
Lock(指令锁)是可用的最低级的同步指令。Lock处于锁定状态时,不被特定的线程拥有。Lock包含两种状态——锁定和非锁定,以及两个基本的方法。
可以认为Lock有一个锁定池,当线程请求锁定时,将线程至于池中,直到获得锁定后出池。池中的线程处于状态图中的同步阻塞状态。
RLock(可重入锁)是一个可以被同一个线程请求多次的同步指令。RLock使用了“拥有的线程”和“递归等级”的概念,处于锁定状态时,RLock被某个线程拥有。拥有RLock的线程可以再次调用acquire(),释放锁时需要调用release()相同次数。
可以认为RLock包含一个锁定池和一个初始值为0的计数器,每次成功调用 acquire()/release(),计数器将+1/-1,为0时锁处于未锁定状态。
简言之:Lock属于全局,Rlock属于线程。
构造方法:
Lock()
Rlock()
注:推荐使用Rlock()
实例方法:
★ acquire([timeout]): 尝试获得锁定。使线程进入同步阻塞状态。
★ release(): 释放锁。使用前线程必须已获得锁定,否则将抛出异常。
★ 使用示例:
# coding:utf-8
import threading
import time
gl_num = 0
lock = threading.RLock()
# 调用acquire([timeout])时,线程将一直阻塞,
# 直到获得锁定或者直到timeout秒后(timeout参数可选)。
# 返回是否获得锁。
def Func():
lock.acquire()
global gl_num
gl_num += 1
time.sleep(1)
print gl_num
lock.release()
for i in range(4):
t = threading.Thread(target=Func)
t.start()
运行结果:
1
2
3
4
全局变量在在每次被调用时都要获得锁,才能操作,因此保证了共享数据的安全性
◆ Lock对比Rlock
★ Lock
#coding:utf-8
import threading
lock = threading.Lock() #Lock对象
lock.acquire()
lock.acquire() #产生了死锁。
lock.release()
lock.release()
print lock.acquire()
★ Rlock(递归锁)
# coding:utf-8
import threading
rLock = threading.RLock() #RLock对象
rLock.acquire()
rLock.acquire() #在同一线程内,程序不会堵塞。
rLock.release()
rLock.release()
◆Semaphore(信号量)
互斥锁同时只允许一个线程更改数据,而Semaphore是同时允许一定数量的线程进行操作。
示例:
# coding:utf-8
import threading, time
def run(n):
semaphore.acquire()
time.sleep(1)
print("run the thread: %s\n" % n)
semaphore.release()
if __name__ == '__main__':
semaphore = threading.BoundedSemaphore(2) # 最多允许2个线程同时运行
for i in range(6):
t = threading.Thread(target=run, args=(i,))
t.start()
while threading.active_count() != 1:
pass # print threading.active_count()
else:
print('----all threads done---')
执行结果:
run the thread: 0
run the thread: 1
run the thread: 3
run the thread: 2
run the thread: 5
run the thread: 4
----all threads done---