Python: Recorre un código con hilos de ejecución.

17 Jul, 2023 Programación 0

Tengo un código que lee un archivo, selecciona una línea al azar del archivo y luego la imprime con múltiples hilos. El problema es que cada vez que ingreso por ejemplo 2 hilos, utiliza los hilos y detiene el código. Quiero que recorra todas las líneas del archivo y luego detenga el código.

Este es el código:

“`
num_thread = input('Número de hilos: ')
num_thread = int(num_thread)

def leer_lista_tokens():
tokens = []
with open('inputTokens.txt', 'r', encoding='UTF-8') as archivo:
lineas = archivo.readlines()
for linea in lineas:
tokens.append(linea.replace('\n', ''))
return tokens

def leer_lista_proxies():
proxies = []
with open('proxies.txt', 'r', encoding='UTF-8') as archivo:
lineas = archivo.readlines()
for linea in lineas:
proxies.append(linea.replace('\n', ''))
return proxies

class Gen:
def init(self, token, proxy=None):
self.token = token
self.proxy = proxy

<pre><code>def registrar(self):
print(f'Token: {self.token}')
print(f'Proxy: {self.proxy}')
</code></pre>

def worker(proxy, lista_tokens):
token = random.choice(lista_tokens)

d = Gen(token, proxy=proxy)
d.registrar()

def main():
hilos = []

proxies = leer_lista_proxies()

lista_tokens = leer_lista_tokens()
random.shuffle(lista_tokens)
tokens_por_hilo = len(lista_tokens) // num_thread

for i in range(num_thread):
if ((i+1)<num_thread):
num_tokens_para_este_hilo = tokens_por_hilo
else:
num_tokens_para_este_hilo = len(lista_tokens)

<pre><code>tokens_para_este_hilo = lista_tokens[0:num_tokens_para_este_hilo]

lista_tokens = lista_tokens[num_tokens_para_este_hilo:]

t = threading.thread(target=worker, args=(random.choice(proxies), tokens_para_este_hilo, ))
hilos.append(t)
t.start()
</code></pre>

if name == 'main':
main()
“` num_tokens_para_este_hilo=”tokens_por_hilo” else:=”” num_tokens_para_este_hilo=”len(lista_tokens)” tokens_para_este_hilo=”lista_tokens[0:num_tokens_para_este_hilo]” lista_tokens=”lista_tokens[num_tokens_para_este_hilo:]” t=”threading.Thread(target=worker,” args=”(random.choice(proxies),” tokens_para_este_hilo,=”” ))=”” hilos.append(t)=”” t.start()=”” if=”” name=”=” ‘main‘:=”” main()=””></num_thread):
num_tokens_para_este_hilo = tokens_por_hilo
else:
num_tokens_para_este_hilo = len(lista_tokens)

tokens_para_este_hilo = lista_tokens[0:num_tokens_para_este_hilo]

lista_tokens = lista_tokens[num_tokens_para_este_hilo:]

t = threading.thread(target=worker, args=(random.choice(proxies), tokens_para_este_hilo, ))
hilos.append(t)
t.start()

if name == ‘main‘:
main()
“`>

import threading import random num_thread = int(input('Número de hilos: ')) def leer_lista_tokens(): tokens = [] with open('inputTokens.txt', 'r', encoding='UTF-8') as archivo: lineas = archivo.readlines() for linea in lineas: tokens.append(linea.replace('\n', '')) return tokens def leer_lista_proxies(): proxies = [] with open('proxies.txt', 'r', encoding='UTF-8') as archivo: lineas = archivo.readlines() for linea in lineas: proxies.append(linea.replace('\n', '')) return proxies class Gen: def __init__(self, token, proxy=None): self.token = token self.proxy = proxy def registrar(self): print(f'Token: {self.token}') print(f'Proxy: {self.proxy}') def trabajador(proxy, lista_tokens): for token in lista_tokens: d = Gen(token, proxy=proxy) d.registrar() def principal(): hilos = [] proxies = leer_lista_proxies() lista_tokens = leer_lista_tokens() tokens_por_hilo = len(lista_tokens) // num_thread for i in range(num_thread): indice_inicio = i * tokens_por_hilo indice_fin = indice_inicio + tokens_por_hilo if i == num_thread - 1: indice_fin = len(lista_tokens) tokens_para_este_hilo = lista_tokens[indice_inicio:indice_fin] t = threading.Thread(target=trabajador, args=(random.choice(proxies), tokens_para_este_hilo,)) hilos.append(t) t.start() for t in hilos: t.join() if __name__ == '__main__': principal()

Answer

davy.ai

July 17, 2023 at 9:57 pm
En el código actual, cada hilo elige un token aleatorio de la lista de tokens y luego imprime la información del token. Esto significa que la cantidad de tokens que cada hilo procesa es aleatoria y puede ser menor que el número total de tokens en el archivo si el número de hilos es mayor que el número de tokens. Para recorrer todas las líneas del archivo antes de detener el código, necesitamos cambiar la forma en que se asignan los tokens a cada hilo.

Una forma de hacer esto es dividir los tokens de manera uniforme entre los hilos. Podemos calcular cuántos tokens necesita procesar cada hilo en función del número total de tokens y el número de hilos. Luego, podemos asignar un segmento de tokens a cada hilo y hacer que cada hilo procese solo su segmento asignado.

Aquí está el código modificado que implementa este enfoque:
```
import threading
import random

num_thread = int(input('Número de hilos: '))

def leer_lista_tokens():
    tokens = []
    with open('inputTokens.txt', 'r', encoding='UTF-8') as archivo:
        lineas = archivo.readlines()
        for linea in lineas:
            tokens.append(linea.replace('\n', ''))
    return tokens

def leer_lista_proxies():
    proxies = []
    with open('proxies.txt', 'r', encoding='UTF-8') as archivo:
        lineas = archivo.readlines()
        for linea in lineas:
            proxies.append(linea.replace('\n', ''))
    return proxies

class Gen:
    def __init__(self, token, proxy=None):
        self.token = token
        self.proxy = proxy

    def registrar(self):
        print(f'Token: {self.token}')
        print(f'Proxy: {self.proxy}')

def trabajador(proxy, lista_tokens):
    for token in lista_tokens:
        d = Gen(token, proxy=proxy)
        d.registrar()

def principal():
    hilos = []

    proxies = leer_lista_proxies()
    lista_tokens = leer_lista_tokens()

    tokens_por_hilo = len(lista_tokens) // num_thread

    for i in range(num_thread):
        indice_inicio = i * tokens_por_hilo
        indice_fin = indice_inicio + tokens_por_hilo
        if i == num_thread - 1:
            indice_fin = len(lista_tokens)
        tokens_para_este_hilo = lista_tokens[indice_inicio:indice_fin]
        t = threading.Thread(target=trabajador, args=(random.choice(proxies), tokens_para_este_hilo,))
        hilos.append(t)
        t.start()
    for t in hilos:
        t.join()

if __name__ == '__main__':
    principal()
```
En el código modificado, primero calculamos la cantidad de tokens que cada hilo debe procesar y luego dividimos los tokens en consecuencia. Usamos un bucle para crear hilos y asignarles sus respectivos segmentos de tokens para procesar. Luego, iniciamos cada hilo y esperamos a que todos los hilos terminen utilizando join().

Con este enfoque, todos los tokens se procesarán antes de que el código se detenga, independientemente del número de hilos especificado.

Comments are closed.

es.davy.ai

¿Tienes una pregunta?

Python: Recorre un código con hilos de ejecución.

Answer

davy.ai