爬虫--多线程、多进程

1.多线程

多线程有两种写法

（1）第一种写法

        “t1 = Thread(target=func)”该语句是创建线程并给线程安排任务

        t1.start()    该语句是多线程状态为开始工作状态，具体的执行时间由CPU决定

（2）第二种写法

第二种写法中，创建一个类MyThread，继承Thread类，写法为“class MyThread(Thread)”

然后再主函数中创建一个线程即“t = MyThread()”，但是这里要注意因为MyThread是一个类，故不能用t.run()来进行多线程，因为t.run()是单线程的类的方法调用，故需要用t.start()方法开启线程。

MyThread类中的run方法是固定的，当线程可以执行后，被执行的就是该线程中的run()。

（3）创建多个线程需要进行传参进行区分时的代码。

        第一种创建多线程的方式中，只需在“t1 = Thread(target=func, args=("周杰伦",))”，后面加上args=("xxx",)。这里一定要注意参数后面必须价格“,”，因为参数必须是元组形式。

# 多线程   创建多个多线程时候为了进行区分需要进行传参。
from threading import Thread   # 导入线程类

def func(name):
    for i in range(1000):
        print(name, i)

# 启动每一个程序默认都会有一个主线程
if __name__ == "__main__" :
    # 创建线程并给线程安排任务
    t1 = Thread(target=func, args=("周杰伦",))          # 创建一个线程类对象，并且告诉程序当前线程执行的话执行func函数(即target=func)
    t1.start()       # 多线程状态为开始工作状态，具体的执行时间由CPU决定

    t2 = Thread(target=func, args=("薛之谦",))
    t2.start()
    
    for i in range(1000):
        print("main: ", i)

        第二种中创建多线程的方式中，只需要在MyThread中加入一个“def __init__(self, name)”函数，其中参数name就是创建线程时传进来的参数用于区分不同线程。super(MyThread,self).__init__() 的作用是重构run函数时必须调用父类的初始化方法，self.name=name是获得创建线程时传进来的参数。

        这种继承创建多线程传参方式是：

# # 多线程   多个参数需要进行传参时
from threading import Thread   # 导入线程类

class MyThread(Thread):   # 写一个类MyThread，继承Thread
    def __init__(self, name):
        super().__init__()
        self.name = name
    def run(self):        # run是固定的      当线程可以执行后，被执行的就是run()
        for i in range(1000):
            print(self.name, i)

if __name__ == '__main__':
    t1 = MyThread("周杰伦")
    # t.run()  # 变成方法的调用了。  相当于单线程了   需要用t.start()
    t1.start()    # 开启线程

    t2 = MyThread("薛之谦")
    # t.run()  # 变成方法的调用了。  相当于单线程了   需要用t.start()
    t2.start()  # 开启线程

    for i in range(1000):
            print("主线程: ", i)

2.单线程和多线程的两种方式的代码

# 线程，进程
# 线程是执行单位
# 进程是资源分配的单位，每一个进程至少有一个线程

# # 单线程
# def func():
#     for i in range(1000):
#         print("func: ", i)
#
# # 启动每一个程序默认都会有一个主线程
# if __name__ == "__main__" :
#     func()
#     for i in range(1000):
#         print("main: ", i)




# # 多线程   第一种写法
# from threading import Thread   # 导入线程类
#
# def func():
#     for i in range(1000):
#         print("func: ", i)
#
# # 启动每一个程序默认都会有一个主线程
# if __name__ == "__main__" :
#     # 创建线程并给线程安排任务
#     t1 = Thread(target=func)          # 创建一个线程类对象，并且告诉程序当前线程执行的话执行func函数(即target=func)
#     t1.start()       # 多线程状态为开始工作状态，具体的执行时间由CPU决定
#     for i in range(1000):
#         print("main: ", i)



# # # 多线程   第二种写法
# from threading import Thread   # 导入线程类
#
# class MyThread(Thread):   # 写一个类MyThread，继承Thread
#     def run(self):        # run是固定的      当线程可以执行后，被执行的就是run()
#         for i in range(1000):
#             print("子线程:", i)
#
# if __name__ == '__main__':
#     t = MyThread()
#     # t.run()  # 变成方法的调用了。  相当于单线程了   需要用t.start()
#     t.start()    # 开启线程
#     for i in range(1000):
#             print("主线程: ", i)


# # 多线程   创建多个多线程时候为了进行区分需要进行传参。
# from threading import Thread   # 导入线程类
#
# def func(name):
#     for i in range(1000):
#         print(name, i)

# # 启动每一个程序默认都会有一个主线程
# if __name__ == "__main__" :
#     # 创建线程并给线程安排任务
#     t1 = Thread(target=func, args=("周杰伦",))          # 创建一个线程类对象，并且告诉程序当前线程执行的话执行func函数(即target=func)
#     t1.start()       # 多线程状态为开始工作状态，具体的执行时间由CPU决定
#
#     t2 = Thread(target=func, args=("薛之谦",))
#     t2.start()
#
#     for i in range(1000):
#         print("main: ", i)


# # 多线程   多个参数需要进行传参时
from threading import Thread   # 导入线程类

class MyThread(Thread):   # 写一个类MyThread，继承Thread
    def __init__(self, name):
        super().__init__()
        self.name = name
    def run(self):        # run是固定的      当线程可以执行后，被执行的就是run()
        for i in range(1000):
            print(self.name, i)

if __name__ == '__main__':
    t1 = MyThread("周杰伦")
    # t.run()  # 变成方法的调用了。  相当于单线程了   需要用t.start()
    t1.start()    # 开启线程

    t2 = MyThread("薛之谦")
    # t.run()  # 变成方法的调用了。  相当于单线程了   需要用t.start()
    t2.start()  # 开启线程

    for i in range(1000):
            print("主线程: ", i)

3.多进程

        与多线程代码逻辑类似，故这里只展现一种方式，类继承创建多继承的方式参考多线程。

from multiprocessing import Process

def func():
    for i in range(1000):
        print("子进程:", i)

if __name__ == '__main__':
    p = Process(target=func)
    p.start()

    for i in range(1000):
        print("主进程:", i)