[python] 线程

来源：田飞雨 

链接：http://www.jianshu.com/p/12cd213a93bf

 

虽然python中由于GIL的机制致使多线程不能利用机器多核的特性，但是多线程对于我们理解并发模型以及底层操作非常有用。

 

线程的有两种使用方法，一种是在函数使用，一种是放在类中使用。

 

1，在函数中使用多线程

 

语法如下:

 

thread.start_new_thread(function, args[, kwargs] )

 

参数说明:

 

function - 线程函数。

args - 传递给线程函数的参数,必须是个tuple类型。

kwargs - 可选参数。

 

下面是一个例子：

 

def run(num):

    print 'hi , i am a thread.', num

 

def main():

    threads = []

    for i in range(5):

        t = threading.Thread(target=run, args=(i,))

        threads.append(t)

        t.start()

    for t in threads:

        t.join()

if __name__ == '__main__':

    print 'start -->'

    main()

    print 'go here -->'

 

运行结果：

 

start -->

hi , i am a thread. 0

hi , i am a thread. 1

hi , i am a thread. 2

hi , i am a thread. 3

hi , i am a thread. 4

go here -->

 

2，在类中多使用线程

 

下面是在类中使用线程的示例：

 

class MyThread(threading.Thread):

    def __init__(self,num):

        self.num = num

        super(MyThread, self).__init__()

    def run(self):

        print 'i am a thread,',self.num

        time.sleep(1)

 

def main():

    threads = []

    for i in range(5):

        t = MyThread(i)

        threads.append(t)

        t.start()

    for t in threads:

        t.join()

 

if __name__ == '__main__':

    print 'start -->'

    main()

    print 'go here -->

 

• run()，需要重写，编写代码实现所需要的功能。

• getName()，获得线程对象名称

• setName()，设置线程对象名称

• start()，启动线程

• join([timeout])，等待另一线程结束后再运行。

• setDaemon(bool)，设置子线程是否随主线程一起结束，必须在start() 之前调用，默认为False。

• isDaemon()，判断线程是否随主线程一起结束。

• isAlive()，检查线程是否在运行中。

 

join方法的作用是阻塞主进程（无法执行join以后的语句），主线程等待这个线程结束后，才可以执行下一条指令。多线程多join的情况下，依次执行各线程的join方法，前头一个结束了才能执行后面一个。无参数，则等待到该线程结束，才开始执行下一个线程的join。设置参数后，则等待该线程这么长时间就不管它了（而该线程并没有结束）。不管的意思就是可以执行后面的主进程了。

 

3，线程同步与互斥锁

 

线程之所以比进程轻量，其中一个原因就是他们共享内存。也就是各个线程可以平等的访问内存的数据，如果在短时间“同时并行”读取修改内存的数据，很可能造成数据不同步。例如下面的例子：

 

var = 0

class IncreThread(Thread):

    def run(self):

        global var

        print 'before,var is ',var

        var += 1

        print 'after,var is ',var

 

def use_incre_thread():

    threads = []

    for i in range(50):

        t = IncreThread()

        threads.append(t)

        t.start()

    for t in threads:

        t.join()

    print 'After 10 times,var is ',var

 

if __name__ == '__main__':

    use_incre_thread()

 

有一个全局变量var，五十个线程，每个线程对var变量进行加 1 运算，但是当你多运行几次后，发现并不是每次的运行结果都是 50，为什么呢？

 

在var是 10 的时候，线程t1读取了var，这个时刻cpu将控制权给了另一个线程t2。t2线程读到的var也是 10，t1和t2都把var加到 11，当时我们期望的是t1 t2两个线程使var + 2 变成 12。在这里就有了资源竞争，相同的情况也可能发生在其它的线程间，所以出现了最后的结果小于 50 的情况。

 

为了避免线程不同步造成数据不同步，可以对资源进行加锁。也就是访问资源的线程需要获得锁，才能访问。threading 模块提供了一个 Lock 功能，修改代码如下：

 

var = 0

lock = Lock()  #创建锁

class IncreThread(Thread):

    def run(self):

        global var

        lock.acquire()  #获取锁

        print 'before,var is ',var

        var += 1

        print 'after,var is ',var

        lock.release()  #释放锁

 

def use_incre_thread():

    threads = []

    for i in range(50):

        t = IncreThread()

        threads.append(t)

        t.start()

    for t in threads:

        t.join()

    print 'After 10 times,var is ',var

 

if __name__ == '__main__':

    use_incre_thread()

 

虽然线程可以共享内存，但是一个线程不能影响其他线程内的变量（非全局变量）。

 

4，死锁

 

在线程间共享多个资源的时候，如果两个线程分别占有一部分资源并且同时等待对方的资源，就会造成死锁。尽管死锁很少发生，但一旦发生就会造成应用的停止响应。下面是一个死锁的例子：

 

mutex_a = Lock()

mutex_b = Lock()

 

class MyThread(Thread):

    def task_b(self):

        if mutex_a.acquire():

            print 'thread get a mutex_a',self.name

            time.sleep(1)

            if mutex_b.acquire():

                print 'get a mutex_b',self.name

                mutex_b.release()

            mutex_a.release()

 

    def task_a(self):

        if mutex_b.acquire():

            print 'thread get a mutex_b',self.name

            time.sleep(1)

            if mutex_a.acquire():

                print 'get a mutex_a',self.name

                mutex_a.release()

            mutex_b.release()

 

    def run(self):

        self.task_a()

        self.task_b()

 

if __name__ == '__main__':

    threads = [MyThread() for i in range(2)]

    print threads

    for t in threads:

        t.start()

 

线程需要执行两个任务，两个任务都需要获取锁，当两个任务得到锁后，就需要等另外锁释放。

 

5，可重入锁

 

为了支持在同一线程中多次请求同一资源，python 提供了可重入锁（RLock）。RLock内部维护着一个Lock和一个counter变量，counter记录了acquire的次数，从而使得资源可以被多次require。直到一个线程所有的acquire都被release，其他的线程才能获得资源。

 

mutex = threading.RLock()

class MyThread(threading.Thread):

    def run(self):

        if mutex.acquire(1):

            print 'threading gte mutex:',self.name

            time.sleep(1)

            mutex.acquire()

            mutex.release()

            mutex.release()

 

def main():

    print 'start main threading:'

    threads = [MyThread() for i in range(2)]

    for t in threads:

        t.start()

    for t in threads:

        t.join()

    print 'end main threading.'

 

if __name__ == '__main__':        

    main()

 

6，后台线程

 

使用多线程默认情况下，当主线程退出之后，即使子线程没有 join，子线程也依然会继续执行。如果希望主线程退出后，其子线程也退出而不再执行，则需要设置子线程为后台线程。python提供了setDaemon方法，将子线程与主线程进行绑定，当主线程退出时子线程的生命也随之结束。

 

class MyThread(threading.Thread):

    def run(self):

        wait_time = random.randrange(1, 10)

        print 'thread %s will wait %s s' %(self.name, wait_time)

        time.sleep(wait_time)

        time.sleep(30)

        print 'thread %s finished.' % self.name

 

 

def main():

    print 'start thread:'

    for i in range(3):

        t = MyThread()

        t.setDaemon(1)

        t.start()

    print 'end thread.'

 

if __name__ == '__main__':

    main()

 

运行结果：

 

start thread:

thread Thread-1 will wait 9 s

thread Thread-2 will wait 1 s

thread Thread-3 will wait 7 s

end thread.

 

本来子线程需要等待几秒才能结束，但是主线程提前结束了，所以子线程也随主线程结束了。