1.当所有的线程都创建后再一起调用start()函数启动，而不是创建一个启动一个。构建一个线程类方法代码。

2.使用几种递归的运算的方法代码

3.使用Queue模块解决生产者和消费者问题方法代码

Python多线程编程中常用方法：

1、join()方法：如果一个线程或者在函数执行的过程中调用另一个线程，并且希望待其完成操作后才能执行，那么在调用线程的时就可以使用被调线程的join方法join([timeout]) timeout：可选参数，线程运行的最长时间

2、isAlive()方法：查看线程是否还在运行

3、getName()方法：获得线程名

4、setDaemon()方法：主线程退出时，需要子线程随主线程退出，则设置子线程的setDaemon()

Python多线程编程中常用方法：

1、join()方法：如果一个线程或者在函数执行的过程中调用另一个线程，并且希望待其完成操作后才能执行，那么在调用线程的时就可以使用被调线程的join方法join([timeout]) timeout：可选参数，线程运行的最长时间

2、isAlive()方法：查看线程是否还在运行

3、getName()方法：获得线程名

4、setDaemon()方法：主线程退出时，需要子线程随主线程退出，则设置子线程的setDaemon()

创建函数并且传入Thread 对象中

t.py 脚本内容

import threading,time

from time import sleep, ctime

def now() :

    return str( time.strftime( '%Y-%m-%d %H:%M:%S' , time.localtime() ) )

def test(nloop, nsec):

    print 'start loop', nloop, 'at:', now()

    sleep(nsec)

    print 'loop', nloop, 'done at:', now()

def main():

    print 'starting at:',now()

    threadpool=[]

    for i in xrange(10):

        th = threading.Thread(target= test,args= (i,2))

        threadpool.append(th)

    for th in threadpool:

        th.start()

    for th in threadpool :

        threading.Thread.join( th )

    print 'all Done at:', now()

if __name__ == '__main__':

        main()

Python多线程编程中常用方法：

1、join()方法：如果一个线程或者在函数执行的过程中调用另一个线程，并且希望待其完成操作后才能执行，那么在调用线程的时就可以使用被调线程的join方法join([timeout]) timeout：可选参数，线程运行的最长时间

2、isAlive()方法：查看线程是否还在运行

3、getName()方法：获得线程名

4、setDaemon()方法：主线程退出时，需要子线程随主线程退出，则设置子线程的setDaemon()

Python多线程编程中常用方法：

1、join()方法：如果一个线程或者在函数执行的过程中调用另一个线程，并且希望待其完成操作后才能执行，那么在调用线程的时就可以使用被调线程的join方法join([timeout]) timeout：可选参数，线程运行的最长时间

2、isAlive()方法：查看线程是否还在运行

3、getName()方法：获得线程名

4、setDaemon()方法：主线程退出时，需要子线程随主线程退出，则设置子线程的setDaemon()

Python线程同步：

（1）Thread的Lock和RLock实现简单的线程同步：

import threadingimport timeclass mythread(threading.Thread):    def __init__(self,threadname):
        threading.Thread.__init__(self,name=threadname)    def run(self):        global x
        lock.acquire()        for i in range(3):
            x = x+1
        time.sleep(1)        print x
        lock.release()if __name__ == '__main__':
    lock = threading.RLock()
    t1 = []    for i in range(10):
        t = mythread(str(i))
        t1.append(t)
    x = 0    for i in t1:
        i.start()

（2）使用条件变量保持线程同步：

# coding=utf-8import threadingclass Producer(threading.Thread):    def __init__(self,threadname):
        threading.Thread.__init__(self,name=threadname)    def run(self):        global x
        con.acquire()        if x == 10000:
            con.wait() 
            pass        else:            for i in range(10000):
                x = x+1
                con.notify()        print x
        con.release()class Consumer(threading.Thread):    def __init__(self,threadname):
        threading.Thread.__init__(self,name=threadname)    def run(self):        global x
        con.acquire()        if x == 0:
            con.wait()            pass        else:            for i in range(10000):
                x = x-1
            con.notify()        print x
        con.release()if __name__ == '__main__':
    con = threading.Condition()
    x = 0
    p = Producer('Producer')
    c = Consumer('Consumer')
    p.start()
    c.start()
    p.join()
    c.join()    print x

（3）使用队列保持线程同步：

# coding=utf-8import threadingimport Queueimport timeimport randomclass Producer(threading.Thread):    def __init__(self,threadname):
        threading.Thread.__init__(self,name=threadname)    def run(self):        global     queue
        i = random.randint(1,5)
        queue.put(i)        print self.getName(),' put %d to queue' %(i)
        time.sleep(1)class Consumer(threading.Thread):    def __init__(self,threadname):
        threading.Thread.__init__(self,name=threadname)    def run(self):        global     queue
        item = queue.get()        print self.getName(),' get %d from queue' %(item)
        time.sleep(1)if __name__ == '__main__':
    queue = Queue.Queue()
    plist = []
    clist = []    for i in range(3):
        p = Producer('Producer'+str(i))
        plist.append(p)    for j in range(3):
        c = Consumer('Consumer'+str(j))
        clist.append(c)    for pt in plist:
        pt.start()
        pt.join()    for ct in clist:
        ct.start()
        ct.join()

生产者消费者模式的另一种实现：

# coding=utf-8import timeimport threadingimport Queueclass Consumer(threading.Thread):    def __init__(self, queue):
        threading.Thread.__init__(self)
        self._queue = queue    def run(self):        while True:            # queue.get() blocks the current thread until an item is retrieved.
            msg = self._queue.get()            # Checks if the current message is the "quit"            if isinstance(msg, str) and msg == 'quit':                # if so, exists the loop                break            # "Processes" (or in our case, prints) the queue item            print "I'm a thread, and I received %s!!" % msg        # Always be friendly!        print 'Bye byes!'class Producer(threading.Thread):    def __init__(self, queue):
        threading.Thread.__init__(self)
        self._queue = queue    def run(self):        # variable to keep track of when we started
        start_time = time.time()        # While under 5 seconds..        while time.time() - start_time < 5:            # "Produce" a piece of work and stick it in the queue for the Consumer to process
            self._queue.put('something at %s' % time.time())            # Sleep a bit just to avoid an absurd number of messages
            time.sleep(1)        # This the "quit" message of killing a thread.
        self._queue.put('quit')if __name__ == '__main__':
    queue = Queue.Queue()
    consumer = Consumer(queue)
    consumer.start()
    producer1 = Producer(queue)
    producer1.start()

使用线程池（Thread pool）+同步队列（Queue）的实现方式：

# A more realistic thread pool example# coding=utf-8import time 
import threading 
import Queue 
import urllib2 

class Consumer(threading.Thread): 
    def __init__(self, queue):
        threading.Thread.__init__(self)
        self._queue = queue 
 
    def run(self):        while True: 
            content = self._queue.get() 
            if isinstance(content, str) and content == 'quit':                break
            response = urllib2.urlopen(content)        print 'Bye byes!' 
def Producer():
    urls = [        'http://www.python.org', 'http://www.yahoo.com'        'http://www.scala.org', 'http://cn.bing.com'        # etc.. 
    ]
    queue = Queue.Queue()
    worker_threads = build_worker_pool(queue, 4)
    start_time = time.time()    # Add the urls to process    for url in urls: 
        queue.put(url)  
    # Add the 'quit' message    for worker in worker_threads:
        queue.put('quit')    for worker in worker_threads:
        worker.join() 
    print 'Done! Time taken: {}'.format(time.time() - start_time) 
def build_worker_pool(queue, size):
    workers = []    for _ in range(size):
        worker = Consumer(queue)
        worker.start() 
        workers.append(worker)    return workers 
if __name__ == '__main__':
    Producer()

另一个使用线程池+Map的实现：

import urllib2 
from multiprocessing.dummy import Pool as ThreadPool 
 
urls = [    'http://www.python.org', 
    'http://www.python.org/about/',    'http://www.python.org/doc/',    'http://www.python.org/download/',    'http://www.python.org/community/'
    ] 
# Make the Pool of workers
pool = ThreadPool(4) 
# Open the urls in their own threads# and return the results
results = pool.map(urllib2.urlopen, urls)#close the pool and wait for the work to finish 
pool.close() 
pool.join()

线程是指进程内的一个执行单元,也是进程内的可调度实体.

与进程的区别:

(1) 地址空间:进程内的一个执行单元;进程至少有一个线程;它们共享进程的地址空间;而进程有自己独立的地址空间;

(2) 资源拥有:进程是资源分配和拥有的单位,同一个进程内的线程共享进程的资源

(3) 线程是处理器调度的基本单位,但进程不是.

(4) 二者均可并发执行.

简而言之,一个程序至少有一个进程,一个进程至少有一个线程.

线程的划分尺度小于进程，使得多线程程序的并发性高。

另外，进程在执行过程中拥有独立的内存单元，而多个线程共享内存，从而极大地提高了程序的运行效率。

创建函数并且传bai入Thread 对象中

t.py 脚本内容

import threading,time

from time import sleep, ctime

def now() :

    return str( time.strftime( '%Y-%m-%d %H:%M:%S' , time.localtime() ) )

def test(nloop, nsec):

    print 'start loop', nloop, 'at:', now()

    sleep(nsec)

    print 'loop', nloop, 'done at:', now()

def main():

    print 'starting at:',now()

    threadpool=[]

    for i in xrange(10):

        th = threading.Thread(target= test,args= (i,2))

        threadpool.append(th)