external/srs
1
0
Fork 0
mirror of https://github.com/ossrs/srs.git synced 2025-03-09 15:49:59 +00:00
Code Issues Releases Wiki Activity

add comments for srs thread, add never quit thread.

Browse source
This commit is contained in:
winlin 2015-05-22 12:10:06 +08:00
parent 948d200ce1
commit 6f8c076b30
1 changed files with 99 additions and 87 deletions
Download patch file Download diff file Expand all files Collapse all files

186
trunk/src/app/srs_app_thread.hpp
View file

@ -32,93 +32,105 @@ CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
#include <srs_app_st.hpp> #include <srs_app_st.hpp>
/** /**
* the handler for the thread, callback interface. * the handler for the thread, callback interface.
* the thread model defines as: * the thread model defines as:
* handler->on_thread_start() * handler->on_thread_start()
* while loop: * while loop:
* handler->on_before_cycle() * handler->on_before_cycle()
* handler->cycle() * handler->cycle()
* handler->on_end_cycle() * handler->on_end_cycle()
* if !loop then break for user stop thread. * if !loop then break for user stop thread.
* sleep(CycleIntervalMilliseconds) * sleep(CycleIntervalMilliseconds)
* handler->on_thread_stop() * handler->on_thread_stop()
* when stop, the thread will interrupt the st_thread, * when stop, the thread will interrupt the st_thread,
* which will cause the socket to return error and * which will cause the socket to return error and
* terminate the cycle thread. * terminate the cycle thread.
* *
* Usage 1: stop by other thread. * Usage 1: loop thread never quit.
* user can create thread and stop then start again and again, * user can create thread always running util server terminate.
* generally must provides a start and stop method, @see SrsIngester. * the step to create a thread never stop:
* the step to create a thread stop by other thread: * 1. create SrsThread field, with joinable false.
* 1. create SrsThread field, with joinable true. * for example:
* 2. must use stop to stop and join the thread. * class SrsStreamCache : public ISrsThreadHandler {
* for example: * public: SrsStreamCache() { pthread = new SrsThread("http-stream", this, SRS_AUTO_STREAM_SLEEP_US, false); }
* class SrsIngester : public ISrsThreadHandler { * public: virtual int cycle() {
* public: SrsIngester() { pthread = new SrsThread("ingest", this, SRS_AUTO_INGESTER_SLEEP_US, true); } * // check status, start ffmpeg when stopped.
* public: virtual int start() { return pthread->start(); } * }
* public: virtual void stop() { pthread->stop(); } * }
* public: virtual int cycle() { *
* // check status, start ffmpeg when stopped. * Usage 2: stop by other thread.
* } * user can create thread and stop then start again and again,
* }; * generally must provides a start and stop method, @see SrsIngester.
* * the step to create a thread stop by other thread:
* Usage 2: stop by thread itself. * 1. create SrsThread field, with joinable true.
* user can create thread which stop itself, * 2. must use stop to stop and join the thread.
* generally only need to provides a start method, * for example:
* the object will destroy itself then terminate the thread, @see SrsConnection * class SrsIngester : public ISrsThreadHandler {
* 1. create SrsThread field, with joinable false. * public: SrsIngester() { pthread = new SrsThread("ingest", this, SRS_AUTO_INGESTER_SLEEP_US, true); }
* 2. owner stop thread loop, destroy itself when thread stop. * public: virtual int start() { return pthread->start(); }
* for example: * public: virtual void stop() { pthread->stop(); }
* class SrsConnection : public ISrsThreadHandler { * public: virtual int cycle() {
* public: SrsConnection() { pthread = new SrsThread("conn", this, 0, false); } * // check status, start ffmpeg when stopped.
* public: virtual int start() { return pthread->start(); } * }
* public: virtual int cycle() { * };
* // serve client. *
* // set loop to stop to quit, stop thread itself. * Usage 3: stop by thread itself.
* pthread->stop_loop(); * user can create thread which stop itself,
* } * generally only need to provides a start method,
* public: virtual int on_thread_stop() { * the object will destroy itself then terminate the thread, @see SrsConnection
* // remove the connection in thread itself. * 1. create SrsThread field, with joinable false.
* server->remove(this); * 2. owner stop thread loop, destroy itself when thread stop.
* } * for example:
* }; * class SrsConnection : public ISrsThreadHandler {
* * public: SrsConnection() { pthread = new SrsThread("conn", this, 0, false); }
* Usage 3: loop in the cycle method. * public: virtual int start() { return pthread->start(); }
* user can use loop code in the cycle method, @see SrsForwarder * public: virtual int cycle() {
* 1. create SrsThread field, with or without joinable is ok. * // serve client.
* 2. loop code in cycle method, check the can_loop() for thread to quit. * // set loop to stop to quit, stop thread itself.
* for example: * pthread->stop_loop();
* class SrsForwarder : public ISrsThreadHandler { * }
* public: virtual int cycle() { * public: virtual int on_thread_stop() {
* while (pthread->can_loop()) { * // remove the connection in thread itself.
* // read msgs from queue and forward to server. * server->remove(this);
* } * }
* } * };
* }; *
* * Usage 4: loop in the cycle method.
* @remark why should check can_loop() in cycle method? * user can use loop code in the cycle method, @see SrsForwarder
* when thread interrupt, the socket maybe not got EINT, * 1. create SrsThread field, with or without joinable is ok.
* espectially on st_usleep(), so the cycle must check the loop, * 2. loop code in cycle method, check the can_loop() for thread to quit.
* when handler->cycle() has loop itself, for example: * for example:
* while (true): * class SrsForwarder : public ISrsThreadHandler {
* if (read_from_socket(skt) < 0) break; * public: virtual int cycle() {
* if thread stop when read_from_socket, it's ok, the loop will break, * while (pthread->can_loop()) {
* but when thread stop interrupt the s_usleep(0), then the loop is * // read msgs from queue and forward to server.
* death loop. * }
* in a word, the handler->cycle() must: * }
* while (pthread->can_loop()): * };
* if (read_from_socket(skt) < 0) break; *
* check the loop, then it works. * @remark why should check can_loop() in cycle method?
* * when thread interrupt, the socket maybe not got EINT,
* @remark why should use stop_loop() to terminate thread in itself? * espectially on st_usleep(), so the cycle must check the loop,
* in the thread itself, that is the cycle method, * when handler->cycle() has loop itself, for example:
* if itself want to terminate the thread, should never use stop(), * while (true):
* but use stop_loop() to set the loop to false and terminate normally. * if (read_from_socket(skt) < 0) break;
* * if thread stop when read_from_socket, it's ok, the loop will break,
* @remark when should set the interval_us, and when not? * but when thread stop interrupt the s_usleep(0), then the loop is
* the cycle will invoke util cannot loop, eventhough the return code of cycle is error, * death loop.
* so the interval_us used to sleep for each cycle. * in a word, the handler->cycle() must:
*/ * while (pthread->can_loop()):
* if (read_from_socket(skt) < 0) break;
* check the loop, then it works.
*
* @remark why should use stop_loop() to terminate thread in itself?
* in the thread itself, that is the cycle method,
* if itself want to terminate the thread, should never use stop(),
* but use stop_loop() to set the loop to false and terminate normally.
*
* @remark when should set the interval_us, and when not?
* the cycle will invoke util cannot loop, eventhough the return code of cycle is error,
* so the interval_us used to sleep for each cycle.
*/
class ISrsThreadHandler class ISrsThreadHandler
{ {
public: public: