线程的基本创建方式

1、使用threading模块创建线程

具体代码实现：

# -*- coding:utf-8 -*-
import threading,time

def process():
    for i in range(3):
        time.sleep(1)
        print("thread name is %s" % threading.current_thread().name)

if __name__ == '__main__':
    print("-----主线程开始-----")
    threads = [threading.Thread(target=process) for i in range(4)] # 创建4个线程，存入列表
    for t in threads:
        t.start()       # 开启线程
    for t in threads:
        t.join()        # 等待子线程结束
    print("-----主线程结束-----")

运行程序，控制台输出

---

2、使用Thread子类创建线程

具体代码实现：

# -*- coding: utf-8 -*-
import threading
import time
class SubThread(threading.Thread):
    def run(self):
        for i in range(3):
            time.sleep(1)
            msg = "子线程"+self.name+'执行，i='+str(i) #name属性中保存的是当前线程的名字
            print(msg)
if __name__ == '__main__':
    print('-----主线程开始-----')
    t1 = SubThread()		# 创建子线程t1
    t2 = SubThread() 	# 创建子线程t2
    t1.start()      		# 启动子线程t1
    t2.start()      		# 启动子线程t2
    t1.join()       		# 等待子线程t1
    t2.join()       		# 等待子线程t2
    print('-----主线程结束-----')

运行程序，控制台输出

---

3、进程通信

具体代码实现：

# -*- coding:utf-8 -*-
from threading import Thread
import time

def plus():
    print('-------子线程1开始------')
    global g_num
    g_num += 50
    print('g_num is %d'%g_num)
    print('-------子线程1结束------')

def minus():
    time.sleep(1)
    print('-------子线程2开始------')
    global g_num
    g_num -= 50
    print('g_num is %d'%g_num)
    print('-------子线程2结束------')

g_num = 100 # 定义一个全局变量
if __name__ == '__main__':
    print('-------主线程开始------')
    print('g_num is %d'%g_num)
    t1 = Thread(target=plus)   # 实例化线程p1
    t2 = Thread(target=minus)  # 实例化线程p2
    t1.start()                  # 开启线程p1
    t2.start()                  # 开启线程p2
    t1.join()                   # 等待p1线程结束
    t2.join()                   # 等待p2线程结束
    print('-------主线程结束------')

运行程序，控制台输出

---

4、互斥锁的使用

具体代码实现：

from threading import Thread,Lock
import time
n=100 # 共100张票

def task():
    global n
    mutex.acquire()             # 上锁
    temp=n                      # 赋值给临时变量
    time.sleep(0.1)             # 休眠0.1秒
    n=temp-1                    # 数量减1
    print('购买成功，剩余%d张电影票'%n)
    mutex.release()             # 释放锁

if __name__ == '__main__':
    mutex=Lock()                # 实例化Lock类
    t_l=[]                      # 初始化一个列表
    for i in range(10):
        t=Thread(target=task)   # 实例化线程类
        t_l.append(t)           # 将线程实例存入列表中
        t.start()               # 创建线程
    for t in t_l:
        t.join()                # 等待子线程结束

运行程序，控制台输出

死锁

---

5、使用队列在线程间通信

具体代码实现：

from queue import Queue
import random,threading,time

# 生产者类
class Producer(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将产品%d加入队列!" % (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):
            val = self.data.get()
            print("消费者%s将产品%d从队列中取出!" % (self.getName(),val))
            time.sleep(random.random())
        print("消费者%s完成!" % self.getName())

if __name__ == '__main__':
    print('-----主线程开始-----')
    queue = Queue()        # 实例化队列
    producer = Producer('Producer',queue)   # 实例化线程Producer，并传入队列作为参数
    consumer = Consumer('Consumer',queue)   # 实例化线程Consumer，并传入队列作为参数
    producer.start()    # 启动线程Producer
    consumer.start()    # 启动线程Consumer
    producer.join()     # 等待线程Producer结束
    consumer.join()     # 等待线程Consumer结束
    print('-----主线程结束-----')

运行程序，控制台输出

---

6、进程与线程的区别

主进程=与子进程、管道不能通信

---

7、多线程非全局变量是否要加锁