【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 创建了两个路由 /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()

在客户端代码中，我们使用 requests 库来发送 HTTP GET 请求以获取任务，然后发送 HTTP POST 请求来完成任务。我们还创建了多个线程来模拟多个客户端同时处理任务的情况。

这个简单的任务分发系统允许客户端请求获取任务并标记任务为已领取，然后完成任务并将其标记为已完成。任务可以被重新获取，从而实现了一个基本的任务分发和处理系统。