Python学习记录（六）：多线程v2&网络爬虫

[PyxYuYu]

Success is getting what you want, happiness is wanting what you get.

0x01 Wooyun

---

• 命令执行
  • 得到命令执行，做了外网映射，可以顺利登录，但是，系统session验证，JSP、JSPX、替换统统失败，可以利用weblogic部署，假如默认的console也被删的话，自行添加一个域，利用这个域本地配置war包来读取内网数据库
• SQL注入
• Java反序列化命令执行
• 设计错误/逻辑缺陷
  • 任意用户登录
    • 先登录自己的用户，登录时候抓包，修改member_id发送，就可以登录其他用户
• 弱口令
  • 没有验证码之类的验证，直接采用密码123456之类的弱口令用Burpsuite爆破

0x02 爬虫实战一

---

• 多线程
  • setDaemon() 设置True，主线程结束的时候，子线程也会结束，主线程其实就是程序的主运行流程，子线程就是程序中设置的一个个单独工作的线程，主线程一定是程序最先运行，负责拉起子线程干活，所以最后就需要join()，来阻塞线程，强制程序等待所有子线程全部完成才继续执行后面的主线程程序

#!/usr/bin/env python
# coding=utf-8

from threading import Thread
import time

class TestThread(Thread):
    def __init__(self):
        Thread.__init__(self)
    # 线程的作用就是输出i
    def run(self):
        for i in range(5):
            print i
            time.sleep(1)

def main(num):
   threads = []
   # 设置num个线程，并且开启
   for x in range(num):
      threads.append(TestThread())
      threads[x].setDaemon(True)
      threads[x].start()
   # 确保线程们没有完成之前，主程序不会关闭
   for a in range(num):
      threads[a].join()

if __name__ == '__main__':
    now = time.time()
    main(4)
    print (time.time()-now)

• Lock线程锁，多个线程之间同时操作同一个资源（也就是全局变量）的时候，哪个线程先操作，哪个线程就先锁定这个资源，直到这个线程操作结束打开锁之后，其他线程才可以操作，也称为线程安全，和join()不同的是，线程锁只是锁定线程内部某个需要处理的资源（比如某个变量），而join()是对整个线程作出限制
  • l = Lock()( from threading import Lock)
  • l.acquire() 上锁
  • l.release() 解锁发布

#!/usr/bin/env python
# coding=utf-8

from threading import Thread
from threading import Lock

global_num = 0
l = Lock()

class TestThread(Thread):

    def __init__(self):
       # 定义继承自Thread类
       Thread.__init__(self)

    def run(self):
        # 如果不锁的话，下面开启的4个线程就会分别去抢夺global_num这个资源
        # 所以需要锁定，锁定之后就会有先后的顺序了
        l.acquire()
        test()
        l.release()

def test():
    global global_num
    for a in range(5):
        global_num = global + 1
        print global_num

def main():
    global global_num
    threads = []
    for i in range(4):
        threads.append(TestThread())
        threads[i].setDaemon(True)
        threads[i].start()
    for x in range(4)
        threads[x].join()

if __name__ == '__main__':
    main()

• _Event 事件对象，是线程之间最简单的通信机制之一，它是由线程设置的信号标志，如果标志为真，则其他线程等待直到信号解除
  • set() 设置信号为真，isSet()可以判断其内部信号标志的状态
  • clear() 清楚信号，即设为假，isSet()返回假
  • wait() 只有在内部信号为真的时候才会很快的执行并完成返回，当内部信号为假时，则wait方法一直等待其为真时才返回，也就是说wait只有接受到信号为真，才会往下执行，否则不这个线程就被挂起等待信号为真

#!/usr/bin/env python
# coding=utf-8

from threading import Thread
from threading import _Event

class TestThread(Thread):
    global e
    def __init__(self):
        Thread.__init__(self)
    def run(self):
        if(e.isSet()):
            e.clear()
            # 线程等待，如果信号为真，清理信号，并且等待
            # 等待的时候，另外一个线程，直接接收这个假的信号
            # 当这个假的信号执行下面的else语句后，信号为真
            # 之前wait的信号就会继续往下执行了
            e.wait()
            print self.getName()
        else:
            e.set()
            print self.getName()

def main():
    threads = []
    for i in range(4):
        threads.append(TestThread())
        threads[i].setDaemon(True)
        threads[i].start()

    for x in range(4):
        threads[x].join()

if __name__ == '__main__':
    e = _Event()
    e.set()
    main()

0x03 一天总结

---

• 多线程之子线程与主线程的关系
  • setDaemon()
• 多线程之线程锁
  • Lock().acquire()
  • Lock().release()
• 多线程之_Event事件
  • set()
  • wait()
  • clear()
  • isSet()