• 使用python生成大量数据写入es数据库并查询操作2

    模拟学生个人信息写入es数据库，包括姓名、性别、年龄、特点、科目、成绩，创建时间。

    方案一：

    在写入数据时未提前创建索引mapping，而是每插入一条数据都包含了索引的信息。

    示例代码：【多线程写入数据】【一次性写入10000*1000条数据】  【本人亲测耗时3266秒】

    1. from elasticsearch import Elasticsearch
    2. from elasticsearch import helpers
    3. from datetime import datetime
    4. from queue import Queue
    5. import random
    6. import time
    7. import threading
    8.  
    9. es = Elasticsearch(hosts='http://127.0.0.1:9200')
    10. # print(es)
    11.  
    12. names = ['刘一', '陈二', '张三', '李四', '王五', '赵六', '孙七', '周八', '吴九', '郑十']
    13. sexs = ['男', '女']
    14. age = [25, 28, 29, 32, 31, 26, 27, 30]
    15. character = ['自信但不自负,不以自我为中心',
    16.              '努力、积极、乐观、拼搏是我的人生信条',
    17.              '抗压能力强，能够快速适应周围环境',
    18.              '敢做敢拼，脚踏实地；做事认真负责，责任心强',
    19.              '爱好所学专业，乐于学习新知识；对工作有责任心；踏实，热情，对生活充满激情',
    20.              '主动性强，自学能力强，具有团队合作意识，有一定组织能力',
    21.              '忠实诚信,讲原则，说到做到，决不推卸责任',
    22.              '有自制力，做事情始终坚持有始有终，从不半途而废',
    23.              '肯学习,有问题不逃避,愿意虚心向他人学习',
    24.              '愿意以谦虚态度赞扬接纳优越者,权威者',
    25.              '会用100%的热情和精力投入到工作中；平易近人',
    26.              '为人诚恳,性格开朗,积极进取,适应力强、勤奋好学、脚踏实地',
    27.              '有较强的团队精神,工作积极进取,态度认真']
    28. subjects = ['语文', '数学', '英语', '生物', '地理']
    29. grades = [85, 77, 96, 74, 85, 69, 84, 59, 67, 69, 86, 96, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86]
    30. create_time = datetime.now().strftime('%Y-%m-%d %H:%M:%S')
    31.  
    32.  
    33. def save_to_es(num):
    34.     """
    35.     批量写入数据到es数据库
    36.     :param num:
    37.     :return:
    38.     """
    39.     start = time.time()
    40.     action = [
    41.         {
    42.             "_index": "personal_info_10000000",
    43.             "_type": "doc",
    44.             "_id": i,
    45.             "_source": {
    46.                 "id": i,
    47.                 "name": random.choice(names),
    48.                 "sex": random.choice(sexs),
    49.                 "age": random.choice(age),
    50.                 "character": random.choice(character),
    51.                 "subject": random.choice(subjects),
    52.                 "grade": random.choice(grades),
    53.                 "create_time": create_time
    54.             }
    55.         } for i in range(10000 * num, 10000 * num + 10000)
    56.     ]
    57.     helpers.bulk(es, action)
    58.     end = time.time()
    59.     print(f"{num}耗时{end - start}s!")
    60.  
    61.  
    62. def run():
    63.     global queue
    64.     while queue.qsize() > 0:
    65.         num = queue.get()
    66.         print(num)
    67.         save_to_es(num)
    68.  
    69.  
    70. if __name__ == '__main__':
    71.     start = time.time()
    72.     queue = Queue()
    73.     # 序号数据进队列
    74.     for num in range(1000):
    75.         queue.put(num)
    76.  
    77.     # 多线程执行程序
    78.     consumer_lst = []
    79.     for _ in range(10):
    80.         thread = threading.Thread(target=run)
    81.         thread.start()
    82.         consumer_lst.append(thread)
    83.     for consumer in consumer_lst:
    84.         consumer.join()
    85.     end = time.time()
    86.     print('程序执行完毕！花费时间：', end - start)

    运行结果：

     自动创建的索引mapping：

    1. GET personal_info_10000000/_mapping
    2. {
    3.   "personal_info_10000000" : {
    4.     "mappings" : {
    5.       "properties" : {
    6.         "age" : {
    7.           "type" : "long"
    8.         },
    9.         "character" : {
    10.           "type" : "text",
    11.           "fields" : {
    12.             "keyword" : {
    13.               "type" : "keyword",
    14.               "ignore_above" : 256
    15.             }
    16.           }
    17.         },
    18.         "create_time" : {
    19.           "type" : "text",
    20.           "fields" : {
    21.             "keyword" : {
    22.               "type" : "keyword",
    23.               "ignore_above" : 256
    24.             }
    25.           }
    26.         },
    27.         "grade" : {
    28.           "type" : "long"
    29.         },
    30.         "id" : {
    31.           "type" : "long"
    32.         },
    33.         "name" : {
    34.           "type" : "text",
    35.           "fields" : {
    36.             "keyword" : {
    37.               "type" : "keyword",
    38.               "ignore_above" : 256
    39.             }
    40.           }
    41.         },
    42.         "sex" : {
    43.           "type" : "text",
    44.           "fields" : {
    45.             "keyword" : {
    46.               "type" : "keyword",
    47.               "ignore_above" : 256
    48.             }
    49.           }
    50.         },
    51.         "subject" : {
    52.           "type" : "text",
    53.           "fields" : {
    54.             "keyword" : {
    55.               "type" : "keyword",
    56.               "ignore_above" : 256
    57.             }
    58.           }
    59.         }
    60.       }
    61.     }
    62.   }
    63. }

    方案二：

    1.顺序插入5000000条数据

    先创建索引personal_info_5000000，确定好mapping后，再插入数据。

    新建索引并设置mapping信息：

    1. PUT personal_info_5000000
    2. {
    3.   "settings": {
    4.     "number_of_shards": 3,
    5.     "number_of_replicas": 1
    6.   },
    7.   "mappings": {
    8.     "properties": {
    9.       "id": {
    10.         "type": "long"
    11.       },
    12.       "name": {
    13.         "type": "text",
    14.         "fields": {
    15.           "keyword": {
    16.             "type": "keyword",
    17.             "ignore_above": 32
    18.           }
    19.         }
    20.       },
    21.       "sex": {
    22.         "type": "text",
    23.         "fields": {
    24.           "keyword": {
    25.             "type": "keyword",
    26.             "ignore_above": 8
    27.           }
    28.         }
    29.       },
    30.       "age": {
    31.         "type": "long"
    32.       },
    33.       "character": {
    34.         "type": "text",
    35.         "analyzer": "ik_smart",
    36.         "fields": {
    37.           "keyword": {
    38.             "type": "keyword",
    39.             "ignore_above": 256
    40.           }
    41.         }
    42.       },
    43.       "subject": {
    44.         "type": "text",
    45.         "fields": {
    46.           "keyword": {
    47.             "type": "keyword",
    48.             "ignore_above": 256
    49.           }
    50.         }
    51.       },
    52.       "grade": {
    53.         "type": "long"
    54.       },
    55.       "create_time": {
    56.         "type": "date",
    57.         "format": "yyyy-MM-dd HH:mm:ss||yyyy-MM-dd||epoch_millis"
    58.       }
    59.     }
    60.   }
    61. }

    查看新建索引信息：

    1. GET personal_info_5000000
    2.  
    3. {
    4.   "personal_info_5000000" : {
    5.     "aliases" : { },
    6.     "mappings" : {
    7.       "properties" : {
    8.         "age" : {
    9.           "type" : "long"
    10.         },
    11.         "character" : {
    12.           "type" : "text",
    13.           "fields" : {
    14.             "keyword" : {
    15.               "type" : "keyword",
    16.               "ignore_above" : 256
    17.             }
    18.           },
    19.           "analyzer" : "ik_smart"
    20.         },
    21.         "create_time" : {
    22.           "type" : "date",
    23.           "format" : "yyyy-MM-dd HH:mm:ss||yyyy-MM-dd||epoch_millis"
    24.         },
    25.         "grade" : {
    26.           "type" : "long"
    27.         },
    28.         "id" : {
    29.           "type" : "long"
    30.         },
    31.         "name" : {
    32.           "type" : "text",
    33.           "fields" : {
    34.             "keyword" : {
    35.               "type" : "keyword",
    36.               "ignore_above" : 32
    37.             }
    38.           }
    39.         },
    40.         "sex" : {
    41.           "type" : "text",
    42.           "fields" : {
    43.             "keyword" : {
    44.               "type" : "keyword",
    45.               "ignore_above" : 8
    46.             }
    47.           }
    48.         },
    49.         "subject" : {
    50.           "type" : "text",
    51.           "fields" : {
    52.             "keyword" : {
    53.               "type" : "keyword",
    54.               "ignore_above" : 256
    55.             }
    56.           }
    57.         }
    58.       }
    59.     },
    60.     "settings" : {
    61.       "index" : {
    62.         "routing" : {
    63.           "allocation" : {
    64.             "include" : {
    65.               "_tier_preference" : "data_content"
    66.             }
    67.           }
    68.         },
    69.         "number_of_shards" : "3",
    70.         "provided_name" : "personal_info_50000000",
    71.         "creation_date" : "1663471072176",
    72.         "number_of_replicas" : "1",
    73.         "uuid" : "5DfmfUhUTJeGk1k4XnN-lQ",
    74.         "version" : {
    75.           "created" : "7170699"
    76.         }
    77.       }
    78.     }
    79.   }
    80. }

    开始插入数据：

    示例代码： 【单线程写入数据】【一次性写入10000*500条数据】  【本人亲测耗时7916秒】

    1. from elasticsearch import Elasticsearch
    2. from datetime import datetime
    3. from queue import Queue
    4. import random
    5. import time
    6. import threading
    7.  
    8. es = Elasticsearch(hosts='http://127.0.0.1:9200')
    9. # print(es)
    10.  
    11. names = ['刘一', '陈二', '张三', '李四', '王五', '赵六', '孙七', '周八', '吴九', '郑十']
    12. sexs = ['男', '女']
    13. age = [25, 28, 29, 32, 31, 26, 27, 30]
    14. character = ['自信但不自负,不以自我为中心',
    15.              '努力、积极、乐观、拼搏是我的人生信条',
    16.              '抗压能力强，能够快速适应周围环境',
    17.              '敢做敢拼，脚踏实地；做事认真负责，责任心强',
    18.              '爱好所学专业，乐于学习新知识；对工作有责任心；踏实，热情，对生活充满激情',
    19.              '主动性强，自学能力强，具有团队合作意识，有一定组织能力',
    20.              '忠实诚信,讲原则，说到做到，决不推卸责任',
    21.              '有自制力，做事情始终坚持有始有终，从不半途而废',
    22.              '肯学习,有问题不逃避,愿意虚心向他人学习',
    23.              '愿意以谦虚态度赞扬接纳优越者,权威者',
    24.              '会用100%的热情和精力投入到工作中；平易近人',
    25.              '为人诚恳,性格开朗,积极进取,适应力强、勤奋好学、脚踏实地',
    26.              '有较强的团队精神,工作积极进取,态度认真']
    27. subjects = ['语文', '数学', '英语', '生物', '地理']
    28. grades = [85, 77, 96, 74, 85, 69, 84, 59, 67, 69, 86, 96, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86]
    29. create_time = datetime.now().strftime('%Y-%m-%d %H:%M:%S')
    30.  
    31.  
    32. # 添加程序耗时的功能
    33. def timer(func):
    34.     def wrapper(*args, **kwargs):
    35.         start = time.time()
    36.         res = func(*args, **kwargs)
    37.         end = time.time()
    38.         print('id{}共耗时约 {:.2f} 秒'.format(*args, end - start))
    39.         return res
    40.  
    41.     return wrapper
    42.  
    43.  
    44. @timer
    45. def save_to_es(num):
    46.     """
    47.     顺序写入数据到es数据库
    48.     :param num:
    49.     :return:
    50.     """
    51.     body = {
    52.         "id": num,
    53.         "name": random.choice(names),
    54.         "sex": random.choice(sexs),
    55.         "age": random.choice(age),
    56.         "character": random.choice(character),
    57.         "subject": random.choice(subjects),
    58.         "grade": random.choice(grades),
    59.         "create_time": create_time
    60.     }
    61.     # 此时若索引不存在时会新建
    62.     es.index(index="personal_info_5000000", id=num, doc_type="_doc", document=body)
    63.  
    64. def run():
    65.     global queue
    66.     while queue.qsize() > 0:
    67.         num = queue.get()
    68.         print(num)
    69.         save_to_es(num)
    70.  
    71.  
    72. if __name__ == '__main__':
    73.     start = time.time()
    74.     queue = Queue()
    75.     # 序号数据进队列
    76.     for num in range(5000000):
    77.         queue.put(num)
    78.  
    79.     # 多线程执行程序
    80.     consumer_lst = []
    81.     for _ in range(10):
    82.         thread = threading.Thread(target=run)
    83.         thread.start()
    84.         consumer_lst.append(thread)
    85.     for consumer in consumer_lst:
    86.         consumer.join()
    87.     end = time.time()
    88.     print('程序执行完毕！花费时间：', end - start)

    运行结果：

    2.批量插入5000000条数据

    先创建索引personal_info_5000000_v2，确定好mapping后，再插入数据。

    新建索引并设置mapping信息：

    1. PUT personal_info_5000000_v2
    2. {
    3.   "settings": {
    4.     "number_of_shards": 3,
    5.     "number_of_replicas": 1
    6.   },
    7.   "mappings": {
    8.     "properties": {
    9.       "id": {
    10.         "type": "long"
    11.       },
    12.       "name": {
    13.         "type": "text",
    14.         "fields": {
    15.           "keyword": {
    16.             "type": "keyword",
    17.             "ignore_above": 32
    18.           }
    19.         }
    20.       },
    21.       "sex": {
    22.         "type": "text",
    23.         "fields": {
    24.           "keyword": {
    25.             "type": "keyword",
    26.             "ignore_above": 8
    27.           }
    28.         }
    29.       },
    30.       "age": {
    31.         "type": "long"
    32.       },
    33.       "character": {
    34.         "type": "text",
    35.         "analyzer": "ik_smart",
    36.         "fields": {
    37.           "keyword": {
    38.             "type": "keyword",
    39.             "ignore_above": 256
    40.           }
    41.         }
    42.       },
    43.       "subject": {
    44.         "type": "text",
    45.         "fields": {
    46.           "keyword": {
    47.             "type": "keyword",
    48.             "ignore_above": 256
    49.           }
    50.         }
    51.       },
    52.       "grade": {
    53.         "type": "long"
    54.       },
    55.       "create_time": {
    56.         "type": "date",
    57.         "format": "yyyy-MM-dd HH:mm:ss||yyyy-MM-dd||epoch_millis"
    58.       }
    59.     }
    60.   }
    61. }

    查看新建索引信息：

    1. GET personal_info_5000000_v2
    2.  
    3. {
    4.   "personal_info_5000000_v2" : {
    5.     "aliases" : { },
    6.     "mappings" : {
    7.       "properties" : {
    8.         "age" : {
    9.           "type" : "long"
    10.         },
    11.         "character" : {
    12.           "type" : "text",
    13.           "fields" : {
    14.             "keyword" : {
    15.               "type" : "keyword",
    16.               "ignore_above" : 256
    17.             }
    18.           },
    19.           "analyzer" : "ik_smart"
    20.         },
    21.         "create_time" : {
    22.           "type" : "date",
    23.           "format" : "yyyy-MM-dd HH:mm:ss||yyyy-MM-dd||epoch_millis"
    24.         },
    25.         "grade" : {
    26.           "type" : "long"
    27.         },
    28.         "id" : {
    29.           "type" : "long"
    30.         },
    31.         "name" : {
    32.           "type" : "text",
    33.           "fields" : {
    34.             "keyword" : {
    35.               "type" : "keyword",
    36.               "ignore_above" : 32
    37.             }
    38.           }
    39.         },
    40.         "sex" : {
    41.           "type" : "text",
    42.           "fields" : {
    43.             "keyword" : {
    44.               "type" : "keyword",
    45.               "ignore_above" : 8
    46.             }
    47.           }
    48.         },
    49.         "subject" : {
    50.           "type" : "text",
    51.           "fields" : {
    52.             "keyword" : {
    53.               "type" : "keyword",
    54.               "ignore_above" : 256
    55.             }
    56.           }
    57.         }
    58.       }
    59.     },
    60.     "settings" : {
    61.       "index" : {
    62.         "routing" : {
    63.           "allocation" : {
    64.             "include" : {
    65.               "_tier_preference" : "data_content"
    66.             }
    67.           }
    68.         },
    69.         "number_of_shards" : "3",
    70.         "provided_name" : "personal_info_5000000_v2",
    71.         "creation_date" : "1663485323617",
    72.         "number_of_replicas" : "1",
    73.         "uuid" : "XBPaDn_gREmAoJmdRyBMAA",
    74.         "version" : {
    75.           "created" : "7170699"
    76.         }
    77.       }
    78.     }
    79.   }
    80. }

    批量插入数据：

            通过elasticsearch模块导入helper，通过helper.bulk来批量处理大量的数据。首先将所有的数据定义成字典形式，各字段含义如下：

    • _index对应索引名称，并且该索引必须存在。
    • _type对应类型名称。
    • _source对应的字典内，每一篇文档的字段和值，可有有多个字段。

    示例代码：  【程序中途异常，写入4714000条数据】

    1. from elasticsearch import Elasticsearch
    2. from elasticsearch import helpers
    3. from datetime import datetime
    4. from queue import Queue
    5. import random
    6. import time
    7. import threading
    8.  
    9. es = Elasticsearch(hosts='http://127.0.0.1:9200')
    10. # print(es)
    11.  
    12. names = ['刘一', '陈二', '张三', '李四', '王五', '赵六', '孙七', '周八', '吴九', '郑十']
    13. sexs = ['男', '女']
    14. age = [25, 28, 29, 32, 31, 26, 27, 30]
    15. character = ['自信但不自负,不以自我为中心',
    16.              '努力、积极、乐观、拼搏是我的人生信条',
    17.              '抗压能力强，能够快速适应周围环境',
    18.              '敢做敢拼，脚踏实地；做事认真负责，责任心强',
    19.              '爱好所学专业，乐于学习新知识；对工作有责任心；踏实，热情，对生活充满激情',
    20.              '主动性强，自学能力强，具有团队合作意识，有一定组织能力',
    21.              '忠实诚信,讲原则，说到做到，决不推卸责任',
    22.              '有自制力，做事情始终坚持有始有终，从不半途而废',
    23.              '肯学习,有问题不逃避,愿意虚心向他人学习',
    24.              '愿意以谦虚态度赞扬接纳优越者,权威者',
    25.              '会用100%的热情和精力投入到工作中；平易近人',
    26.              '为人诚恳,性格开朗,积极进取,适应力强、勤奋好学、脚踏实地',
    27.              '有较强的团队精神,工作积极进取,态度认真']
    28. subjects = ['语文', '数学', '英语', '生物', '地理']
    29. grades = [85, 77, 96, 74, 85, 69, 84, 59, 67, 69, 86, 96, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86]
    30. create_time = datetime.now().strftime('%Y-%m-%d %H:%M:%S')
    31.  
    32.  
    33. # 添加程序耗时的功能
    34. def timer(func):
    35.     def wrapper(*args, **kwargs):
    36.         start = time.time()
    37.         res = func(*args, **kwargs)
    38.         end = time.time()
    39.         print('id{}共耗时约 {:.2f} 秒'.format(*args, end - start))
    40.         return res
    41.  
    42.     return wrapper
    43.  
    44.  
    45. @timer
    46. def save_to_es(num):
    47.     """
    48.     批量写入数据到es数据库
    49.     :param num:
    50.     :return:
    51.     """
    52.     action = [
    53.         {
    54.             "_index": "personal_info_5000000_v2",
    55.             "_type": "_doc",
    56.             "_id": i,
    57.             "_source": {
    58.                 "id": i,
    59.                 "name": random.choice(names),
    60.                 "sex": random.choice(sexs),
    61.                 "age": random.choice(age),
    62.                 "character": random.choice(character),
    63.                 "subject": random.choice(subjects),
    64.                 "grade": random.choice(grades),
    65.                 "create_time": create_time
    66.             }
    67.         } for i in range(10000 * num, 10000 * num + 10000)
    68.     ]
    69.     helpers.bulk(es, action)
    70.  
    71.  
    72. def run():
    73.     global queue
    74.     while queue.qsize() > 0:
    75.         num = queue.get()
    76.         print(num)
    77.         save_to_es(num)
    78.  
    79.  
    80. if __name__ == '__main__':
    81.     start = time.time()
    82.     queue = Queue()
    83.     # 序号数据进队列
    84.     for num in range(500):
    85.         queue.put(num)
    86.  
    87.     # 多线程执行程序
    88.     consumer_lst = []
    89.     for _ in range(10):
    90.         thread = threading.Thread(target=run)
    91.         thread.start()
    92.         consumer_lst.append(thread)
    93.     for consumer in consumer_lst:
    94.         consumer.join()
    95.     end = time.time()
    96.     print('程序执行完毕！花费时间：', end - start)

    运行结果：

    3.批量插入50000000条数据

    先创建索引personal_info_5000000_v2，确定好mapping后，再插入数据。

    此过程是在上面批量插入的前提下进行优化，采用python生成器。

    建立索引和mapping同上，直接上代码：

    示例代码： 【程序中途异常，写入3688000条数据】

    1. from elasticsearch import Elasticsearch
    2. from elasticsearch import helpers
    3. from datetime import datetime
    4. from queue import Queue
    5. import random
    6. import time
    7. import threading
    8.  
    9. es = Elasticsearch(hosts='http://127.0.0.1:9200')
    10. # print(es)
    11.  
    12. names = ['刘一', '陈二', '张三', '李四', '王五', '赵六', '孙七', '周八', '吴九', '郑十']
    13. sexs = ['男', '女']
    14. age = [25, 28, 29, 32, 31, 26, 27, 30]
    15. character = ['自信但不自负,不以自我为中心',
    16.              '努力、积极、乐观、拼搏是我的人生信条',
    17.              '抗压能力强，能够快速适应周围环境',
    18.              '敢做敢拼，脚踏实地；做事认真负责，责任心强',
    19.              '爱好所学专业，乐于学习新知识；对工作有责任心；踏实，热情，对生活充满激情',
    20.              '主动性强，自学能力强，具有团队合作意识，有一定组织能力',
    21.              '忠实诚信,讲原则，说到做到，决不推卸责任',
    22.              '有自制力，做事情始终坚持有始有终，从不半途而废',
    23.              '肯学习,有问题不逃避,愿意虚心向他人学习',
    24.              '愿意以谦虚态度赞扬接纳优越者,权威者',
    25.              '会用100%的热情和精力投入到工作中；平易近人',
    26.              '为人诚恳,性格开朗,积极进取,适应力强、勤奋好学、脚踏实地',
    27.              '有较强的团队精神,工作积极进取,态度认真']
    28. subjects = ['语文', '数学', '英语', '生物', '地理']
    29. grades = [85, 77, 96, 74, 85, 69, 84, 59, 67, 69, 86, 96, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86]
    30. create_time = datetime.now().strftime('%Y-%m-%d %H:%M:%S')
    31.  
    32.  
    33. # 添加程序耗时的功能
    34. def timer(func):
    35.     def wrapper(*args, **kwargs):
    36.         start = time.time()
    37.         res = func(*args, **kwargs)
    38.         end = time.time()
    39.         print('id{}共耗时约 {:.2f} 秒'.format(*args, end - start))
    40.         return res
    41.  
    42.     return wrapper
    43.  
    44.  
    45. @timer
    46. def save_to_es(num):
    47.     """
    48.     使用生成器批量写入数据到es数据库
    49.     :param num:
    50.     :return:
    51.     """
    52.     action = (
    53.         {
    54.             "_index": "personal_info_5000000_v3",
    55.             "_type": "_doc",
    56.             "_id": i,
    57.             "_source": {
    58.                 "id": i,
    59.                 "name": random.choice(names),
    60.                 "sex": random.choice(sexs),
    61.                 "age": random.choice(age),
    62.                 "character": random.choice(character),
    63.                 "subject": random.choice(subjects),
    64.                 "grade": random.choice(grades),
    65.                 "create_time": create_time
    66.             }
    67.         } for i in range(10000 * num, 10000 * num + 10000)
    68.     )
    69.     helpers.bulk(es, action)
    70.  
    71.  
    72. def run():
    73.     global queue
    74.     while queue.qsize() > 0:
    75.         num = queue.get()
    76.         print(num)
    77.         save_to_es(num)
    78.  
    79.  
    80. if __name__ == '__main__':
    81.     start = time.time()
    82.     queue = Queue()
    83.     # 序号数据进队列
    84.     for num in range(500):
    85.         queue.put(num)
    86.  
    87.     # 多线程执行程序
    88.     consumer_lst = []
    89.     for _ in range(10):
    90.         thread = threading.Thread(target=run)
    91.         thread.start()
    92.         consumer_lst.append(thread)
    93.     for consumer in consumer_lst:
    94.         consumer.join()
    95.     end = time.time()
    96.     print('程序执行完毕！花费时间：', end - start)

    运行结果：

  • 相关阅读:
    《神经网络与深度学习》算法伪代码汇总
    微服务的发展历程的详细说明及每个阶段主流的架构和组件
    React Refs 使用场景及核心要点
    【字符串】分割字符串的最大得分
    408计算机组成原理需要背的部分
    这里有一份超实用Excel快捷键合集（常用+八大类汇总）
    fpga bitstream userid
    SpringBoot + Docker 实现一次构建到处运行
    pytorch中的view与reshape
    【C语言】堆排序详解
  • 原文地址：https://blog.csdn.net/weixin_44799217/article/details/126911481