python多线程互斥锁_python 使用多线程进行并发编程/互斥锁的使用

importthreadingimporttime"""python的thread模块是比较底层的模块，python的threading模块是对thread做了一些包装的，可以更加方便的被使用

多线程程序的执行顺序是不确定的,当线程被阻塞(Blocked)时,线程挂起，阻塞结束后,线程进入就绪(Runnable)状态，等待调度。

而线程调度将自行选择一个线程执行。只能保证每个线程都运行完整个run函数，但是线程的启动顺序、run函数中每次循环的执行顺序都不能确定。

也就是说:

1.每个线程默认有一个名字，尽管上面的例子中没有指定线程对象的name，但是python会自动为线程指定一个名字。

2.当线程的run()方法结束时该线程完成。

3.无法控制线程调度程序，但可以通过别的方式来影响线程调度的方式。"""G_num=0deftest_thread_1():print("test_thread_1 子线程被调用, 休眠2秒")

time.sleep(2)print("test_thread_1 子线程执行结束")deftest_mutex_1(mutex, num):#声明使用全局变量

globalG_numfor i inrange(num):if mutex.acquire(True): #上锁,True表示进行堵塞,也就是说如果上锁失败,就阻塞在这一步,直到上锁成功

G_num += 1

#释放锁

mutex.release()deftest_mutex_2(mutex, num):#声明使用全局变量

globalG_numfor i inrange(num):if mutex.acquire(True): #上锁,True表示进行堵塞,也就是说如果上锁失败,就阻塞在这一步,直到上锁成功

G_num += 1

#释放锁

mutex.release()class MyThread(threading.Thread): #继承自threading.Thread类

"""为了让每个线程的封装性更完美，所以使用threading模块时，往往会定义一个新的子类class，

只要继承threading.Thread就可以了，然后重写run方法"""

#重写run方法

defrun(self):#name属性,当前线程的名字

print("自己封装的线程类,当前线程名字:%s" %self.name)#python的threading.Thread类有一个run方法，用于定义线程的功能函数，

#可以在自己的线程类中覆盖该方法。而创建自己的线程实例后，通过Thread类的start方法，

#可以启动该线程，交给python虚拟机进行调度，当该线程获得执行的机会时，就会调用run方法执行线程。

defmake_thread():#将函数引用使用target命名参数进行传递,创建子线程

thread = threading.Thread(target=test_thread_1)#启动子线程

thread.start()

# 自定义的线程类

my_thread=MyThread()

my_thread.start()#创建一个互斥锁

#这个锁默认是未上锁的状态

mutex =threading.Lock()

t1= threading.Thread(target=test_mutex_1, args=(mutex, 1000000, ))

t1.start()

t2= threading.Thread(target=test_mutex_2, args=(mutex, 1000000, ))

t2.start()#默认情况下,主线程会等待子线程

#t1 线程阻塞, 当t1完成执行后再进行下一步操作

#t1.join()

#t1 线程守护主线程

#t1.daemon = True

#获取当前进程下的所有线程数量(包含主线程)

#length = len(threading.enumerate())

#print("线程数量:%d" % length)

#print("主线程执行到最后一行")

whileTrue:

length=len(threading.enumerate())if length == 1:returnG_numelse:

time.sleep(0.2)

num=make_thread()print(num)