python Threading线程关键点

创建存储线程的队列，thread=[]

将线程添加到队列中，

t.setDaemon(True)  设置为守护进程等子进程进行完，父进程才继续执行
t.start()          启动线程
t.join()           队列中的子进程没执行完阻塞父进程  

python中，默认情况下，t.setDaemon(False)为False

(1)没有t.setDaemon(True)，如果不加join语句，那么主线程不会等到当前线程结束才结束，但却不会立即杀死该线程。

(2)如果为线程实例添加t.setDaemon(True)之后，如果不加join语句，那么当主线程结束之后，会杀死子线程

t.setDaemon(True)	join()	主线程结束后是否杀死子线程
有	无	是
无	无	否

                    

#coding=utf-8
import threading
from time import ctime,sleep
def music(func):
    for i in range(2):
        print "I was listening to %s. %s" %(func,ctime())
        sleep(1)
def move(func):
    for i in range(2):
        print "I was at the %s! %s" %(func,ctime())
        sleep(5)
threads = []
t1 = threading.Thread(target=music,args=(u'爱情买卖',))
threads.append(t1)
t2 = threading.Thread(target=move,args=(u'阿凡达',))
threads.append(t2)
if __name__ == '__main__':
    for t in threads:
        t.setDaemon(True)
        t.start()
    # t.join()
    print "all over %s" %ctime()

 

1、Python多线程的缺陷：

上面说了那么多关于多线程的用法，但Python多线程并不能真正能发挥作用，因为在Python中，有一个GIL，即全局解释锁，该锁的存在保证在同一个时间只能有一个线程执行任务，也就是多线程并不是真正的并发，只是交替得执行。假如有10个线程炮在10核CPU上，当前工作的也只能是一个CPU上的线程。

2、Python多线程的应用场景。

虽然Python多线程有缺陷，总被人说成是鸡肋，但也不是一无用处，它很适合用在IO密集型任务中。I/O密集型执行期间大部分是时间都用在I/O上，如数据库I/O，较少时间用在CPU计算上。因此该应用场景可以使用Python多线程，当一个任务阻塞在IO操作上时，我们可以立即切换执行其他线程上执行其他IO操作请求。

 

3、线程锁和ThreadLocal

（1）线程锁

对于多线程来说，最大的特点就是线程之间可以共享数据，那么共享数据就会出现多线程同时更改一个变量，使用同样的资源，而出现死锁、数据错乱等情况。

 

假设有两个全局资源，a和b，有两个线程thread1，thread2. thread1占用a，想访问b，但此时thread2占用b，想访问a，两个线程都不释放此时拥有的资源，那么就会造成死锁。

对于该问题，出现了Lock。 当访问某个资源之前，用Lock.acquire()锁住资源,访问之后，用Lock.release()释放资源。用finally的目的是防止当前线程无线占用资源。

 

a = 3

lock = threading.Lock()

def target():

    print 'the curent threading  %s is running' % threading.current_thread().name

    time.sleep(4)

    global a

    lock.acquire()

    try:

        a += 3

    finally:

        lock.release()

    print 'the curent threading  %s is ended' % threading.current_thread().name

    print 'yes'

 

 

 

 

(2)ThreadLocal

 

介绍完线程锁，接下来出场的是ThreadLocal。当不想将变量共享给其他线程时，可以使用局部变量，但在函数中定义局部变量会使得在函数之间传递特别麻烦。ThreadLocal是非常牛逼的东西，它解决了全局变量需要枷锁，局部变量传递麻烦的两个问题。通过在线程中定义：
local_school = threading.local()
此时这个local_school就变成了一个全局变量，但这个全局变量只在该线程中为全局变量，对于其他线程来说是局部变量，别的线程不可更改。 def process_thread(name):# 绑定ThreadLocal的student: local_school.student = name

local = threading.local()

def func(name):

    print 'current thread:%s' % threading.currentThread().name

    local.name = name

    print "%s in %s" % (local.name,threading.currentThread().name)

t1 = threading.Thread(target=func,args=('haibo',))

t2 = threading.Thread(target=func,args=('lina',))

t1.start()

t2.start()

t1.join()

t2.join()