import multiprocessing
import os

def worker():
    print(f"進程ID: {os.getpid()}, 進程名稱: {multiprocessing.current_process().name}")

if __name__ == "__main__":
    processes = []
    for i in range(3):
        p = multiprocessing.Process(target=worker, name=f"Process-{i}")
        processes.append(p)
        p.start()
    
    for p in processes:
        p.join()

import multiprocessing
import threading
import time

def thread_task(thread_id):
    """線程工作函數(shù)"""
    print(f"線程 {thread_id} 在進程 {multiprocessing.current_process().name} 中運行")
    time.sleep(2)
    return f"線程 {thread_id} 完成"

def process_task():
    """進程工作函數(shù)"""
    print(f"進程 {multiprocessing.current_process().name} 啟動")
    
    # 創(chuàng)建并啟動多個線程
    threads = []
    results = []
    
    for i in range(4):
        t = threading.Thread(target=thread_task, args=(i,))
        threads.append(t)
        t.start()
    
    # 等待所有線程完成
    for t in threads:
        t.join()
    
    print(f"進程 {multiprocessing.current_process().name} 結(jié)束")

if __name__ == "__main__":
    # 創(chuàng)建3個子進程
    processes = []
    for i in range(3):
        p = multiprocessing.Process(target=process_task, name=f"SubProcess-{i}")
        processes.append(p)
        p.start()
    
    # 等待所有子進程完成
    for p in processes:
        p.join()
    
    print("所有進程完成")

import concurrent.futures
import multiprocessing
import threading
import time

def thread_worker(data):
    """線程池工作函數(shù)"""
    process_name = multiprocessing.current_process().name
    thread_name = threading.current_thread().name
    time.sleep(0.5)  # 模擬工作負載
    return f"{process_name}-{thread_name} 處理: {data}"

def process_worker(data_chunk):
    """進程池工作函數(shù)"""
    print(f"進程 {multiprocessing.current_process().name} 開始處理 {len(data_chunk)} 個項目")
    
    # 使用線程池處理數(shù)據(jù)
    with concurrent.futures.ThreadPoolExecutor(max_workers=4) as executor:
        results = list(executor.map(thread_worker, data_chunk))
    
    return results

if __name__ == "__main__":
    # 準(zhǔn)備數(shù)據(jù)
    all_data = [f"data_{i}" for i in range(20)]
    chunk_size = 5
    data_chunks = [all_data[i:i+chunk_size] for i in range(0, len(all_data), chunk_size)]
    
    # 使用進程池
    with concurrent.futures.ProcessPoolExecutor(max_workers=3) as executor:
        futures = [executor.submit(process_worker, chunk) for chunk in data_chunks]
        
        # 收集結(jié)果
        all_results = []
        for future in concurrent.futures.as_completed(futures):
            all_results.extend(future.result())
    
    print("處理完成，結(jié)果:")
    for result in all_results:
        print(f"  {result}")

import multiprocessing
import threading
import time

class ThreadedProcess(multiprocessing.Process):
    def __init__(self, task_id, data_list):
        super().__init__()
        self.task_id = task_id
        self.data_list = data_list
        self.results = multiprocessing.Manager().list()
    
    def run(self):
        print(f"進程 {self.name} 開始處理任務(wù) {self.task_id}")
        
        # 創(chuàng)建線程
        threads = []
        for i, data in enumerate(self.data_list):
            thread = threading.Thread(
                target=self.process_item,
                args=(data, i)
            )
            threads.append(thread)
            thread.start()
        
        # 等待所有線程完成
        for thread in threads:
            thread.join()
        
        print(f"進程 {self.name} 完成任務(wù) {self.task_id}")
    
    def process_item(self, data, index):
        """處理單個數(shù)據(jù)項"""
        thread_name = threading.current_thread().name
        print(f"線程 {thread_name} 處理: {data}")
        time.sleep(0.3)  # 模擬處理時間
        
        # 處理數(shù)據(jù)并保存結(jié)果
        result = {
            'index': index,
            'data': data,
            'processed': data.upper(),  # 示例處理
            'thread': thread_name,
            'process': self.name
        }
        self.results.append(result)

if __name__ == "__main__":
    # 準(zhǔn)備任務(wù)數(shù)據(jù)
    tasks = [
        (1, ['apple', 'banana', 'cherry']),
        (2, ['dog', 'elephant', 'fox']),
        (3, ['green', 'blue', 'red', 'yellow'])
    ]
    
    # 創(chuàng)建并啟動進程
    processes = []
    for task_id, data_list in tasks:
        process = ThreadedProcess(task_id, data_list)
        processes.append(process)
        process.start()
    
    # 等待所有進程完成
    for process in processes:
        process.join()
    
    # 匯總結(jié)果
    all_results = []
    for process in processes:
        all_results.extend(list(process.results))
    
    print("\n所有任務(wù)完成，結(jié)果匯總:")
    for result in all_results:
        print(f"  任務(wù){(diào)result['index']}: {result['data']} -> {result['processed']}")

import multiprocessing
import threading
import time
import random

def producer(queue, producer_id):
    """生產(chǎn)者線程函數(shù)"""
    for i in range(5):
        item = f"生產(chǎn)者{producer_id}-項目{i}"
        queue.put(item)
        print(f"生產(chǎn): {item}")
        time.sleep(random.uniform(0.1, 0.5))
    queue.put(f"生產(chǎn)者{producer_id}-完成")

def consumer_process(queue, consumer_id):
    """消費者進程函數(shù)"""
    print(f"消費者進程 {consumer_id} 啟動")
    
    completed_producers = 0
    total_producers = 2  # 假設(shè)有2個生產(chǎn)者
    
    while completed_producers < total_producers:
        try:
            item = queue.get(timeout=5)
            if item.endswith("-完成"):
                completed_producers += 1
                print(f"消費者{consumer_id} 收到完成信號: {item}")
            else:
                print(f"消費者{consumer_id} 處理: {item}")
                time.sleep(random.uniform(0.2, 0.8))  # 模擬處理時間
        except queue.Empty:
            print(f"消費者{consumer_id} 等待超時")
            break
    
    print(f"消費者進程 {consumer_id} 結(jié)束")

def producer_process(queue, process_id):
    """生產(chǎn)者進程函數(shù)"""
    print(f"生產(chǎn)者進程 {process_id} 啟動")
    
    # 在生產(chǎn)者進程中創(chuàng)建多個線程
    producer_threads = []
    for i in range(2):  # 每個進程創(chuàng)建2個生產(chǎn)者線程
        thread = threading.Thread(
            target=producer,
            args=(queue, f"P{process_id}-T{i}")
        )
        producer_threads.append(thread)
        thread.start()
    
    # 等待所有生產(chǎn)者線程完成
    for thread in producer_threads:
        thread.join()
    
    print(f"生產(chǎn)者進程 {process_id} 結(jié)束")

if __name__ == "__main__":
    # 創(chuàng)建進程間通信隊列
    queue = multiprocessing.Queue(maxsize=10)
    
    # 創(chuàng)建生產(chǎn)者進程
    producer_processes = []
    for i in range(2):
        p = multiprocessing.Process(
            target=producer_process,
            args=(queue, i)
        )
        producer_processes.append(p)
        p.start()
    
    # 創(chuàng)建消費者進程
    consumer_processes = []
    for i in range(2):
        c = multiprocessing.Process(
            target=consumer_process,
            args=(queue, i)
        )
        consumer_processes.append(c)
        c.start()
    
    # 等待所有進程完成
    for p in producer_processes:
        p.join()
    
    for c in consumer_processes:
        c.join()
    
    print("所有生產(chǎn)消費任務(wù)完成")

import os

# 根據(jù)CPU核心數(shù)設(shè)置進程數(shù)
cpu_count = os.cpu_count()
process_pool_size = max(1, cpu_count - 1)  # 留一個核心給系統(tǒng)

# 根據(jù)任務(wù)類型設(shè)置線程數(shù)
if task_type == "io_intensive":
    thread_pool_size = 10  # I/O密集型可以更多線程
else:
    thread_pool_size = cpu_count  # CPU密集型不宜過多

from multiprocessing import Pool
import threading
import database  # 假設(shè)的數(shù)據(jù)庫模塊

# 進程級別的連接池
process_conn_pool = None

def init_process():
    global process_conn_pool
    process_conn_pool = database.ConnectionPool(max_connections=5)

def thread_task(query):
    # 從進程級連接池獲取連接
    conn = process_conn_pool.get_connection()
    try:
        result = conn.execute(query)
        return result
    finally:
        process_conn_pool.release_connection(conn)

def process_worker(queries):
    with threading.ThreadPoolExecutor(max_workers=3) as executor:
        results = list(executor.map(thread_task, queries))
    return results

if __name__ == "__main__":
    queries = [f"SELECT * FROM table WHERE id = {i}" for i in range(10)]

    with Pool(processes=2, initializer=init_process) as pool:
        results = pool.map(process_worker, [queries[:5], queries[5:]])

import multiprocessing
import threading
import time
from functools import wraps

def retry(max_attempts=3, delay=1):
    """重試裝飾器"""
    def decorator(func):
        @wraps(func)
        def wrapper(*args, **kwargs):
            attempts = 0
            while attempts < max_attempts:
                try:
                    return func(*args, **kwargs)
                except Exception as e:
                    attempts += 1
                    print(f"嘗試 {attempts} 失敗: {e}")
                    if attempts < max_attempts:
                        time.sleep(delay)
                    else:
                        raise
        return wrapper
    return decorator

@retry(max_attempts=3, delay=2)
def reliable_thread_task(data):
    """可靠的線程任務(wù)"""
    # 模擬可能失敗的操作
    if random.random() < 0.3:  # 30%概率失敗
        raise ValueError("隨機失敗")
    
    time.sleep(0.5)
    return f"成功處理: {data}"

def robust_process():
    """健壯的進程函數(shù)"""
    try:
        threads = []
        results = []
        
        for i in range(5):
            t = threading.Thread(
                target=lambda: results.append(reliable_thread_task(f"data-{i}"))
            )
            threads.append(t)
            t.start()
        
        for t in threads:
            t.join()
        
        print(f"處理結(jié)果: {results}")
        
    except Exception as e:
        print(f"進程失敗: {e}")
        # 這里可以添加更復(fù)雜的錯誤處理邏輯

if __name__ == "__main__":
    processes = []
    for i in range(2):
        p = multiprocessing.Process(target=robust_process)
        processes.append(p)
        p.start()
    
    for p in processes:
        p.join()

import multiprocessing
import threading
import time
import random
from http.server import HTTPServer, BaseHTTPRequestHandler
import json

class RequestHandler(BaseHTTPRequestHandler):
    def do_GET(self):
        # 模擬處理時間
        processing_time = random.uniform(0.1, 1.0)
        time.sleep(processing_time)
        
        self.send_response(200)
        self.send_header('Content-type', 'application/json')
        self.end_headers()
        
        response = {
            'path': self.path,
            'processing_time': processing_time,
            'process': multiprocessing.current_process().name,
            'thread': threading.current_thread().name
        }
        
        self.wfile.write(json.dumps(response).encode())

def run_server(port):
    """運行HTTP服務(wù)器"""
    server = HTTPServer(('localhost', port), RequestHandler)
    print(f"服務(wù)器在進程 {multiprocessing.current_process().name} 中啟動，端口: {port}")
    server.serve_forever()

def health_checker(server_ports):
    """健康檢查線程"""
    while True:
        time.sleep(5)
        print(f"健康檢查: 服務(wù)器進程正常運行，監(jiān)控端口: {server_ports}")

def server_process(port):
    """服務(wù)器進程函數(shù)"""
    # 創(chuàng)建服務(wù)器線程
    server_thread = threading.Thread(
        target=run_server,
        args=(port,),
        daemon=True
    )
    
    # 創(chuàng)建健康檢查線程
    health_thread = threading.Thread(
        target=health_checker,
        args=([port],),
        daemon=True
    )
    
    server_thread.start()
    health_thread.start()
    
    # 等待服務(wù)器線程結(jié)束
    server_thread.join()

if __name__ == "__main__":
    # 啟動多個服務(wù)器進程，每個進程在不同的端口上運行
    ports = [8000, 8001, 8002]
    processes = []
    
    for port in ports:
        p = multiprocessing.Process(
            target=server_process,
            args=(port,),
            name=f"ServerProcess-{port}"
        )
        processes.append(p)
        p.start()
    
    print(f"啟動了 {len(processes)} 個服務(wù)器進程")
    
    try:
        # 主進程保持運行
        while True:
            time.sleep(1)
    except KeyboardInterrupt:
        print("正在關(guān)閉服務(wù)器...")
        for p in processes:
            p.terminate()
        for p in processes:
            p.join()
        print("所有服務(wù)器已關(guān)閉")