#
            面向过程的实现方法
            import
             threading

            import
             time


            def
             sing(key):
    
            for item in range(1,7):
        print("我在唱歌")
        time.sleep(1)

def dance(key):
    for item in range(1,7):
        print("我在跳舞")
        time.sleep(1)

if__name__=="__main__":
    key="小强"# 面向过程方式创建线程
    sThread = threading.Thread(target=sing, name="唱歌", args=(key,))
    dThread = threading.Thread(target=dance, name="跳舞", args=(key,))
    sThread.start()
    dThread.start()
    sThread.join()
    dThread.join()
    print("主线程结束")

            #
            面向对象的实现方法
            import
             threading

            import
             time


            """
            
    定义一个类，继承自threading.Thread

            """
            class
             singThread(threading.Thread):
    
            def
            __init__
            (self,name,args):
        super().
            __init__
            ()
        self.name=name
        self.args=args


    def run(self):
        for i in range(1,7):
            print(‘线程{}----{}:i am sing‘.format(self.name,self.args))
            time.sleep(0.5)


class danceThread(threading.Thread):
    def__init__(self, name, args):
        super().__init__()
        self.name = name
        self.args = args

    def run(self):
        for i in range(1,7):
            print(‘线程{}----{}:i am dance‘.format(self.name,self.args))
            time.sleep(0.5)

def main():
    #创建线程
    sing =singThread(1,‘小丽‘)
    dance =danceThread(2,‘小强‘)
    #启动线程    sing.start()
    dance.start()
    #设置主线程等待子线程结束    sing.join()
    dance.join()

if__name__ == "__main__":
    main()

            #
            -*-coding:gb2312-*-
            import
             requests

            import
             threading

            from queue import Queue
from lxml import etree
import time
import json

#定义标记位
data_flag=False

#创建队列def creatQueue():
    #创建存储爬取的页码的url队列
    page_queue=Queue()
    #创建存储爬取到的网页内容的队列
    data_queue=Queue()
    #爬取50页内容for i in range(1,11):
        page_queue.put(i)

    return page_queue,data_queue

#crawl 爬取
#parse 解析
#创建爬取线程存储列表
Crawl_thread_list=[]
#创解析取线程存储列表
Parse_thread_list=[]
#创建爬取线程类class Crawl_thread(threading.Thread):
    def__init__(self,name,page_queue,data_queue):
        super(Crawl_thread, self).__init__()
        self.name=name
        self.page_queue=page_queue
        self.data_queue=data_queue
        self.url=r‘http://www.ifanjian.net/jiantu-{}‘
        self.header={‘User-Agent‘: ‘Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/78.0.3904.108 Safari/537.36‘}

    def run(self):
        print(‘%s-------启动‘%self.name)
        while 1:
            #爬取线程退出if self.page_queue.empty():
                print(‘{}爬取完毕，线程退出‘.format(self.name))
                break# 获取要采集的页码序号并拼接urlprint(‘{}开始爬取数据‘.format(self.name))
            url= self.url.format(self.page_queue.get())
            #爬取网页信息
            r= requests.get(url=url,headers=self.header)
            #将爬取的网页信息放入数据队列中            self.data_queue.put(r.text)
        print(‘%s-------结束‘%self.name)

#创建解析线程类class Parse_thread(threading.Thread):
    def__init__(self,name,data_queue,fp,lock):
        super(Parse_thread, self).__init__()
        self.name=name
        self.data_queue = data_queue
        self.fp=fp
        self.lock=lock


    def run(self):
        print(‘%s-------启动‘%self.name)
        #count=1while 1:

            #解析线程结束if data_flag:
                print(‘{}数据解析完毕，线程退出‘.format(self.name))
                break#从数据队列中获取要采集到的数据
            data= self.data_queue.get()
            print(‘{}开始解析数据‘.format(self.name))
            self.parse_content(data)
            #count += 1print(‘%s-------结束‘%self.name)

    def parse_content(self, data):
        tree = etree.HTML(data)
        # 对取出的数据进行解析# 获取 标题和图片地址所在的位置
        li = tree.xpath("//div[@class=‘page-body clearfix‘]//li[@class=‘cont-item‘]")
        # 建立列表临时存储解析出的数据
        items = []
        for temp in li:
            # 获取标题
            tittle = temp.xpath(".//h2/a/text()")
            # 获取图片src,懒加载
            image_src = temp.xpath("./div[2]//img/@data-src")
            item = {‘标题‘: tittle, ‘链接‘: image_src}

            # 临时存储数据            items.append(item)
        print(items)

        # 将数据写入文件# 获取全局锁        self.lock.acquire()
        # 写入数据print(‘{}开始写入数据‘.format(self.name))
        self.fp.write(json.dumps(items, ensure_ascii=False) + ‘\n‘)
        # 释放全局锁        self.lock.release()




#定义爬取线程创建函数def Creat_crawl_thread(num,page_queue,data_queue):
    #创建线程名称列表
    name_list=[‘爬取线程{}‘.format(i) for i in range(1,num+1)]
    #创建爬取线程for name in name_list:
        crawl_thread= Crawl_thread(name,page_queue,data_queue)
        Crawl_thread_list.append(crawl_thread)

#定义解析线程创建函数def Creat_parse_thread(num,data_queue,fp,lock):
    #创建线程名称列表
    name_list=[‘解析线程{}‘.format(i) for i in range(1,num+1)]
    #创建爬取线程for name in name_list:
        parse_thread= Parse_thread(name,data_queue,fp,lock)
        Parse_thread_list.append(parse_thread)

def main():
   #创建队列
    page_queue,data_queue= creatQueue()
   #创建数据存储文件
    fp= open(‘fangjian.json‘,‘a‘,encoding=‘utf8‘)
   #创建全局锁
    lock= threading.Lock()
   #创建线程#创建爬取线程
    Creat_crawl_thread(3,page_queue,data_queue)
   #创建解析线程
    Creat_parse_thread(3,data_queue,fp,lock)
   #启动爬取线程for crawl_thread in Crawl_thread_list:
       crawl_thread.start()
    #等待10秒#time.sleep(10)# 启动解析线程for parse_thread in Parse_thread_list:
       parse_thread.start()

    # 判断数据是否爬取解析完毕while 1:
        if page_queue.empty():
            breakwhile 1:
        if data_queue.empty():
            global data_flag
            data_flag = True
            break#设置主线程等待子线程结束for crawl_thread in Crawl_thread_list:
        crawl_thread.join()
    for parse_thread in Parse_thread_list:
        parse_thread.join()



    #数据写入结束，关闭文件    fp.close()
    print(‘主线程结束‘)


if__name__ == ‘__main__‘:
    main()