Python 3.14 Subinterpreters vs. Celery. Here is why my RAM usage dropped by 48%
SolidJobs for Python: Redis task runner on PEP 734 subinterpreters, backed by the Ruby solid-redis gem through a sidecar.
以下正文同步自 Hacker News 最新,版权归原站所有,已转换为易读排版。
SolidJobs for Python: Redis task runner on PEP 734 subinterpreters, backed by the Ruby solid-redis gem through a sidecar.
pip install solid-jobs-py
Copy PIP instructions
Port Python de solid-jobs (Ruby) : jobs fiables sur Redis, exécutés en parallélisme CPU réel par des sous-interpréteurs Python (PEP 684 / PEP 734, un GIL par interpréteur).
Redis n'est pas recodé en Python. Tout l'accès Redis passe par un processus compagnon Ruby (sidecar) qui embarque la gemme solid-redis.
[ Processus Python ]
|-- Subinterpreter 1 (GIL isolé) --
|-- Subinterpreter 2 (GIL isolé) --+--> Socket Unix (0600) --> Sidecar Ruby (solid-redis) --> Redis
|-- Subinterpreter N (GIL isolé) --/ JSON lines
Prérequis
Python >= 3.14 (concurrent.interpreters)
Ruby + gem install solid-redis (>= 1.0.13) ; bundle install fonctionne aussi via le Gemfile
Un serveur Redis
Installation
pip install . # embarque solid_redis_gateway.rb
Utilisation
myapp/jobs.py (doit être importable par son nom de module dans les workers, pas main)
from solid_jobs import Task
class RecalculateAccount(Task, channel="critical", max_failures=10): def execute_task(self, account_id): ...
@classmethod def retry_delay(cls, failure_count, error, envelope): return 5.0 # secondes, "drop", "archive" ou None (backoff par défaut)
from myapp.jobs import RecalculateAccount
RecalculateAccount.enqueue(42) RecalculateAccount.enqueue_many([[1], [2], [3]]) RecalculateAccount.enqueue_after(30, 42) RecalculateAccount.schedule_at(datetime_or_timestamp, 42) RecalculateAccount.with_options(channel="low").enqueue(42)
Exécuter les workers :
REDIS_URL=redis://127.0.0.1:6379/0 solid-jobs -r myapp.jobs -c 4 --channel critical,3 --channel default -t 25
Options : -r/--require, -C/--config (TOML ou JSON), -c/--concurrency, --channel nom[,poids], -t/--timeout, --redis-url. Signaux : SIGTERM/SIGINT arrêt gracieux, SIGTSTP quiet, SIGTTIN dump des threads.
Variables d'environnement : REDIS_URL, SOLID_JOBS_RUBY (commande ruby, ex. bundle exec ruby), SOLID_JOBS_GATEWAY_SOCKET (utiliser un sidecar déjà lancé).
Tests : Task.execute(...) exécute en ligne ; with lab.testing("capture"): capture au lieu d'écrire dans Redis.
Même clavier de clés Redis (solid_jobs:*) et mêmes scripts Lua : réservation fiable (liste claimed par worker), ack/requeue protégés par un jeton de claim (fencing), récupération des claims de nœuds morts, retries avec backoff, archive des échecs, tâches planifiées, barrière de publication, IntegrityCheck.
Une requête JSON par ligne, une réponse par ligne :
{"command": "RPOP", "args": ["queue"]} -> {"status": "OK", "data": ...} {"pipeline": [["SET","a",1],["INCR","a"]]} -> {"status": "OK", "data": [...]} erreur -> {"status": "ERROR", "error": {"class": "...", "message": "..."}}
Un thread et un client SolidRedis::Client par connexion. Socket créée en 0600 dans un répertoire 0700. Le sidecar s'arrête quand le parent meurt (EOF sur stdin).
Adaptateurs Rails/ActiveJob, warm pool, code spécifique Ractor, télémétrie SolidTrace (observations.rb). Les hooks d'instrumentation des jobs sont conservés (l'instrumenteur doit être une classe sans argument).
Environnement : Python 3.14.7, 12 CPU logiques (Apple Silicon), Celery 5.6.3, solid-jobs-py 0.1.0 + sidecar Ruby solid-redis, Redis local isolé. Méthodologie identique au benchmark Sidekiq/SolidJobs (Ruby) : worker neuf par mesure, ordre des systèmes alterné, médiane de 6 répétitions de 1 000 jobs, débit mesuré du premier au dernier job d'une file pré-remplie, RSS/CPU de tout l'arbre de processus (sidecar Ruby inclus). Job CPU = boucle entière de 100 000 itérations, job IO = sleep 5 ms, mixed = alternance des deux. Celery : pool prefork, --prefetch-multiplier=1 -Ofair, broker Redis, résultats ignorés.
Rapport complet (enqueue, p95/p99, CPU %, efficacité de scaling, CSV) et code : ../benchmark_sidekiq_solid-jobs/celery_vs_solid_jobs_py/ (python bench.py).
Ce benchmark a aussi mis en évidence deux défauts corrigés dans solid-jobs-py : interpreters.Queue.get(timeout=…) fait de l'attente active en Python 3.14 (remplacé par get_nowait() + sommeil) et une course au démarrage où la récupération pouvait remettre en file les claims du nœud avant son premier heartbeat (désormais publié avant le démarrage des workers).
5000 jobs, 3 répétitions, médianes (results/stress-c4-8-16.md). Débit en jobs/s, mémoire = pic RSS de l'arbre de processus.
Celery garde l'avantage en IO à faible concurrence (artefact du sleep en sous-interpréteur, voir plus haut) ; à c=16 solid-jobs-py rattrape ou dépasse Celery en CPU et en mixed, avec environ moitié moins de mémoire. Aucun job perdu.
4 workers, jobs CPU/IO mélangés, file maintenue à ~1000, un échantillon toutes les 10 s (stability.py, durée via BENCHMARK_STABILITY_DURATION, 1800 s par défaut comme la version Ruby). Les résultats ci-dessous sont des runs courts de 300 s, pas de 30 min.
Débit et mémoire sont plats sur les deux systèmes : pas de fuite visible sur 5 min (une conclusion sur la durée demande le run complet de 30 min). Débit mixed à c=4 : Celery ~6 % devant.
Commandes : BENCHMARK_CONCURRENCY=4,8,16 BENCHMARK_REPETITIONS=3 BENCHMARK_JOBS=5000 BENCHMARK_NAME=stress-c4-8-16 .venv/bin/python bench.py puis BENCHMARK_STABILITY_DURATION=300 .venv/bin/python stability.py.
En résumé : solid-jobs-py égale Celery en CPU et mixed, le dépasse nettement en surcoût et en mémoire, et reste derrière de quelques pourcents en IO à faible concurrence.
redis-server --port 6390 --save "" --appendonly no & REDIS_URL=redis://127.0.0.1:6390/15 PYTHONPATH=src python3 -m unittest discover -s tests -t .
Les tests utilisent FLUSHDB sur la base indiquée : n'utilisez pas une base de production.
For a detailed explanation of source distributions (sdists) and built distributions (wheels), please see the package formats documentation.
Provenance describes where a file came from. On PyPI, provenance is shared via attestations, which provide a verifiable record of the build or publishing details. View details, limitations and caveats.
PyPI verified that this artifact, at this checksum, originated from the publisher listed below.
Signed by GitHub Actions, verified by PyPI on Oct 16, 2026.
Provenance describes where a file came from. On PyPI, provenance is shared via attestations, which provide a verifiable record of the build or publishing details. View details, limitations and caveats.
PyPI verified that this artifact, at this checksum, originated from the publisher listed below.
Signed by GitHub Actions, verified by PyPI on Oct 16, 2026.
正文由 探How 从来源站点 RSS 同步,内容未经改写;遇到排版缺失或需要图片、视频时请以原文为准。