python创建线程

1 使用threading模块创建线程

import  threading,time

def progress():
    print("thread niame is %s -----"%threading.current_thread().name)


if __name__ == '__main__':
    print('~~主线程开始~~')
    threads=[threading.Thread(target=progress) for i in range(4)]#创建似四个线程存入列表
    for t in threads:
        t.start()
        time.sleep(1)
    for t in threads:
        t.join()
    print('~~主线程结束~~')

执行结果：

~~主线程开始~~
thread niame is Thread-1 -----
thread niame is Thread-2 -----
thread niame is Thread-3 -----
thread niame is Thread-4 -----
~~主线程结束~~

2 使用thread子类创建线程

import  threading,time

class SubThread(threading.Thread):
    def run(self):
        for i in range(3):
            time.sleep(1)
            msg="子线程"+self.name+"执行,i="+str(i)
            print(msg)



if __name__ == '__main__':
    print('~~主线程开始~~')
    t1=SubThread()
    t2=SubThread()
    t1.start()
    t2.start()
    t1.join()
    t2.join()
    print('~~主线程结束~~')

运行结果如下：

~~主线程开始~~
子线程Thread-1执行,i=0
子线程Thread-2执行,i=0
子线程Thread-1执行,i=1
子线程Thread-2执行,i=1
子线程Thread-1执行,i=2
子线程Thread-2执行,i=2
~~主线程结束~~

3 应用全局变量进行线程之间通讯

在一个进程内的所有线程共享全局变量。

import threading,time
from threading import Thread

def plus():
    print("子线程加法开始")
    global g_num
    g_num += 50
    print("全局变量值%s"%g_num)
    print("子线程加法结束")
def minus():
    print("子线程减法开始")
    global g_num
    g_num -= 50
    print("全局变量值%s"%g_num)
    print("子线程减法结束")


g_num=100               #定义一个全局变量
.
if __name__ == '__main__':
    print('~~主线程开始~~')
    print("全局变量值%s" % g_num)
    t1=Thread(target=plus)
    t2=Thread(target=minus)
    t1.start()
    t2.start()
    t1.join()
    t2.join()
    print('~~主线程结束~~')

执行结果：

~~主线程开始~~
全局变量值100
子线程加法开始
全局变量值150
子线程加法结束
子线程减法开始
全局变量值100
子线程减法结束
~~主线程结束~~

4 线程锁应用

防止多个线程之间对全局变量混乱操作，在全局变量更改的地方加线程锁，只能允许同时只有一个线程进行全局变量修改

import threading,time
from threading import Thread,Lock

def task():
    global n
    mutex.acquire()  #上锁
    time.sleep(0.1)
    n=n-1
    print("购买成功，当前余票数量%s"%n)
    mutex.release()   #解锁




n=100      #定义一个全局变量

if __name__ == '__main__':
    print('~~主线程开始~~')
    mutex = Lock()
    t_list=[]
    for i in range(10):
        t1 = Thread(target=task)
        t_list.append(t1)
        t1.start()
    for i in t_list:
        i.join()
    print('~~主线程结束~~')

执行结果：

~~主线程开始~~
购买成功，当前余票数量99
购买成功，当前余票数量98
购买成功，当前余票数量97
购买成功，当前余票数量96
购买成功，当前余票数量95
购买成功，当前余票数量94
购买成功，当前余票数量93
购买成功，当前余票数量92
购买成功，当前余票数量91
购买成功，当前余票数量90
~~主线程结束~~

5 应用队列在线程之间通讯

生产者产生产品，消费者消耗产品，用队列作为二者中间的中转仓

import threading,time,random
from threading import Thread,Lock
from  queue import Queue


#生产者类
class Producter(threading.Thread):
    def __init__(self,name,queue):
        threading.Thread.__init__(self,name=name)
        self.data=queue
    def run(self):
        for i in range(5):
            print("生产者%s将产品%s放入队列"%(self.getName(),i))
            self.data.put(i)
            time.sleep(random.random())
        print("生产者%s完成"%self.getName())
# 消费者类
class Consumer(threading.Thread):
    def __init__(self, name, queue):
        threading.Thread.__init__(self, name=name)
        self.data = queue
    def run(self):
        for i in range(5):
            value=self.data.get()    
            print("消费者%s将产品%s从队列取出"%(self.getName(),value))
            time.sleep(random.random())
        print("消费者%s完成"%self.getName())


n=100      #定义一个全局变量

if __name__ == '__main__':
    print('~~主线程开始~~')
    queue=Queue()     #实例化队列
    producter = Producter("producter",queue)
    consumer = Consumer("consumer",queue)
    producter.start()
    consumer.start()
    producter.join()
    consumer.join()

    print('~~主线程结束~~')

运行结果如下：

~~主线程开始~~
生产者producter将产品0放入队列
消费者consumer将产品0从队列取出
生产者producter将产品1放入队列
消费者consumer将产品1从队列取出
生产者producter将产品2放入队列
消费者consumer将产品2从队列取出
生产者producter将产品3放入队列
生产者producter将产品4放入队列
消费者consumer将产品3从队列取出
消费者consumer将产品4从队列取出
生产者producter完成
消费者consumer完成
~~主线程结束~~