【Python】タスクが完了マークになったら再取得可能

タスクの分散と処理は、多くのアプリケーションで共通の問題です。たとえば、タスクはデータの処理、結果の計算、または分散処理を必要とする操作の実行などです。この記事では、Python と Flask を使用して単純なタスク分散システムを作成する方法を示します。このシステムでは、サーバーがタスクを提供し、クライアントがタスクの取得を要求し、タスクを受信済みとしてマークします。クライアントがタスクを完了した後、タスクにマークを付けることができます。タスクを取得します。

サービスターミナル

まず、タスクを処理するために Flask フレームワークを使用してサーバー側を作成します。また、タスクを保存するために SQLite データベースも使用します。

from flask import Flask, request, jsonify
import threading
import sqlite3

app = Flask(__name__)

# 数据库文件名
DB_FILE = 'tasks.db'

# 初始化数据库表并插入示例任务数据
def initialize_database():
    conn = sqlite3.connect(DB_FILE)
    cursor = conn.cursor()
    cursor.execute('''CREATE TABLE IF NOT EXISTS tasks
                  (id INTEGER PRIMARY KEY AUTOINCREMENT, content TEXT, status INTEGER)''')

    # 插入示例任务数据
    cursor.execute("INSERT INTO tasks (content, status) VALUES (?, ?)", ("Task1", 0))
    cursor.execute("INSERT INTO tasks (content, status) VALUES (?, ?)", ("Task2", 0))
    cursor.execute("INSERT INTO tasks (content, status) VALUES (?, ?)", ("Task3", 0))
    cursor.execute("INSERT INTO tasks (content, status) VALUES (?, ?)", ("Task4", 0))

    conn.commit()
    conn.close()

# initialize_database()

tasks_lock = threading.Lock()

@app.route('/get_task', methods=['GET'])
def get_task():
    task = None
    with tasks_lock:
        conn = sqlite3.connect(DB_FILE)
        cursor = conn.cursor()
        cursor.execute('SELECT id, content FROM tasks WHERE status=0 LIMIT 1')
        row = cursor.fetchone()
        if row:
            task_id, task_content = row
            cursor.execute('UPDATE tasks SET status=1 WHERE id=?', (task_id,))
            conn.commit()
            task = task_content
        conn.close()

    if task:
        return jsonify({'task': task})
    else:
        return jsonify({'task': None})

@app.route('/complete_task', methods=['POST'])
def complete_task():
    task = request.json.get('task')
    if task:
        with tasks_lock:
            conn = sqlite3.connect(DB_FILE)
            cursor = conn.cursor()
            cursor.execute('UPDATE tasks SET status=0 WHERE content=?', (task,))
            conn.commit()
            conn.close()
        return jsonify({'message': f'Task {task} marked as completed'})
    else:
        return jsonify({'message': 'Invalid request'})

if __name__ == "__main__":
    app.run(host='0.0.0.0', port=8888)

サーバー側のコードでは、Flask を使用して、タスクを取得し、タスクの完了をマークするための 2 つのルート /get_task と /complete_task を作成しました。また、SQLite データベースを初期化し、サンプルタスクをデータベースに挿入しました。

クライアント

次に、タスクをリクエストして要求済みとしてマークし、タスクを完了して完了としてマークする単純なクライアントを作成します。

import requests
import threading
import time

# 服务器地址
SERVER_URL = 'http://127.0.0.1:8888'

# 最大并发线程数
MAX_CONCURRENT_THREADS = 5

tasks_lock = threading.Lock()

def get_task():
    response = requests.get(f'{SERVER_URL}/get_task')
    if response.status_code == 200:
        data = response.json()
        return data.get('task')
    else:
        return None

def complete_task(task):
    if task:
        response = requests.post(f'{SERVER_URL}/complete_task', json={'task': task})
        if response.status_code == 200:
            data = response.json()
            print(data.get('message'))

def worker():
    while True:
        task = get_task()
        if task:
            print(f'Received task: {task}')
            # 模拟客户端完成任务的处理
            time.sleep(5)
            # 在实际应用中，这里应该执行任务的实际逻辑
            print(f'Completed task: {task}')
            complete_task(task)
        else:
            print('No tasks available. Waiting for tasks...')
            time.sleep(5)

def main():
    threads = []
    for _ in range(MAX_CONCURRENT_THREADS):
        thread = threading.Thread(target=worker)
        thread.start()
        threads.append(thread)

    for thread in threads:
        thread.join()

if __name__ == "__main__":
    main()

クライアントコードでは、リクエストライブラリを使用して HTTP GET リクエストを送信してタスクを取得し、次に HTTP POST リクエストを送信してタスクを完了します。また、複数のクライアントのタスク処理を同時にシミュレートするために、複数のスレッドも作成しました。

この単純なタスク分散システムを使用すると、クライアントはタスクを要求して要求済みとしてマークし、タスクを完了して完了としてマークすることができます。タスクの再取得が可能であり、基本的なタスク分散処理システムを実現します。