python高级培训第三课

目录

创建多线程

多线程特性

线程锁

递归锁

---

创建多线程

什么是线程：线程也叫轻量级进程，是操作系统能够进行运算调度的最小单位，它被包涵在进程之中，是进程中的实际运作单位。线程自己不拥有系统资源，只拥有一点儿在运行中必不可少的资源，但它可与同属一个进程的其他线程共享进程所拥有的全部资源。一个线程可以创建和撤销另一个线程，同一个进程中的多个线程之间可以并发执行

什么是进程：即为程序，程序与程序之间是相互独立的。

创建多线程：

#创建多线程
def test(x):
    print(x)
    time.sleep(2)

t1 = threading.Thread(target = test,args = 1)
t2 = threading.Thread(target = test,args = 2)
t1.start()
t2.start()

#以类的方式创建
class MyThread(thraeding.Thread):
    def __init__(self.n):
        super(MyThread,self).__init__()
        self.n = n

    def run(self):
    print('以类的方式创建多线程'，self.n)

r1 = MyThread(11)
r2 = MyThread(11)
r1.start()
r2.start()

 

多线程特性

t.join特性：

 查看活动线程：threading.acttive_account()

查看当前线程：threading.current_thread()

设置守护线程（必须有主线程）：setDaemon(True)

线程锁

为什么需要线程锁：多个线程对同一个数据进行修改时， 可能会出现不可预料的情况。

如何实现线程锁：

1. 实例化一个锁对象;
lock = threading.Lock()
2. 操作变量之前进行加锁
lock.acquire()
3. 操作变量之后进行解锁
lock.release()

实例：

import threading


#  银行存钱和取钱
def add(lock):
    global money  # 生命money为全局变量
    for i in range(1000000):
        # 2. 操作变量之前进行加锁
        lock.acquire()
        money += 1  # money;  money+1; money=money+1;
        # 3. 操作变量之后进行解锁
        lock.release()


def reduce(lock):
    global money
    for i in range(1000000):
        # 2. 操作变量之前进行加锁
        lock.acquire()
        money -= 1
        # 3. 操作变量之后进行解锁
        lock.release()


if __name__ == '__main__':
    money = 0
    # 1. 实例化一个锁对象;
    lock = threading.Lock()

    t1 = threading.Thread(target=add, args=(lock,))
    t2 = threading.Thread(target=reduce, args=(lock,))
    t1.start()
    t2.start()
    t1.join()
    t2.join()

    print("当前金额:", money)

递归锁

为什么需要递归锁：保证线程之间改变变量的独立性。

怎么使用递归锁：多个线程共同修改一个变量时一定要加上递归锁。

实例：

import threading,time


def run1():
    '''
    定义第一个程序来创建一个修改参数的线程
    :return: 
    '''
    print("Grab the first part data.")
    lock.acquire()
    global num
    num += 1
    lock.release()
    return num

def run2():
    '''
    定义第二个程序来创建一个修改参数的线程
    :return: 
    '''
    print("Grab the second part data.")
    lock.acquire()
    global num2
    num2 += 1
    lock.release()
    return num2

def run3():
    '''
    定义第三个程序来创建一个修改参数的线程
    :return: 
    '''
    lock.acquire()
    res = run1()
    print("----------Between run1 and run2------------- ")
    res2 = run2()
    print(res, res2)
    lock.release()

# 初始化主线程中的变量
num, num2 = 0, 0
# 实例化递归锁
lock = threading.RLock()
# 循环创建线程改变参数
for i in range(9):
    t = threading.Thread(target=run3)
    t.start()

# 判断线程是否都执行结束
while threading.active_count() != 1:
    print(threading.active_count())
else:
    print("--------All threads done--------")
    print(num, num2)