Python Threading چیست؟

import random
import time
from threading import Thread

class MyThread(Thread):
    def __init__(self, name):
        Thread.__init__(self)
        self.name = name

    def run(self):
        amount = random.randint(3, 15)
        time.sleep(amount)
        print(f"Thread {self.name} is running")

def create_threads():
    for i in range(5):
        name = f"Thread #{i+1}"
        my_thread = MyThread(name)
        my_thread.start()

if __name__ == "__main__":
    create_threads()

import os
import urllib.request
from threading import Thread

class DownloadThread(Thread):
    def __init__(self, url, name):
        Thread.__init__(self)
        self.name = name
        self.url = url

    def run(self):
        handle = urllib.request.urlopen(self.url)
        fname = os.path.basename(self.url)
        with open(fname, "wb") as f_handler:
            while True:
                chunk = handle.read(1024)
                if not chunk:
                    break
                f_handler.write(chunk)
        print(f"{self.name} has finished downloading {self.url}!")

def main(urls):
    for item, url in enumerate(urls):
        name = f"Thread {item+1}"
        thread = DownloadThread(url, name)
        thread.start()

if __name__ == "__main__":
    urls = [
        "http://www.irs.gov/pub/irs-pdf/f1040.pdf",
        "http://www.irs.gov/pub/irs-pdf/f1040a.pdf",
        "http://www.irs.gov/pub/irs-pdf/f1040ez.pdf",
        "http://www.irs.gov/pub/irs-pdf/f1040es.pdf",
        "http://www.irs.gov/pub/irs-pdf/f1040sb.pdf"
    ]
    main(urls)

import threading

counter = 0
lock = threading.Lock()

def increment():
    global counter
    for _ in range(100000):
        with lock:
            counter += 1

threads = [threading.Thread(target=increment) for _ in range(2)]
for thread in threads:
    thread.start()
for thread in threads:
    thread.join()

print(f"Final counter value: {counter}")

import os
import threading
import urllib.request
from queue import Queue

class Downloader(threading.Thread):
    def __init__(self, queue):
        threading.Thread.__init__(self)
        self.queue = queue

    def run(self):
        while True:
            url = self.queue.get()
            self.download_file(url)
            self.queue.task_done()

    def download_file(self, url):
        handle = urllib.request.urlopen(url)
        fname = os.path.basename(url)
        with open(fname, "wb") as f:
            while True:
                chunk = handle.read(1024)
                if not chunk:
                    break
                f.write(chunk)
        print(f"Finished downloading {url}")

def main(urls):
    queue = Queue()
    for i in range(5):
        t = Downloader(queue)
        t.setDaemon(True)
        t.start()
    for url in urls:
        queue.put(url)
    queue.join()

if __name__ == "__main__":
    urls = [
        "http://www.irs.gov/pub/irs-pdf/f1040.pdf",
        "http://www.irs.gov/pub/irs-pdf/f1040a.pdf",
        "http://www.irs.gov/pub/irs-pdf/f1040ez.pdf",
        "http://www.irs.gov/pub/irs-pdf/f1040es.pdf",
        "http://www.irs.gov/pub/irs-pdf/f1040sb.pdf"
    ]
    main(urls)

from concurrent.futures import ThreadPoolExecutor
import time

def perform_task(task_id):
    print(f"Task {task_id} started")
    time.sleep(2)
    result = task_id * 2
    print(f"Task {task_id} completed with result: {result}")
    return result

with ThreadPoolExecutor(max_workers=3) as executor:
    tasks = [1, 2, 3, 4, 5]
    results = executor.map(perform_task, tasks)
    for result in results:
        print(f"Result: {result}")