【无标题】

了解线程和进程的概念，进程是包含线程的，比如进程是一个软件，线程就是软件中的一些子模块。当不存在多线程的时候，子模块只能顺序执行，引入多线程之后，子模块之间才能够进行并列执行。多线程可以有两类实现方法，一类是用普通程序中的实现，另一类是通过类进行实现。

import threading
import time


def Dog():
    while 1:
        print("汪汪汪")
        time.sleep(1)
def Cat():
    while 1:
        print("喵喵喵")
        time.sleep(2)

def Yang():
    while 1:
        print("绵绵绵绵")
        time.sleep(3)
t1 =threading.Thread(target=Dog)
t2 =threading.Thread(target=Cat)
t3 =threading.Thread(target=Yang)
t1.start()
t2.start()
t3.start()

import threading
import time

# def Dog():
#     while 1:
#         print("汪汪汪")
#         time.sleep(1)
def Cat():
    while 1:
        print("喵喵喵")
        time.sleep(3)
class Mythread(threading.Thread):
    def __init__(self,name):
        super(Mythread,self).__init__()
        self.name = name
    def run(self):
        while 1 :
            print(self.name)
            time.sleep(1)
t1 = Mythread("zhangsan")
t1.start()
Cat()

线程的一些特点，如何知道线程的执行时间，如何获取共有多少个线程在进行执行，如何获取当前正在执行的线程。

import threading
import time


def run(x):
    print(f"xiancheng{x}")
    time.sleep(2)
    # print(threading.current_thread())#查看正在执行那个线程

if __name__ == '__main__':
    #采用多线程
    res =[]
    start_time = time.time()  # 获取从1970年到现在的时间，以秒为单位
    for i in range(10):
        t = threading.Thread(target=run,args=(i,))#里面好像不能有两个i会报错
        t.setDaemon(True)
        t.start()
        res.append(t)
    print(threading.active_count())#执行的线程数目
    # for t in res:
    #     t.join()
    # t.join()#等待最后一个线程结束后再往后进行执行
    # run(1)
    # run(2)
    end_time = time.time()  # 获取从1970年到现在的时间，以秒为单位
    print(f"run()函数共运行了{end_time - start_time}秒")
    print(threading.current_thread())  # 查看正在执行那个线程

线程锁，为了防止多个线程对一个数据进行同时操作而出错，而设计的一种方法，具体原理不太懂，但是在python2中如果不加入线程锁，可能会出问题，python3中得到了很好的解决，基本不需要线程锁。

import threading


def run():
    global x
    lock.acquire()
    x+=1
    lock.release()
if __name__ == '__main__':
    x = 0
    res =[]
    lock = threading.Lock()
    for i in range(100):
        t = threading.Thread(target=run)
        t.start()
        res.append(t)
    for t in res:
        t.join()
    print(x)

递归锁，目前没有特别理解具体用处是什么，有点绕

import threading
def run1():
    global  x
    lock.acquire()
    x += 1
    lock.release()
    return x
def run2():
    global  y
    lock.acquire()
    y += 1
    lock.release()
    return y
def run3():
    lock.acquire()
    res1 = run1()
    res2 = run2()
    lock.release()
    print(res1,res2)
if __name__ == '__main__':
    x = 0
    y = 0
    lock = threading.RLock()
    for i in range(50):
        t = threading.Thread(target=run3)
        t.start()
    while threading.active_count() != 1 :
        print(f'正在运行{threading.active_count()}个线程')
    print("线程运行结束")