限制python多处理中的总CPU使用率(Limit total CPU usage in python multiprocessing)

 这完全属于如何处理子程序中的错误的问题。 
 
 对此进行了很好的讨论，但我现在找不到这些帖子。 
 
 原则上，这些是处理子例程中的错误的方法 
 
 
 
 返回码，其中一些表示错误 
 
 
 返回“特殊”值，如Perl中的undef 
 
 
 抛出异常，Perl中的设备就会die 
 
 
 调用者要么检查返回，要么测试undef ，或使用eval来捕获和处理die 。 什么是最合适的完全取决于上下文和代码的作用。 
 
 我认为在现代语言中没有太多理由限制指示错误的“代码”（如负值）。 首先，要么干涉合法的回报，要么限制它们通过指针/引用，这是一个重大的设计决定。 
 
 返回undef通常是一种很好的中途方法，特别是在代码不太复杂的情况下。 它表示sub的某些“失败”，以执行它的意图。 然而，即使在最小的子中， undef也可能适合于表示不可接受的结果 。 然后，如果它也用于输入错误，我们就有区分这些错误的问题。 
 
 在简单die上使用Perl抛出异常会增加更多可能性。 在复杂的代码中，您可能希望编写（或使用）一个错误处理类，该类模仿具有它的语言的异常处理支持，然后抛出它。 
 
my $error_obj = ErrorHandlingClass->new( params );

... or die $error_obj;
 
 然后调用代码可以分析对象。 这将是最有条理的方式。 
 
 一个很好的简单例子是Path :: Tiny ，它的源代码中有自己的Path::Tiny::Error 。 
 
 同样，在任何一种特定情况下适用的内容取决于该应用的细节。 
 
 
 关于直接问题的一些评论。 
 
 die的无信息消息强调了返回什么的困境（它告诉我们什么都失败了）。 但在这种情况下，我们如何使失败提供信息？ 
 
 请注意，如果sub返回0或空字符串，则表示or导致die 。 如果我们用// （defined-or）替换它，那么在undef上die ，如果undef也可能表示结果不好，我们仍然无法打印特定的消息。 
 
 因此，在这种情况下，您可能希望函数在输入错误时使用合适的消息。 
 
 这样做可以进行调试。 如果代码需要能够恢复，那么您最好返回更多结构化信息 - 抛出（或返回）您编写的错误处理类的对象。 （作为一种临时的止损措施，你可以解析die的信息。） 
 
 至于古老的纪律检查问题， die是一个很好的工具。 没有“ 简单的子 ”是不值得的 - 你不想继续犯错误，所以die也没关系。 在复杂的项目中，错误处理更复杂，因此我们需要更多的工具和结构，而不是更少。 
 
 回想一下异常“冒泡”，如果未处理则向上传播调用堆栈，并且die也是如此。 这可以很好地用于调试，而不需要每次调用都有eval 。 最后，大部分都是调试的一部分。 
 
 这没有“最佳实践”。 但缺席的die至少是合理的。 

This falls squarely under the question of how to deal with errors in subroutines in general.
 
There have been good discussions on this but I just can't find those posts now. 
 
In principle, these are ways to handle errors in subroutines
 
 
 
return codes, some of which indicate errors
 
 
return "special" values, like undef in Perl
 
 
throw exceptions, and a device for that in Perl is die
 
 
The caller either checks the return, or tests for undef, or uses eval to catch and handle the die. What is most suitable depends entirely on the context and on what the code does.
 
I don't see much reason in modern languages to be restrained to "codes" (like negative values) that indicate errors. For one thing, that either interferes will legitimate returns or it constrains them to go via pointer/reference, which is a big design decision.
 
Returning undef is often a good middle-of-the-road approach, in particular in code that isn't overly complex. It indicates some "failure" of the sub to perform what it is meant to. However, even in the smallest of subs undef may be suitable to indicate a result that isn't acceptable. Then if it is also used for bad input we have a problem of distinguishing between those errors.
 
Throwing an exception, based in Perl on the simple die, adds more possibilities. In complex code you may well want to write (or use) an error-handling class that mimics exception handling support from languages that have it, and then throw that.
 
my $error_obj = ErrorHandlingClass->new( params );

... or die $error_obj;
 
Then the calling code can analyze the object. This would be the most structured way to do it. 
 
A nice and simple example is Path::Tiny, with its own Path::Tiny::Error found in its source.
 
Again, what is suitable in any one particular case depends on details of that application.
 
 
A few comments on direct questions.
 
The dilemma of what to return is stressed by the information-free message in die (it tells us nothing of what failed). But how do we make the failure informative, in this case? 
 
Note that your or results in a die if the sub returns 0 or an empty string. If we replace it with // (defined-or), so to die on undef, we still can't print a specific message if undef may also indicate a bad result. 
 
So in this case you may want the function to die on bad input, with a suitable message.
 
That would do it for debugging after there's been a problem. If the code needs to be able to recover then you'd better return more structured information -- throw (or return) an object of an error handling class you'd write. (As an ad hoc stop-gap measure you can parse the message from die.)
 
As for the age-old question of discipline to check returns, a die is a good tool. There is no "simple sub" that is unworthy – you do not want to proceed with an error so it's OK to die. And in complex projects error handling is more complex, so we need more tools and structure, not less. 
 
Recall that exceptions "bubble up", propagate up the call stack if unhandled, and so does die. This can be used nicely for debugging without having eval on every single call. In the end, most of this is a part of debugging.
 
There is no "best practice" for this. But a default of die-ing is rather reasonable.