- 一、什么是线程
- 二、创建线程
- 1、使用threading模块创建线程
- 2、使用Thread子类创建线程
- 3、线程间通信
- 4、使用队列在线程间通信
- 三、互斥锁
- 1、使用互斥锁
- 四、线程和进程的区别总结
如果需要同时处理多个任务，一种是可以在一个应用程序内使用多个进程，每个进程负责完成一部分工作;另一种将工作细分为多个任务的方法是使用一个进程内的多个线程。那么，什么是线程呢?
线程(Thread)是 *** 作系统能够进行运算调度的最小单位。它被包含在进程之中，是进程中的实际运作单位。一条线程指的是进程中一个单一顺序的控制流，一个进程中可以并发多个线程，每条线程并行执行不同的任务。例如，对于视频播放器，显示视频用一个线程，播放音频用另一个线程。只有2个线程同时工作，我们才能正常观看画面和声音同步的视频。
举一个生活中的例子来更好的理解进程和线程的关系。一个进程就像一座房子，它是一个容器，有着相应的属性，如占地面积、卧室、厨房和卫生间等。房子本身并没有主动地做任何事情。而线程就是这座房子的居住者，他可以使用房子内每一个房间、做饭、洗澡等。
二、创建线程由于线程是 *** 作系统直接支持的执行单元，因此，高级语言（如Python、Java等）通常都内置多线程的支持。Python 的标准库提供了两个模块:_thread和 threading，_thread是低级模块，threading 是高级模块，对_thread进行了封装。绝大多数情况下，我们只需要使用threading这个高级模块。
1、使用threading模块创建线程threading模块提供了一个Thread类来代表一个线程对象，语法如下:
Thread( [group [ , target [, name [, args [,kwargs]]]]])
Thread类的参数说明如下:
- group :值为None，为以后版本而保留。
- target:表示一个可调用对象，线程启动时，run()方法将调用此对象，默认值为None，表示不调用任何内容。
- name表示当前线程名称，默认创建一个“Thread-N”格式的唯一名称。args :表示传递给target()函数的参数元组。
- kwargs :表示传递给
- target()函数的参数字典。
import threading,time
def process():
for i in range(3):
time.sleep(2)
print("thread name is %s"%threading.current_thread().name)
if __name__=="__main__":
print("----主线程开始----")
#创建4个线程，存入列表
threads = [threading.Thread(target=process) for i in range(4)]
for t in threads:
t.start() #分别开启每个线程
for t in threads:
t.join() #主线程阻塞，等待每个子线程结束
print("----主线程结束----")
可以看出，线程执行的顺序是不确定的。
import threading,time
class SubThread(threading.Thread):
def run(self):
for i in range(3):
time.sleep(1)
#name属性保存的是当前线程的名字
message = "子线程"+self.name+"执行，i="+str(i)
print(message)
if __name__ == "__main__":
print("----主线程开始----")
#创建子线程
t1 = SubThread()
t2 = SubThread()
#启动子线程
t1.start()
t2.start()
#等待子线程结束
t1.join()
t2.join()
print("----主线程结束----")
3、线程间通信
进程间不能直接共享信息，但是线程之间可以直接共享信息
from threading import Thread
import time
def th1():
print("----子线程1开始----")
global g_num
g_num += 50
print("g_num is %d"%g_num)
print("----子线程1结束----")
def th2():
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=th1)
t2 = Thread(target=th2)
#开始线程
t1.start()
t2.start()
#线程等待，阻塞主线程
t1.join()
t2.join()
print("----主线程结束----")
上述代码中，定义一个全局变量g_num，赋值为100，然后创建2个线程。一个线程g_num增加50，一个线程将g_num减少50。如果g_num的最终结果为100，则说明线程之间可以共享数据。
上述结果说明：
在一个进程内的所有线程共享全局变量，能够在不使用其他方式的前提下完成多线程之间的数据共享。
我们知道multiprocessing模块的Queue队列可以实现进程间通信，同样在线程间，也可以使用Queue队列实现线程间通信。不同之处在于我们需要使用queue模块的Queue队列，而不是multiprocessing模块的Queue队列，但Queue的使用方法相同。
使用Queue在线程间通信通常应用于生产者消费者模式。==产生数据的模块称为生产者，而处理数据的模块称为消费者。在生产者与消费者之间的缓冲区称之为仓库。生产者负责往仓库运输商品，而消费者负责从仓库里取出商品，这就构成了生产者、消费者模式。==下面通过一个示例学习一下使用Queue在线程间通信。
定义一个生产者类Producer，定义一个消费者类Consumer。生成者生成5件产品，依次写入队列,而消费者依次从队列中取出产品，代码如下:
from queue import 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() #启动线程
consumer.start()
producer.join() #等待producer线程结束
consumer.join() #等待consumer线程结束
print("----主线程结束----")
random.random()随机生成0~1之间的数
==由于线程可以对全局变量随意修改，这就可能造成多线程之间对全局变量的混乱 *** 作。==依然以房子为例，当房子内只有一个居住者时（单线程)，他可以任意时刻使用任意一个房间，如厨房、卧室和卫生间等。但是，当这个房子有多个居住者时（多线程)，他就不能在任意时刻使用某些房间，如卫生间，否则就会造成混乱。
如何解决这个问题呢?一个防止他人进入的简单方法，就是门上加一把锁。先到的人锁上门，后到的人就在门口排队，等锁打开再进去。
这就是“互斥锁”(Mutual exclusion，缩写 Mutex)，防止多个线程同时读写某一块内存区域。互斥锁为资源引入一个状态:锁定和非锁定。某个线程要更改共享数据时，先将其锁定，此时资源的状态为“锁定”，其他线程不能更改;直到该线程释放资源，将资源的状态变成“非锁定”时，其他的线程才能再次锁定该资源。互斥锁保证了每次只有一个线程进行写入 *** 作，从而保证了多线程情况下数据的正确性。
1、使用互斥锁在threading模块中使用Lock类可以方便地处理锁定。Lock类有2个方法: acquire()锁定和release()释放锁。示例用法如下:
mutex = threading.Lock() #创建锁 mutex.acquire([blocking]]) #锁定 mutex.release() #释放锁
语法如下:
- acquire([blocking]):获取锁定，如果有必要，需要阻塞到锁定释放为止。如果提供blocking参数并将它设置为False，当无法获取锁定时将立即返回False;如果成功获取锁定则返回True。
- release():释放一个锁定。当锁定处于未锁定状态时，或者从与原本调用acquire()方法的不同线程调用此方法,将出现错误。
下面，通过一个示例学习一下如何使用互斥锁。这里使用多线程和互斥锁模拟实现多人同时订购电影票的功能，假设电影院某个场次只有100张电影票，10个用户同时抢购该电影票。每售出一张，显示一次剩余的电影票张数。代码如下:
from threading import Thread
from threading import Lock
import time
n = 100 #共100张票
def task():
global n
mutex.acquire() #上锁
# temp = n #赋值给临时变量
# time.sleep(0.1) #休眠0.1秒
# n = temp - 1 #数量减1
time.sleep(0.1) #休眠0.1秒
n = n-1
print("购买成功,剩余%d张电影票"%n)
mutex.release() #释放锁
if __name__ == "__main__":
mutex = Lock() #实例化LOCK类
t_list = [] #初始化一个列表
for i in range(10):
t = Thread(target=task) #实例化线程类
t_list.append(t) #将线程实例存入列表中
t.start() #创建线程
for t in t_list:
t.join() #等待子线程结束
上述代码中，创建了10个线程，全部执行task()函数。为解决资源竞争问题，使用mutex.acquire()函数实现资源锁定，第一个获取资源的线程锁定后，其他线程等待mutex.release()解锁。所以每次只有一个线程执行task()函数。运行结果如图所示：
注意：
使用互斥锁时，要避免死锁。在多任务系统下，当一个或多个线程等待系统资源，而资源又被线程本身或其他线程占用时，就形成了死锁
进程和线程的区别主要有（重点）:
- 进程是系统进行资源分配和调度的一个独立单位，线程是进程的一个实体，是CPU调度和分派的基本单位。
- 进程之间是相互独立的，多进程中，同一个变量，各自有一份备份存在于每个进程中，但互不影响;而同一个进程的多个线程是内存共享的，所有变量都由所有线程共享。
- 由于进程间是独立的，因此一个进程的崩溃不会影响到其他进程;而线程是包含在进程之内的，线程的崩溃就会引发进程的崩溃，继而导致同一进程内的其他线程也崩溃。
多线程非全局变量是否要加锁：
在多线程开发中，全局变量是多个线程都共享的数据，为防止数据混乱，通常使用互斥锁。而局部变量等是各自线程的，是非共享的，所以不需要使用互斥锁。
欢迎分享，转载请注明来源：内存溢出
微信扫一扫
支付宝扫一扫
评论列表（0条）