Python基础编程 多线程学习使用

线程

线程基本概念

1. 什么是线程？
   了解线程之前先说下进程。
   进程：一个线程是进程的一个顺序执行流，进程是独立的所有子任务的集合，
   线程是应用程序中工作的最小单元。

   线程：进程中的每个子任务，不能独立存在

   线程，进程:目的都是想同时完成任务

   1. 各自的特点
      1. 进程的特点:独立(内存独立，cpu使用独立)启动进程开销大(速率低)，进程之间很难共享数据，和数据通信，数据安全高。
      2. 线程的特点:依赖进程(内存共享，CPU使用独立)启动开销小，线程之间共享数据容易，方便通信，线程不安全。

2. 线程的状态
   

创建线程

1. Python3 线程中常用的两个模块为：
   _thread
   threading(推荐使用)
   thread 模块已被废弃。用户可以使用 threading 模块代替。所以，在 Python3 中不能再使用"thread" 模块。为了兼容性，Python3 将 thread 重命名为 “_thread”。
2. python中使用线程有两种方式：函数或用类来包装线程对象。
   1. 函数式：调用 _thread 模块中的start_new_thread()函数来产生新线程。
      代码：

import threading
import time
# 为线程定义一个函数
def someting():
    for i in range(1,11):
        print(i)
        time.sleep(1)
#创建一个函数
threading._start_new_thread(someting(),())

	2. 类方式  threading 模块创建线程
	线程模块同样提供了Thread类来处理线程，Thread类提供了以下方法:
	
	run(): 用以表示线程活动的方法。
	start():启动线程活动。
	join([time]): 等待至线程中止。这阻塞调用线程直至线程的join() 方法被调用中止-正常退出或者抛出未处理的异常-或者是可选的超时发生。
	isAlive(): 返回线程是否活动的。
	getName(): 返回线程名。
	setName(): 设置线程名。

import threading
import time
class Mythread(threading.Thread):
    def __init__(self):
        threading.Thread.__init__(self)
        print("Mythread")
    def run(self):
        for i in range(1,11):
            print(i)
            time.sleep(1)
    def start(self):
        print("开始Mythread")
        super().start()
t=Mythread()
t2 = Mythread()
t.start()
t2.start()

线程同步

使用 Thread 对象的 Lock 和 Rlock 可以实现简单的线程同步，这两个对象都有 acquire 方法和 release 方法，对于那些需要每次只允许一个线程操作的数据，可以将其操作放到 acquire 和 release 方法之间。
当多个线程同时进行任务时，为了保证不会有多个线程同时对同一个数据进行操作造成不可预料的后果，所以有了锁的概念，我们通过锁来使多线程任务更加安全。

1. 锁的创建

   import  threading
   import  time	
   counter = 0
   counter_lock = threading.Lock()  
   counter_lock2 = threading.Lock()
   counter_lock3 = threading.Lock()
   

可以定义多个锁, 当你需要独占某一资源时，任何一个锁都可以锁这个资源
就好比你用不同的锁都可以把相同的一个门锁住是一个道理。

import  threading
import  time

counter = 0
counter_lock = threading.Lock() #只是定义一个锁,并不是给资源加锁,你可以定义多个锁,像下两行代码,当你需要占用这个资源时，任何一个锁都可以锁这个资源
counter_lock2 = threading.Lock()
counter_lock3 = threading.Lock()
class  MyThread(threading.Thread):
    def  __init__(self,name):
        threading.Thread.__init__(self)
        self.name = "Thread-" + str(name)
    def run(self):   #run函数必须实现
        global counter,counter_lock #多线程是共享资源的，使用全局变量
        time.sleep(1);
        if counter_lock.acquire(): #当需要独占counter资源时，必须先锁定，这个锁可以是任意的一个锁，可以使用上边定义的3个锁中的任意一个
            counter += 1
            print ("I am %s, set counter:%s"  % (self.name,counter))
            counter_lock.release() #使用完counter资源必须要将这个锁打开，让其他线程使用

if  __name__ ==  "__main__":
    for i in range(1,101):
        my_thread = MyThread(i)
        my_thread.start()

同一个线程中，RLock.acquire可以被多次调用，利用该特性，可以解决部分死锁问题。

更多文章:点击这里

扫码关注公众号《后端开发ipoo》