多线程应用

import time
import threading

def func_one(name):
    for num in range(1,6):
        print(f"{name}第{num}次执行")
        time.sleep(1)

def func_two(name):
    for num in range(1,6):
        print(f"{name}第{num}次执行")
        time.sleep(1)

if __name__=='__main__':
    #创建子线程
    t1=threading.Thread(target=func_one,args=("张三",))
    t2=threading.Thread(target=func_two,args=("李四",))

    t1.start()
    t2.start()
    print("老板走了")

#类创建的就是线程
import time
from threading import Thread

class DemoOne(Thread):
    def __init__(self,name):
        super().__init__()
        self.name=name

    def run(self):
        for num in range(1,6):
            print(f"{self.name}第{num}次执行")
            time.sleep(1)

class DemoTwo(Thread):
    def __init__(self,name):
        Thread.__init__(self)
        self.name=name

    def run(self):
        for num in range(1,6):
            print(f"{self.name}第{num}次执行")
            time.sleep(1)

if __name__=='__main__':
    t1 = DemoOne("张三")
    t2= DemoTwo("李四")

    t1.start()
    t2.start()

import time
import threading

def func_one(name):
    for num in range(1,6):
        print(f'{name}第{num}次执行')
        time.sleep(1)

def func_two(name):
    for num in range(1,6):
        print(f"{name}第{num}次执行")
        time.sleep(1)


if __name__ =='__main__':
    # 创建子线程
    t1=threading.Thread(target=func_one,args=('张三',), daemon=True)
    # t1.setDeamon(True)
    t2=threading.Thread(target=func_two,args=('李四',))
    t2.setDaemon(True)
    #启动线程
    t1.start()
    t2.start()

    print('线程——阻塞')
    t1.join(timeout=3)
    print('线程——阻塞')
    t2.join(timeout=3)
    print("老板走了")

import threading  
import time  
  
def worker():  
    print('Worker thread starting')  
    time.sleep(5)  # 模拟一些工作  
    print('Worker thread finished')  
  
# 创建一个守护线程  
daemon_thread = threading.Thread(target=worker, daemon=True)  
daemon_thread.start()  
  
# 主线程尝试等待守护线程完成，但最多只等待2秒  
daemon_thread.join(timeout=2)  
  
if daemon_thread.is_alive():  
    print("Daemon thread is still alive")  
else:  
    print("Daemon thread has finished or was killed")  
  
# 注意：由于daemon_thread是守护线程，当主线程结束时，它会被强制结束  
# 因此，上面的"Worker thread finished"可能不会被打印出来

import time
import threading

number=100

lock= threading.Lock()

def func_one(name):
    for num in range(200):
        global number
        lock.acquire()  #上锁
        if number>0:
            print(f"{name}正在输出{number}")
        number-=1
        lock.release()

def func_two(name):
    for num in range(200):
        global number
        lock.acquire()
        if number>0:
            print(f"{name}正在输出{number}")
        number -=1
        lock.release()

if __name__=='__main__':
    #创建子线程
    t1 = threading.Thread(target=func_one, args=("张三",))
    t2 = threading.Thread(target=func_two, args=("虚竹",))
    #启动线程

    t1.start()
    t2.start()



# 这段代码里 global number，  number=100已经定义，为什么还要global number
# 在Python中，使用global关键字是为了告诉解释器你正在引用或修改的是全局作用域中的变量，而不是在局部作用域（如函数内部）中创建一个新的同名变量。
#
# 在你的代码中，尽管number已经在全局作用域中被定义（即在函数外部定义），但在函数内部，Python会默认认为你正在引用或修改一个局部变量，除非你用global关键字明确告诉它你是在操作全局变量。
#
# 在你给出的代码示例中，尽管number在函数外部已经被定义，但由于在函数内部你试图修改它（即number-=1），所以你需要使用global关键字来告诉Python：“我不是在创建一个新的局部变量number，而是在修改已经在全局作用域中定义的number”。
#
# 如果你没有在函数内部使用global number，那么当你尝试修改number时，Python会创建一个新的局部变量number（只在函数内部存在），而这个新的局部变量会与全局变量number无关。这会导致全局变量number的值不会被修改，因为函数内部实际上是在修改一个与全局变量同名但不同的局部变量。
#
# 所以，即使number=100已经在全局作用域中定义，你仍然需要在函数内部使用global number来确保你正在操作的是那个全局变量