用threading和Queue模块实现多线程的端口扫描器

一.Queue模块基础

q = Queue.Queue()    
q.qsize()           返回队列的大小  
q.empty()         如果队列为空,返回True,反之False  
q.full()          如果队列满了,返回True,反之False
q.full              与 maxsize 大小对应  
q.get([block[, timeout]]) 获取队列,timeout等待时间  
q.get_nowait()         相当q.get(False)
q.put(item)           写入队列,timeout等待时间  
q.put_nowait(item)    相当q.put(item, False)
q.task_done()         在完成一项工作之后,q.task_done() 函数向任务已经完成的队列发送一个信号
q.join()             实际上意味着等到队列为空,再执行别的操作

二.threading模块基础

t = threading.Thread             使用它来创建线程
t.start()                           开始线程的执行
t.run()                           包含了线程实际执行的内容
t.join(timeout=None)               被调用 join() 方法的线程会一直阻塞调用者的线程,直到自己结束
t.name                           用于鉴别进程的一个字符串
t.getName()/t.setName()           为后向兼容而保留的方法,现在请直接通过 name 属性来访问
t.ident                           如果线程还未开始,则值为 None
t.is_alive()                       返回本进程是否是 alive 状态
t.daemon                       标明本进程是否为“daemon thread”。一定要在 start() 被调用前设定,否则引发 RuntimeError。
t.isDaemon() / t.setDaemon()        为后向兼容而保留的方法,现在请直接访问 daemon 属性
lock = threading.Lock
lock.acquire(blocking=True,timeout=-1)        获取一个锁
lock.release()                              释放一个锁

三.多线程端口扫描器

# -*- coding: utf-8 -*-
__author__ = ‘Dleo‘
import sys
import socket
import threading
import Queue

ports=[21,80,445,3389]
queue = Queue.Queue()

def ip_c(ip):
    new_ip = []
    for ip_c in range(1,255):
        new_ip.append(str(ip) + "." + str(ip_c))
        #print new_ip
    return new_ip

class ThreadNum(object):
    def __init__(self, queue):
        self.queue = queue
        self.lock = threading.Lock()
    def port_open(self):
        while True:
            try:
                try:
                    ip = self.queue.get(timeout=1)
                except:
                    break
                for port in ports:
                    socket.setdefaulttimeout(0.5)
                    s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
                    if s.connect_ex((ip, port)) == 0:
                        self.lock.acquire()
                        print (ip + ‘:‘ + str(port) + ‘ is openning‘)
                        self.lock.release()
                    s.close()
            except:
                pass
            self.queue.task_done()
    def run (self):
        tmp = []
        for i in range(255):
            t = threading.Thread(target=self.port_open)
            t.setDaemon(True)
            t.start()
            tmp.append(t)
        for t in tmp:
            t.join()

if __name__ == ‘__main__‘:
    if len(sys.argv) != 2:
        print "please put ip like this ‘127.0.0‘ "
        sys.exit()
    ip = sys.argv[1]
    for i in ip_c(ip):
        queue.put(i)
    t = ThreadNum(queue)
    t.run()

效果图:

时间: 2024-11-03 21:04:56

用threading和Queue模块实现多线程的端口扫描器的相关文章

python Queue模块用于多线程通信

# -*-coding:utf-8 -*- import Queue import threading import time q = Queue.Queue(100000) def producer():     for i in range(1000):         q.put(i)         time.sleep(0) def consumer():     for i in range(1000):         print q.get(), q.qsize()       

Python:使用threading模块实现多线程(转)

分类: python   标签: thread    评论: 暂无评论   阅读:5,420 views 综述 Python这门解释性语言也有专门的线程模型,Python虚拟机使用GIL(Global Interpreter Lock,全局解释器锁)来互斥线程对共享资源的访问,但暂时无法利用多处理器的优势. 在Python中我们主要是通过thread和 threading这两个模块来实现的,其中Python的threading模块是对thread做了一些包装的,可以更加方便的被使用,所以我们使用

Python多线程(3)——Queue模块

Queue模块支持先进先出(FIFO)队列,支持多线程的访问,包括一个主要的类型(Queue)和两个异常类(exception classes). Python 2 中的Queue模块在Python 3中更名为 queue. Queue对象的创建 可以通过实例化Queue类型获得队列对象: q = Queue.Queue(maxsize=0) 创建新的队列,参数 maxsize 的含义是: 如果 maxsize > 0:当 q 中的元素达到 maxsize 个时,队列就满了,此时再有一个线程希望

python 多线程并发threading & 任务队列Queue

https://docs.python.org/3.7/library/concurrency.htmlpython程序默认是单线程的,也就是说在前一句语句执行完之前后面的语句不能继续执行先感受一下线程,一般情况下: def testa(): sleep(1) print "a" def testb(): sleep(1) print "b" testa() testb()#先隔出一秒打印出a,再过一秒打出b 但是如果用了threading的话: ta = thre

python多线程编程-queue模块和生产者-消费者问题

摘录python核心编程 本例中演示生产者-消费者模型:商品或服务的生产者生产商品,然后将其放到类似队列的数据结构中.生产商品中的时间是不确定的,同样消费者消费商品的时间也是不确定的. 使用queue模块(python2.x版本中,叫Queue)来提供线程间通信的机制,从而让线程之间可以分享数据.具体而言,就是创建一个队列,让生产者(线程)在其中放入新的商品,而消费者(线程)消费这些商品. 下表是queue模块的部分属性: 属性 描述 queue模块的类 Queue(maxsize=0) 创建一

day42——queue模块

Python提供了Queue模块来专门实现消息队列Queue对象Queue对象实现一个fifo队列(其他的还有lifo.priority队列,这里不再介绍).queue只有maxsize一个构造参数,用来指定队列容量,指定为0的时候代表容量无限.主要有以下成员函数:Queue.qsize():返回消息队列的当前空间.返回的值不一定可靠.Queue.empty():判断消息队列是否为空,返回True或False.同样不可靠.Queue.full():类似上边,判断消息队列是否满Queue.put(

python threading之queue

创建一个"队列"对象import Queueq = Queue.Queue(maxsize = 10)Queue.Queue类即是一个队列的同步实现.队列长度可为无限或者有限.可通过Queue的构造函数的可选参数maxsize来设定队列长度.如果maxsize小于1就表示队列长度无限. 将一个值放入队列中q.put(10)调用队列对象的put()方法在队尾插入一个项目.put()有两个参数,第一个item为必需的,为插入项目的值:第二个block为可选参数,默认为1.如果队列当前为空且

【[email protected]】queue模块-生产者消费者问题

python通过queue模块来提供线程间的通信机制,从而可以让线程分项数据. 个人感觉queue就是管程的概念 一个生产者消费者问题 1 from random import randint 2 from threading import Thread 3 from queue import Queue 4 from time import sleep 5 6 7 def writeq(queue): 8 print('starting put queue...') 9 queue.put('

python Queue模块使用

Python中,队列是线程间最常用的交换数据的形式.Queue模块是提供队列操作的模块,虽然简单易用,但是不小心的话,还是会出现一些意外. 创建一个"队列"对象import Queueq = Queue.Queue(maxsize = 10)Queue.Queue类即是一个队列的同步实现.队列长度可为无限或者有限.可通过Queue的构造函数的可选参数maxsize来设定队列长度.如果maxsize小于1就表示队列长度无限. 将一个值放入队列中q.put(10)    put(item[