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

import threading
import time

"""
python的thread模块是比较底层的模块，python的threading模块是对thread做了一些包装的，可以更加方便的被使用
多线程程序的执行顺序是不确定的,当线程被阻塞（Blocked)时,线程挂起，阻塞结束后,线程进入就绪（Runnable）状态，等待调度。
而线程调度将自行选择一个线程执行。只能保证每个线程都运行完整个run函数，但是线程的启动顺序、run函数中每次循环的执行顺序都不能确定。
也就是说:
    1.每个线程默认有一个名字，尽管上面的例子中没有指定线程对象的name，但是python会自动为线程指定一个名字。
    2.当线程的run()方法结束时该线程完成。
    3.无法控制线程调度程序，但可以通过别的方式来影响线程调度的方式。
"""

G_num = 0

def test_thread_1():
    print("test_thread_1 子线程被调用, 休眠2秒")
    time.sleep(2)
    print("test_thread_1 子线程执行结束")

def test_mutex_1(mutex, num):

    # 声明使用全局变量
    global G_num

    for i in range(num):
        if mutex.acquire(True):  # 上锁,True表示进行堵塞,也就是说如果上锁失败,就阻塞在这一步,直到上锁成功
            G_num += 1
            # 释放锁
            mutex.release()

def test_mutex_2(mutex, num):
    # 声明使用全局变量
    global G_num

    for i in range(num):
        if mutex.acquire(True):  # 上锁,True表示进行堵塞,也就是说如果上锁失败,就阻塞在这一步,直到上锁成功
            G_num += 1
            # 释放锁
            mutex.release()

class MyThread(threading.Thread):  # 继承自threading.Thread类
    """
    为了让每个线程的封装性更完美，所以使用threading模块时，往往会定义一个新的子类class，
    只要继承threading.Thread就可以了，然后重写run方法
    """
    # 重写run方法
    def run(self):
        # name属性,当前线程的名字
        print("自己封装的线程类,当前线程名字:%s" % self.name)

    # python的threading.Thread类有一个run方法，用于定义线程的功能函数，
    # 可以在自己的线程类中覆盖该方法。而创建自己的线程实例后，通过Thread类的start方法，
    # 可以启动该线程，交给python虚拟机进行调度，当该线程获得执行的机会时，就会调用run方法执行线程。

def make_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("主线程执行到最后一行")

    while True:
        length = len(threading.enumerate())
        if length == 1:
            return G_num
        else:
            time.sleep(0.2)

num = make_thread()
print(num)

输出:

test_thread_1 子线程被调用, 休眠2秒
自己封装的线程类,当前线程名字:Thread-2
test_thread_1 子线程执行结束
2000000