多线程爬虫基础代码

#导入线程模块
import threading      
 
def coding():             #定义 coding 函数，用于打印字符串 "aaa" 十次
    for i in range(10):
        print("aaa")
 
def ac():                 #定义 ac 函数，用于打印字符串 "bbbb" 十次：
    for j in range(10):
        print("bbbb")
 
def main():               #定义 main 函数，用于创建并启动两个线程：
    # 创建第一个线程，目标函数是 coding
    t1 = threading.Thread(target=coding)        
    # 创建第二个线程，目标函数是 ac
    t2 = threading.Thread(target=ac)             
 
    t1.start()  # 启动第一个线程
    t2.start()  # 启动第二个线程
 
if __name__ == '__main__':        #在 __main__ 中调用 main 函数：
    main()

这段代码创建了两个线程，一个用于执行 coding 函数，另一个用于执行 ac 函数。每个函数都简单地打印了一段字符串多次。主函数 main 中创建了这两个线程，并启动它们，使它们可以并发地执行。

# 定义第一个线程类
import threading
 
class MyThread(threading.Thread):
    # 重写 run 方法
    def run(self):
        # 循环打印 "bbbb" 十次
        for j in range(10):
            print("bbbb")
 
# 定义第二个线程类
class YourThread(threading.Thread):
    # 重写 run 方法
    def run(self):
        # 循环打印 "aaa" 十次
        for i in range(10):
            print("aaa")
 
# 主函数
def main():
    # 创建 YourThread 的实例
    t1 = YourThread()
    # 创建 MyThread 的实例
    t2 = MyThread()
 
    # 启动第一个线程
    t1.start()
    # 启动第二个线程
    t2.start()
 
# 当前文件被直接运行时执行主函数
if __name__ == "__main__":
    main()

这段代码创建了两个线程类 MyThread 和 YourThread，它们都继承自 threading.Thread 类，并重写了 run() 方法。在 MyThread 类中，run() 方法会打印字符串 "bbbb" 十次，而在 YourThread 类中，run() 方法会打印字符串 "aaa" 十次。
在 main() 函数中，创建了一个 YourThread 类的实例 t1 和一个 MyThread 类的实例 t2。然后分别调用了它们的 start() 方法，以启动两个线程并发执行。
这段代码的执行结果会交替输出 "aaa" 和 "bbbb" 字符串，每个字符串各输出十次，因为两个线程是并行执行的。
这种方式可以更好地组织代码，将线程相关的逻辑封装在类中，提高了代码的可维护性 

import threading
 
# 全局变量 a 初始化为 0
a = 0
 
# 创建一个线程锁对象
lock = threading.Lock()
 
# 定义一个函数，该函数将对全局变量 a 执行增加 1000 次的操作
def add_a():
    global a  # 声明 a 为全局变量
    for i in range(1000):
        # 获取线程锁，确保线程安全
        lock.acquire()
        # 对全局变量 a 执行加一操作
        a += 1
        # 打印增加后的值
        print(a)
        # 释放线程锁，允许其他线程获取锁
        lock.release()
 
# 主函数，创建两个线程并启动它们
def main():
    for j in range(2):
        # 创建线程，并指定目标函数为 add_a
        t = threading.Thread(target=add_a)
        # 启动线程
        t.start()
 
# 如果当前文件被直接执行，则调用主函数
if __name__ == "__main__":
    main()

 此代码创建了两个线程，每个线程执行 add_a 函数，该函数会对全局变量 a 进行增加 1000 次的操作。为了确保在多线程环境中对 a 的修改是线程安全的，使用了 threading.Lock 对象 lock。这样，每个线程在修改 a 之前会获取锁，修改完成后释放锁，确保其他线程不会同时访问和修改 a，从而避免了竞态条件（Race Condition）的发生。在主函数 main 中，创建了两个线程，并启动它们，以便同时执行 add_a 函数。