Celery: タスクはサブプロセスを開始できません

これは3.0と3.1の間で変更されていないため、なぜこのエラーが発生するのか、以前は発生しなかったのかわかりません。

これは、このエラーを再現する方法です。

app.py：

import multiprocessing
from celery import Celery

app = Celery(__name__, broker='amqp://192.168.33.40')
@app.task
def f():
    manager = multiprocessing.Manager()

sendtask.py：

import app

app.f.delay()

次のコマンドを使用してworkerを実行します： celery worker -A app.app -l debug 。

Celery 3.0.24を使用すると、タスクは成功します。

[2013-12-02 20:43:56,454: INFO/MainProcess] Task app.f[bcaab028-dbec-43a8-9259-ff7c35ff13d0] 
succeeded in 0.0169339179993s: None

Celery 3.1.5では、次のことは行われません。

[2013-12-02 20:48:38,946: ERROR/MainProcess] Task app.f[c9f1cdd3-ae38-493e-b7c7-b9636ed473d0] 
raised exception: AssertionError('daemonic processes are not allowed to have children',)

この問題についての私の理解は次のとおりです。 celery.concurrency.prefork.TaskPoolはcelery.concurrency.asynpool.AsynPoolます; AsynPoolは、デーモンワーカープロセスをbilliard.pool.Poolから継承し、 AsynPoolはこの動作をオーバーライドしません。 しかし、あなたは正しいです、このスキームは3.0と3.1の間で変更されていないようです、それで私も混乱しています:)

そして、私だけがその問題を抱えているわけではないようです： http ：

1つの違いは、ワーカープロセスが 'Process'のサブクラスになり、関数の引数Process(target=)使用する前は、これらのアプローチのデフォルト値に違いがある可能性があることです。

マルチプロセッシングと古いバージョンのビリヤードセットdaemon=True ：
https://github.com/celery/billiard/blob/2.7/billiard/pool.py#L904

そしてそれは最新バージョンでも同じです：
https://github.com/celery/billiard/blob/3.3/billiard/pool.py#L1039

デーモンであるタスクプロセスは、タスクの実装に深刻な制限があると思います。
マルチプロセッシングを使用してCPUバウンド操作を高速化するタスクを作成しました。 次のようにターミナルでワーカーを起動すると、すべて正常に動作します。

セロリワーカー--app = tasks -Q wb -l info --concurrency = 1

しかし、celerydスクリプトを使用してワーカーを起動すると、次の例外が発生します。
AssertionError：デーモンプロセスに子を含めることは許可されていません

何が行動の変化を引き起こしたのかを理解しました。
タスクは3.0と3.1の両方でデーモンプロセスを使用して実行されますが、celery / billiard @ 4c32d2eとhttps://github.com/celery/billiard/commit/c676b94aa4144349b11ab31c82296a5d804909c9$＃$ multiprocessingモジュールがそれを認識していなかったため、サブプロセスの作成を許可していました。

私の理解では、バージョン3.1より前のバグ（タスクはサブプロセスの作成を許可されていたため、孤立状態になる可能性がありました）があり、現在このバグは修正されています。

Pythonデーモンプロセスがフォークすることを許可しないという決定は、私にはかなり恣意的に思えます。 私はそれが誠実であることを認識していますが、必要に応じて、この動作を完全に制御できるはずだと感じています。

タスクごとに1つのプロセスにバインドされることは、私にとって深刻な制限のようです。 考え？

そもそもなぜその制限があるのだろうか、私には理解できる警告ですが、他の手段を使用してプロセスを完全にフォークできる場合、それを完全に禁止するのはばかげているようです。

@ask 、デーモンフラグがFalseの状態でセロリワーカープロセスを初期化することは可能でしょうか？ または、これを構成可能にしますか？

@ilyastamは同時にコメントしていたようです

それは恣意的な制限のように思われることに同意しますが、そもそもそれを追加する理由を知っていればいいのですが。

これはposixシステムでよく知られている落とし穴ですが、それでも許可されています。 シグナルハンドラで子プロセスをクリーンアップすることはできますが、SIGKILLから保護することはできません。

マルチプロセッシングの動作とは異なりますが、ビリヤードから制限を取り除く必要があると思います。 subpocessモジュールまたは低レベルのfork呼び出しを使用して子プロセスを作成できるため、パワーユーザーは子billiard.Processインスタンスを作成できるはずです。

@ilyastamは、raiseステートメントを削除できるはずです。プロセスを「非デーモン」にする必要はありません。

つまり、デーモンプロセスは、子プロセスを取得できない場合でも、子プロセスを作成できます。
とにかくposixがどのように機能するかです。

ところで、これはraiseではなく、assertステートメントであり、PythonがPYTHONOPTIMIZE envvarまたは-O引数で開始された場合に削除されることに注意してください。

ビリヤード3.3.0.11は、この変更を含めてPyPI上にあります

@askありがとうございます。 どのバージョンのセロリでこの改善が見られるか考えてみませんか？

multiprocessingドキュメントには、デーモンプロセスがサブプロセスを作成することは許可されていないことが明示されており、その理由が説明さこのassertステートメントは、 raiseショートカットとしてここに配置されたように見えます（多くの場合、そうします）。

この制限は文書化されており、Celeryがmultiprocessingを黙ってモンキーパッチして削除するのは良い考えではないと思います。 それは本当に予期せぬ有害な結果につながる可能性があります。

私は次の例を考えることができます（しかし、それは少し不自然に見えるかもしれません）：

@app.task
def f():
    p = multiprocessing.Pool(3)
    p.map_async(time.sleep, [1000, 1000, 1000])

プレーンなPython関数として実行されるため、このコードは正しく機能します。 ただし、Celeryタスクとして実行されると（Celeryバージョン3.0。*を使用）、3つのサブプロセスが残り、永久にハングします。 Celeryワーカーが終了すると、これらのサブプロセスは孤立します。

理由は説明されていません。子子プロセスを開始するときに予想されるUNIXの動作を示しているだけです。 それはUNIXの悪名高い制限ですが、それは人々がそれをするのを止めません。 これはと違いはありません
subprocess.Popenプロセスを開始するか、 fork()を呼び出して新しいプロセスを開始します。 では、なぜそれは違法なのですか？

あなたの例を行う方法：

from billiard import Pool
from multiprocessing.util import Finalize

_finalizers = []

@app.task
def f():
    p = billiard.Pool(3)
    _finalizers.append(Finalize(p, p.terminate))
   try:
       p.map_async(time.sleep, [1000, 1000, 1000])
       p.close()
       p.join()
   finally:
       p.terminate()

これを殺す（-9）には、子プロセスも-9殺す必要がありますが、それはあなたが持っているものです
すべてのUNIXプロセスについて検討します。

すべてのタスクにプールを作成することを推奨しているわけではありませんが、自分が何であるかを知っているユーザーがなぜかはわかりません
実行中、タスクからプロセスを開始することを許可されるべきではありません。

また、これはビリヤードのみの変更であるため、モンキーパッチは適用しません。

また、これはビリヤードのみの変更であるため、モンキーパッチは適用しません。

「モンキーパッチ」とは、 multiprocessing._current_processをbilliard.process.Processインスタンスに置き換えるこの割り当てを意味します： https ：

（あなたの例のように）正しく処理されれば、子子プロセスを開始することに何の問題もないことに同意します。 私のポイントは、 multiprocessingはそのように書かれておらず、その_実装_の制限を無視してはならないということです。

@aromanovich他の方法で書くことはできません。マルチプロセッシングの制限ではなく、UNIXの制限です。

ロギングモジュールのprocessName形式変数が機能するように_current_processを設定し、ビリヤードプロセスオブジェクトはマルチプロセッシングプロセスオブジェクトと同じAPIを持っているため、現在のプロセスを安全に設定できます。

ところで、制限を解除するにはビリヤードを使用する必要があります。マルチプロセッシングを使用すると、例外が発生します。

このアプローチを使用してこの問題を修正することもできます。
http://stackoverflow.com/questions/6974695/python-process-pool-non-daemonic
これにより、ユーザーはマルチプロセッシングモジュールを引き続き使用できるようになり、この問題を回避できます。
https://github.com/celery/billiard/issues/99

セロリタスク内から@parallelファブリックタスクを呼び出すと、このエラーが発生します。

@celery.task
def dostuff():
   execute(fabfile.push_settings, sid=site['sid'])

<strong i="7">@parallel</strong>
@roles(environment)
def push_settings(sid):
  #do stuff

@frodopwnsはENVを使用します
エクスポートPYTHONOPTIMIZE = 1
このアサートを削除します。 あなたはすべてのものを処理する必要があります。

@xiaods私はこの問題を次のようなもので解決したと思います：

@worker_process_init.connect
def configure_workers(sender=None, conf=None, **kwargs):
    Crypto.Random.atfork()

問題

いくつかのデータを計算し、scikit-learn分類子をロードして、そのデータに基づいて予測を行うタスクがあります。 タスクを単独で実行すると、すべて問題ありませんが、Celeryを使用してタスクを実行すると、タスクがpickle化された分類子を読み込もうとするとエラーが発生します。

[2015-07-17 21:23:51,299: ERROR/MainProcess] Task app.f[329d0da4-2e0e-4e1f-8148-d64f47750b1f] raised unexpected: AttributeError("'Worker' object has no attribute '_config'",)
Traceback (most recent call last):
  File "/home/username/anaconda3/lib/python3.4/site-packages/celery/app/trace.py", line 240, in trace_task
    R = retval = fun(*args, **kwargs)
  File "/home/username/anaconda3/lib/python3.4/site-packages/celery/app/trace.py", line 438, in __protected_call__
    return self.run(*args, **kwargs)
  File "/home/username/working/playground/celery/app.py", line 11, in f
    clf = pickle.load(open('clf.pickle', 'rb'))
  File "/home/username/anaconda3/lib/python3.4/site-packages/sklearn/ensemble/__init__.py", line 6, in <module>
    from .base import BaseEnsemble
  File "/home/username/anaconda3/lib/python3.4/site-packages/sklearn/ensemble/base.py", line 13, in <module>
    from ..externals.joblib import cpu_count
  File "/home/username/anaconda3/lib/python3.4/site-packages/sklearn/externals/joblib/__init__.py", line 112, in <module>
    from .parallel import Parallel
  File "/home/username/anaconda3/lib/python3.4/site-packages/sklearn/externals/joblib/parallel.py", line 23, in <module>
    from ._multiprocessing_helpers import mp
  File "/home/username/anaconda3/lib/python3.4/site-packages/sklearn/externals/joblib/_multiprocessing_helpers.py", line 25, in <module>
    _sem = mp.Semaphore()
  File "/home/username/anaconda3/lib/python3.4/multiprocessing/context.py", line 81, in Semaphore
    return Semaphore(value, ctx=self.get_context())
  File "/home/username/anaconda3/lib/python3.4/multiprocessing/synchronize.py", line 127, in __init__
    SemLock.__init__(self, SEMAPHORE, value, SEM_VALUE_MAX, ctx=ctx)
  File "/home/username/anaconda3/lib/python3.4/multiprocessing/synchronize.py", line 59, in __init__
    kind, value, maxvalue, self._make_name(),
  File "/home/username/anaconda3/lib/python3.4/multiprocessing/synchronize.py", line 117, in _make_name
    return '%s-%s' % (process.current_process()._config['semprefix'],
AttributeError: 'Worker' object has no attribute '_config'

再現するには

空の分類子を作成し、ピクルスとして保存します。

import pickle
from sklearn.ensemble import GradientBoostingClassifier
clf = GradientBoostingClassifier()
pickle.dump(clf, open('clf.pickle', 'wb'))

簡単なアプリを作成する（ app.py ）：

import pickle
import sklearn
from celery import Celery

app = Celery(__name__, broker='amqp://localhost//')

@app.task
def f():
    print('hello')
    clf = pickle.load(open('clf.pickle', 'rb'))
    print(clf)

セロリワーカーを開始します。

celery -A app worker --loglevel=debug

アプリを実行します。

python -c "from app import f; f.delay()"

エラーメッセージ：

...
AttributeError: 'Worker' object has no attribute '_config'

解決

特にそのような「機能」が過去に存在した場合、タスクがサブプロセスを開始できるようにするために、Celeryを「モンキーパッチ」するオプションがあるべきだと思います。 現在、人々はこの問題に遭遇したときに他のフレームワークに移動しているだけです： http ： http ：

この問題は再度開く必要があります...

私はちょうど同じ問題に遭遇しました。 ワーカーの1つでnltkを使用しているため、 scikit-learnがインポートされ、 @ ostrokachが示したのと同じエラーが発生します。

次のコードでこれを回避できるようです。

from celery.signals import worker_process_init

@worker_process_init.connect
def fix_multiprocessing(**kwargs):
    from multiprocessing import current_process
    try:
        current_process()._config
    except AttributeError:
        current_process()._config = {'semprefix': '/mp'}

これは明らかに非常に大雑把なハックであり、実際にマルチプロセッシングを使用するとどうなるかわかりません（ semprefixが何であるかさえわかりません）が、 scikit-learnを作成するには十分です。

この問題が修正されるまで同じ問題に遭遇する他の人々のために、これをここに残しておきます。

これは、Python 3のビリヤードとのある種の非互換性でしょうか？ それともPython2でも再現可能ですか？

セロリプロセスがサブプロセスを作成できないという元の問題はまだ問題ですか？ コメントを振り返ると、バージョン3.3billiard @ e6bb0f7で修正されました。 ただし、後のコミット（celery / billiard @ c7eedbd0ee1498e76d4fa1affac5b1a275660ee7）では、3.4のstartメソッドに非常によく似たassertステートメントが再導入されました。 3.3を使用しているので問題はありませんが、将来問題が発生する可能性があるかどうかを指摘したいと思います。

@martinthありがとう、このハックは私にも

@xiaodsありがとうございます！ あなたの解決策は私のために働きます！ ありがとう！

@gilinsonはまだ問題であり、PYTHONOPTIMIZE = 1をエクスポートしても「ちょっと修正」されます。
Celeryタスクでansibleplaybookを実行しようとして、同じ問題が発生しました

@martinthハックしてくれてありがとう！ 私は次の問題で同じ問題に直面しています：

• Python 3.4.3
• セロリ== 3.1.18
• scikit-learn == 0.17

@martinthのハックは私には

スレッドベースのmultiprocessing.dummyを使用すると、セロリで機能しました。

from multiprocessing.dummy import Pool

このエラーは、Python2.7.5でも引き続き発生します。 これに対処することを意図しているかどうかはわかりませんが、これにより、saltstackのsalt-sshをセロリで使用できなくなります。

このタスクを完了するためのリソースがないため、これを閉じます。

考えられる「解決策」

スレッドを作成しようとするようなタスクがありましたが、これは失敗します。 私はそれをうまく機能させることができました：それ自体が同じ正確なコードを実行するPythonインタープリターにフォークするbashスクリプトにフォークします（したがって、私のユースケースにとって重要なスレッドを作成できました）。

なぜチケットが閉まるのかわかりません。 そのためのリソースがない場合は、これについてコメントすることができますが、これはチケットを閉じません。 そうすることでバグを隠しているだけです。

これは、優先度と重大度の両方で「クリティカル」とラベル付けされたチケットにとって特に悪いことです。

@ orzel + 1。
優先度：クリティカル
重大度：重大
このタスクを完了するためのリソースがないため、これを閉じます。

それは冗談です。 現在リソースがない場合は、今すぐ修正しないでください。 リソースがあるときに修正してください。 チケットを閉じても問題は解決しません

@orzel @Templarrrこのチケットにクリティカルのラベルを付けたので、 @ askはここで責任を負いません。
あなたはこれに不満を持っているかもしれませんが、抗議することは役に立ちません。
何が実行可能で何が実行可能でないかに基づいてバックログをグルーミングする必要がありますが、現在はそうではありません。
それは難しい呼びかけですが、誰かがそれをしなければなりません。
この問題が邪魔になっている場合は、修正してみてください。 修正が正しく、適切なテストがあれば、それをマージすることを約束します。

@thedrow
あなたは誤解しました。 2回。
私たちの懸念は、あなたがリソースを持っていないということではありません（これは完全に理解でき、悲しいことに、自由ソフトウェアでは非常に一般的なケースです）。 私たちの懸念は、そのためにチケットが閉鎖されていることです。これはチケットの仕組みではありません。
私たちは「不幸」ではなく、ショックを受けています。

私もこれを閉じることに完全に同意しません。

これは確かにバグであることに私たちは皆同意できると思います。 そして、_definite_バグを閉じるのに十分なリソースがないのは確かに悲しいことですが、これは役に立ちません。 明日誰かが長く来て、未解決の問題を調べるためだけに「Celeryのいくつかのバグを修正しましょう」と考え、「まあ、ここで行う興味深い作業はありません...作業しましょう」と考えるかどうかは、おそらくわかりません。代わりに_OtherProject_で」。
さらに、この問題を閉じると、それを見つけるのが難しくなります。 Githubの使い方はわかりませんが、潜在的な問題を見つけたら、まず課題トラッカーで未解決の課題を検索します。 一般的には多くの議論があり、今のところ使用できる回避策（この場合のように）もありません。 私が_本当に_必死になった場合にのみ、私は閉じられた問題を調べ始めます。

これは「バックロググルーミング」ではなく、数の調整です。 使用するものを見る場合は、未解決の問題の数を確認しますが、常に星の数も確認します（セロリの場合はかなり多いです）。 パブリックアピールのためだけでなく、あなた自身のためにも、バグ数を少なくすることが望ましいことを理解しています。 正直なところ、「250の未解決の問題」を見るのは良い数字ではなく、圧倒されるように聞こえることを理解しています。

来月（または1年）にこれに取り組む人材がいない場合は、_これで問題ありません_。 閉じないでください。 クローズは、問題が発生した場合、または発生しないことが_絶対に明らか_である場合にのみ発生します。 ここでは両方とも当てはまりません。

「クリティカル」フラグを削除し、現在は処理できないが、リソースが利用可能な場合は処理する必要があるものには「延期」フラグを追加するだけです。

実際に問題を解決できるかどうかはわかりません。 UNIXの動作を変更することはできませんが、制限を解除するためにアップストリームにパッチを送信することはできますか？

Linuxにはプラットフォーム固有のソリューションがあるかもしれませんが、それは調査する必要があります。 それは誰もそれを修正するインセンティブを持たずに2年間開いているので、近くの機能で修正される可能性は低いです。

私は200以上の問題をクローズし、3万通をはるかに超える電子メールを既読としてマークしたので、それらのいくつかは論争の的になるはずであり、これらを再開する必要があるかもしれません。 私はそれを完全に期待していますが、それが唯一の既知のオプションである場合、たとえば欠陥の文書化を支援することによって、解決策にも貢献できれば素晴らしいと思います。

私たちは仕事に溢れ、リソースのない巨大なプロジェクトを運営しようとしています。 問題を優先順位付けしたり、すでに修正されている問題を特定したりすることはできません。

まあいいよ。 しかし、「セロリ労働者のためのコードを書くとマルチプロセッシングを使用できない」という事実は、少なくとも文書化できますか？ つまり...それを読まない人は常にいるでしょうが、少なくともあなたはそれを指差して「ほら、それは文書化されています。私たちはそれを変えることはできません。それに対処してください」と言うことができます。

私のやることリストは巨大です。今すぐgithubでドキュメントを直接編集できるので、次のような変更を簡単に投稿できます:(

私は問題を隠すためにこれをしません、私はそれが改善されるのを見たいという理由だけで人々を行動に移すためにこれをしています。

@ask djangoでセロリを使用してタスク内でマルチプロセッシングを適用できますか？
そうするための代替手段はありますか？

@abhisheksachanこのような質問を投稿する前に、この問題をすべて読む必要があります

@abhisheksachanここ数年は試していませんが、サブプロセスのデーモン化が可能であるため、 https： //pypi.python.org/pypi/billiardを使用して動作するようになりました。

ええ、あなたは「マルチプロセッシング」からのインポートを「ビリヤード」に置き換える必要があります、例えば：

from multiprocessing import Process

->

from billiard import Process

マルチプロセッシングの制限を無効にする方法はありませんが、マルチプロセッシングフォークで許可されるように、とにかく制限があるべきではないと主張します。

私のように、キューイングシステムの開発に投資してその制限を見つけ、より使いやすいrabbitMQ pythonラッパーに移行できるようになるまで別の回避策が必要な場合は、次のことができる外部サブプロセスを呼び出すことで問題を回避できました。自分自身をきれいにフォークします。 その分岐したプロセスは現在、セロリのサンドボックスの外にあり、正常に機能します。

OPの例では、次を置き換えます。

app = Celery(__name__, broker='amqp://192.168.33.40') 
@app.task
def f():
    manager = multiprocessing.Manager()

と：

app = Celery(__name__, broker='amqp://192.168.33.40')
@app.task
def f():
    process = subprocess.Popen(["program"]) # or the newer post 3.5 run version
    process.wait()
    # analyze exit code

「プログラム」は次のようになります（POSIX unix / linuxプラットフォームの下で）

import os

def main():
      manager = multiprocessing.Manager()

# this is equivalent to "(cmd )&" under bash
pid = os.fork()
if pid == 0:
    cpid = os.fork()
    if cpid == 0:
        main()
    else:
        exit(0)
else:
    os.wait(pid)

CPU管理は、セロリを使用するという考えに反するセロリの範囲を回避することを覚えておいてください。ただし、マルチプロセッシングを使用する場合は、とにかくセロリの外部でCPU使用率を処理する必要があります。

少なくとも、その制限を文書化する必要があります。 ドキュメントを見て回ったが見つかりませんでした。

繰り返しになりますが、ドキュメントを変更してプルリクエストを送信してください。

@martinthのコメント、Python 3.5.2、 Celery 4.0.0、およびビリヤード3.5.0のフォローアップでは、マルチプロセッシングがデーモン化されているプロセスをチェックし、子の起動を停止するため、彼のソリューションは機能しませんでした。

ワーカーのデーモンフラグをリセットすることで、制限を解除することができました。 それは悪い考えだと確信していますが、マルチプロセッシングを開始できます。セロリタスク内からプールします。

@worker_process_init.connect
def fix_multiprocessing(**kwargs):
    # don't be a daemon, so we can create new subprocesses
    from multiprocessing import current_process
    current_process().daemon = False

そうは言っても、IMHO Celeryは、ワーカーをデーモンとして開始するかどうかを構成するための文書化されたオプションを追加する必要があります。 k8ポッドでセロリを使用しているので、セロリはcelery workerを使用してフォアグラウンドプロセスとして開始され、デーモン化されたワーカーは必要ありません。

@miraculixxこの提案の問題は、処理するフェイルモードが増え、対処する問題が増えることです。 私たちはむしろそれらを避けたいと思います。

マルチプロセッシングをプリフォークプールと組み合わせて使用​​すると失敗しますが、ソロプールを使用すると機能するようです。 したがって、回避策は、プレフォークプールに複数の子を持つ1人ではなく、ソロプールで複数のセロリワーカーを生成することだと思います。 これは合法に聞こえますか？ もちろん、その方法では、max-mem-per-childなどの一部のオプションは機能しません。

これは基本的にアプリケーションの設計上の問題だと思います。 daemonic processes are not allowed to have children直面している特別な苦痛です。ご存知のとおり、アプリケーション全体を再設計しなければならない段階に達したからです。 しかし、これはOSレベルの制限であり、深刻な副作用なしに回避することはできません。 デーモンプロセスもCで子を持つことはできません。これはPython固有のものではありません。 以前はスレッドとプロセスのパフォーマンスについて議論がありましたが、結論として、どちらも他よりも大幅に優れている、または劣っていないことが判明しました。

私は2つのオプションを提案します（そしてここでセロリについてではなく、一般的に話します）

• subprocess.Popenを使用して、独立したプロセスを生成します。このプロセスは、子を持つことができ、プロセス間通信にUNIXソケットを使用できます。
• メインプロセスではなく、フォークされたプロセスによってスレッドが生成されることが本当に必要ですか？

価値のあることとして、当時の私のユースケースは、重要な（そしてセキュリティに敏感でない）入力の問題のためにすぐにクラッシュすることが多い、長時間実行されるサブプロセスを起動したかったというものでした。 したがって、アイデアは、少なくともプロセスが正常に起動することを確認することでした。

長期的には、さまざまな理由で設計が不十分であることが判明したため、新しいアーキテクチャは、非同期セロリワーカーの「自然な」使用に自然に戻りました。 ですから、フォークが本当に必要かどうかを質問するという考えに同意します。 タスクはフォークです。

私のユースケースは、マルチプロセッシングを使用するscikit-learnプロセスを（joblibを介して）起動することでした。 それ以来、joblibへのセロリバックエンドを開発しました。これは、scikit-learnがセロリを使用して並列プロセスを起動することを意味し、上記のハックは不要になりました。 これはPOCの段階にあり、まだプライムタイムの準備ができていません。

@miraculixxこれはどこかでホストされていますか？ 見てみたい、試してみたいです。 私はあなたと同じ問題に直面しています-sklearnスポーンサブプロセス-そして私は基本的にCeleryをあきらめました。

@pgeez sklearnでサブプロセスを使用する必要がない場合は、環境変数JOBLIB_MULTIPROCESSING = 0を設定できます。 https://github.com/scikit-learn/scikit-learn/blob/0.18.X/sklearn/externals/joblib/_multiprocessing_helpers.pyを参照して

思考のための@jennaliuは感謝、しかし@miraculixxのように、私は有効にマルチプロセッシング必要です。

セロリのデーモンプロセスから子供を勘当するために、古いUnixダブルフォークトリックを試したことがありますか？

このスレッドのタイトルを読みましたか？！？！？

@sebastroy明らかに、私はこのスレッドを何年もフォローしています。 ダブルフォークを発見したばかりですが、デーモンフォークがセロリによって殺されているのではなく、完全に阻止されているのではないかと混乱していることがわかりました。

ガッチャ。 ええ、前世ではCを使っていたので、これはパンとバターのようでした。

私が使用している回避策はsubprocess.Popenです。これは正常に機能しますが、セロリが最初に実行する必要があるロジックを再実装する（そしてプログラムのシェルバージョンを作成する）必要があります。 しかし、トップレベルのAPI実装の動作を変更することで修正しました。 セロリの目的に合っていると思います。 低レベルよりもいくつかのロジックを単純化します。

幸い、Celeryタスクでansibleプレイブックを実行しようとすると、この問題が発生します。
@martinthによって提供されたいきませんでした。 current_process()._configを印刷して、
{'authkey': b"y&e\x8d'\xcb\xd4\r\xd2\x86\x06\xe7\x9e\x14\xaf \xbc\xc4\x95\xa5G\xec&[i\x19\xf3G-\x06\xac\x19", 'semprefix': '/mp', 'daemon': True} 。
次に、フィールドdaemonをFalseに再割り当てすると、機能します。

タスクでマルチプロセスを実行できるようにするソリューションやその他の実装はありますか？

@HeartUnchange ：最近、分散コンポーネントとしてセロリを使用したいというビッグデータプロジェクトに取り組んでいます。 そしてあなたのガイドと一緒に、私たちは問題を解決することができてとても幸運です。 タスク構成を参照してください。

     @app.task
    def handleBigZipfile(filename,nid):
    current_process()._config['daemon'] = False
    logger.info('{} begin handle!'.format(filename))
    handleAll(filename,nid)
     logger.info('{} is done!'.format(filename))

解決策は大丈夫です！ 2017.1からプロジェクトを開始し、プロトタイプが完成しました。 9ヶ月が経ちました！ 私はあなたに感謝します！ そして私の感謝は表現を超えています！
問題をどのように理解するかについて詳しく説明してください。 私たちはそれを知りたがっています！

こんにちは 、

私はかなり標準的な設定をしています：Django + Rabbitmq + celery-4.0.2 + python-2.7 + centOS-7

セロリで標準のPythonマルチプロセッシングモジュールを使用してプロセスを生成しようとしています。

デーモンプロセスは子プロセスを作成することを許可されておらず、その結果、マルチプロセッシングパッケージを使用するタスクは機能していません。
実行に使用されるコマンド：celery worker -B -A celery_task -l debug
トレースバックログ：

[2017-09-26 23:27:08,838: WARNING/PoolWorker-2] ERROR
[2017-09-26 23:27:08,839: WARNING/PoolWorker-2] Traceback (most recent call last):
[2017-09-26 23:27:08,839: WARNING/PoolWorker-2] File "/home/induser/config.py", line 612, in main
[2017-09-26 23:27:08,840: WARNING/PoolWorker-2] mylog_process = mp.Process(target=test_logger_process, args=(myqueue,))
[2017-09-26 23:27:08,840: WARNING/PoolWorker-2] File "/usr/lib64/python2.7/multiprocessing/process.py", line 98, in __init__
[2017-09-26 23:27:08,841: WARNING/PoolWorker-2] self._authkey = _current_process._authkey
[2017-09-26 23:27:08,841: WARNING/PoolWorker-2] AttributeError: 'Process' object has no attribute '_authkey'

プロセスを生成しない理由は何でしょうか？
コードは次のとおりです。

import multiprocessing as mp
from celery.schedules import crontab
from celery.decorators import periodic_task

@periodic_task(run_every=crontab(minute='*/1'), name='test_process_celery')
def main():
data = config_read()
try:
    myqueue = mp.Queue(-1)
    mylog_process = mp.Process(target=test_logger_process, args=(myqueue,))
    mylog_process.start()
    . . .
    . . .
except Exception as e:
    raise
finally:
    mylog_process.join()

ありがとうございます。

それでも問題がある場合は、マスターを試して報告してください

まだエラーがあります。 私は次のサブプロセスを使用しようとしました：

from multiprocessing import Process, Value
import ctypes

[...]
        result = Value('i', 0)
        text = Value(ctypes.c_char_p, fail_string.encode())
        p = Process(target=reader.find_text_async, args=(result, text, ))
        p.start()
        p.join(5)

        if p.is_alive():
            logging.WARNING("Manual terminating the process 'find_text_async'")
            p.terminate()

しかし、セロリマスターブランチでは、次のように述べています。

ファイル "/usr/lib/python3.5/multiprocessing/process.py"、行103、開始時
「デーモンプロセスは子を持つことを許可されていません」
AssertionError：デーモンプロセスに子を含めることは許可されていません

編集

ビリヤードでマルチプロセッシングを変更しましたが、動作します！

from billiard import Process, Value