אחסון מקומי של נימים בפייתון: ניהול נתונים ספציפי לנימים

            
import threading

# Create a thread-local object
local_data = threading.local()

def worker():
    # Set a thread-specific value
    local_data.value = threading.current_thread().name
    # Access the thread-specific value
    print(f"Thread {threading.current_thread().name}: Value = {local_data.value}")

# Create and start multiple threads
threads = []
for i in range(3):
    thread = threading.Thread(target=worker, name=f"Thread-{i}")
    threads.append(thread)
    thread.start()

# Wait for all threads to complete
for thread in threads:
    thread.join()

            

              
                Copy
              
            
          

            
Thread Thread-0: Value = Thread-0
Thread Thread-1: Value = Thread-1
Thread Thread-2: Value = Thread-2

            

              
                Copy
              
            
          

            
import threading
import time
import random

# Thread-local storage for request context
request_context = threading.local()

def process_request(request_id):
    # Simulate setting request-specific data
    request_context.request_id = request_id
    request_context.user_id = random.randint(1000, 2000)

    # Simulate processing the request
    print(f"Thread {threading.current_thread().name}: Processing request {request_context.request_id} for user {request_context.user_id}")
    time.sleep(random.uniform(0.1, 0.5))  # Simulate processing time
    print(f"Thread {threading.current_thread().name}: Finished processing request {request_context.request_id} for user {request_context.user_id}")

def worker(request_id):
    process_request(request_id)

# Create and start multiple threads
threads = []
for i in range(5):
    thread = threading.Thread(target=worker, name=f"Thread-{i}", args=(i,))
    threads.append(thread)
    thread.start()

# Wait for all threads to complete
for thread in threads:
    thread.join()

            

              
                Copy
              
            
          

            
Thread Thread-0: Processing request 0 for user 1234
Thread Thread-1: Processing request 1 for user 1567
Thread Thread-2: Processing request 2 for user 1890
Thread Thread-0: Finished processing request 0 for user 1234
Thread Thread-3: Processing request 3 for user 1122
Thread Thread-1: Finished processing request 1 for user 1567
Thread Thread-2: Finished processing request 2 for user 1890
Thread Thread-4: Processing request 4 for user 1456
Thread Thread-3: Finished processing request 3 for user 1122
Thread Thread-4: Finished processing request 4 for user 1456

            

              
                Copy
              
            
          

            
import threading
import sqlite3

# Thread-local storage for database connections
db_context = threading.local()

def get_db_connection():
    if not hasattr(db_context, 'connection'):
        db_context.connection = sqlite3.connect('example.db') # Replace with your DB connection
    return db_context.connection

def worker():
    conn = get_db_connection()
    cursor = conn.cursor()
    cursor.execute("SELECT * FROM employees")
    results = cursor.fetchall()
    print(f"Thread {threading.current_thread().name}: Results = {results}")

# Example setup, replace with your actual database setup
def setup_database():
    conn = sqlite3.connect('example.db') # Replace with your DB connection
    cursor = conn.cursor()
    cursor.execute("CREATE TABLE IF NOT EXISTS employees (id INTEGER PRIMARY KEY, name TEXT)")
    cursor.execute("INSERT INTO employees (name) VALUES ('Alice'), ('Bob'), ('Charlie')")
    conn.commit()
    conn.close()

# Set up the database (run only once)
setup_database()

# Create and start multiple threads
threads = []
for i in range(3):
    thread = threading.Thread(target=worker, name=f"Thread-{i}")
    threads.append(thread)
    thread.start()

# Wait for all threads to complete
for thread in threads:
    thread.join()

            

              
                Copy
              
            
          

            
import threading

# Thread-local storage for configuration settings
config = threading.local()

def worker():
    # Set thread-specific configuration
    config.log_level = 'DEBUG' if threading.current_thread().name == 'Thread-0' else 'INFO'
    config.region = 'US' if threading.current_thread().name == 'Thread-1' else 'EU'

    # Access configuration settings
    print(f"Thread {threading.current_thread().name}: Log Level = {config.log_level}, Region = {config.region if hasattr(config, 'region') else 'N/A'}")

# Create and start multiple threads
threads = []
for i in range(3):
    thread = threading.Thread(target=worker, name=f"Thread-{i}")
    threads.append(thread)
    thread.start()

# Wait for all threads to complete
for thread in threads:
    thread.join()

            

              
                Copy
              
            
          

            
import threading

# Thread-local storage for locale settings
locale_context = threading.local()

def set_locale(language, date_format, currency):
    locale_context.language = language
    locale_context.date_format = date_format
    locale_context.currency = currency

def format_date(date):
    if hasattr(locale_context, 'date_format'):
        # Custom date formatting based on locale
        if locale_context.date_format == 'US':
            return date.strftime('%m/%d/%Y')
        elif locale_context.date_format == 'EU':
            return date.strftime('%d/%m/%Y')
        else:
            return date.strftime('%Y-%m-%d') # ISO format as default
    else:
        return date.strftime('%Y-%m-%d') # Default format

def worker():
    # Simulate setting locale-specific data based on thread
    if threading.current_thread().name == 'Thread-0':
        set_locale('en', 'US', 'USD')
    elif threading.current_thread().name == 'Thread-1':
        set_locale('fr', 'EU', 'EUR')
    else:
        set_locale('ja', 'ISO', 'JPY')

    # Simulate date formatting
    import datetime
    today = datetime.date.today()
    formatted_date = format_date(today)
    print(f"Thread {threading.current_thread().name}: Formatted Date = {formatted_date}")

# Create and start multiple threads
threads = []
for i in range(3):
    thread = threading.Thread(target=worker, name=f"Thread-{i}")
    threads.append(thread)
    thread.start()

# Wait for all threads to complete
for thread in threads:
    thread.join()

            

              
                Copy