int pthread_cancel(pthread_t thread);
The pthread_cancel() function shall request that thread be canceled. The target thread's cancelability state and type determines when the cancellation takes effect. When the cancellation is acted on, the cancellation cleanup handlers for thread shall be called. When the last cancellation cleanup handler returns, the thread-specific data destructor functions shall be called for thread. When the last destructor function returns, thread shall be terminated. The cancellation processing in the target thread shall run asynchronously with respect to the calling thread returning from pthread_cancel().
int pthread_setcancelstate(int state, int *oldstate);
int pthread_setcanceltype(int type, int *oldtype);
void pthread_testcancel(void);
The pthread_setcancelstate() function shall atomically both set the calling thread's cancelability state to the indicated state and return the previous cancelability state at the location referenced by old-state. Legal values for state are PTHREAD_CANCEL_ENABLE and PTHREAD_CANCEL_DISABLE.
Thepthread_setcanceltype() function shall atomically both set the calling thread's cancelability type to the indicated type and return the previous cancelability type at the location referenced by oldtype. Legal values fortype are PTHREAD_CANCEL_DEFERRED andPTHREAD_CANCEL_ASYNCHRONOUS.
The cancelability state and type of any newly created threads, including the thread in which main() was first invoked, shall be PTHREAD_CANCEL_ENABLE and PTHREAD_CANCEL_DEFERRED respectively.
The pthread_testcancel() function shall create a cancellation point in the calling thread. The pthread_testcancel() function shall have no effect if cancelability isdisabled.
The pthread_setcancelstate() and pthread_setcanceltype() functions control the points at which a thread may be asynchronously canceled. For cancellation control to be usable in modular fashion, some rules need to be followed.(These rule is not very useful!)
An object can be considered to be a generalization of a procedure. It is a set of procedures and global variableswritten as a unit and called by clients not known by the object. Objects maydepend on other objects.(Where an object means a pieceof code, functions is an example.)
First, cancelability should only be explicitly enable/disabled on entryto an object, in other word, never change the cancelability during a procedure.On exit from an object, the cancelability state should always be restored toits value on entry to the object.
This followsfrom a modularity argument: if the client of an object (or the client of anobject that uses that object) has disabled cancelability, it is because theclient does not want to be concerned about cleaning up if the thread iscanceled while executing some sequence of actions. If an object is called insuch a state and it enables cancelability and a cancellation request is pendingfor that thread, then the thread is canceled, contrary to the wish of theclient that disabled.
Second, the cancelability type may be explicitly set to either deferredor asynchronous upon entry to an object. But as with the cancelability state,on exit from an object the cancelability type should always be restored to itsvalue on entry to the object.
Finally, only functions that are cancel-safe may be called from a threadthat is asynchronously cancelable. All most functions are not cancel-safe!
NOTE:
1) pthread_setcancelstate() and pthread_setcanceltype() only can change the calling thread(current thread)’s state and type, not effect other thread’s state and type, include other new created threads!
2) pthread_setcancelstate() and pthread_setcanceltype() should be called in the beginning of thread function.
3) Don’t need to restore the cancellation state/type in the end of thread function, because other thread has itself state/type.
void pthread_cleanup_pop(int execute);
void pthread_cleanup_push(void (*routine)(void*), void *arg);
The pthread_cleanup_pop() function shall remove the routine at the top of the calling thread's cancellation cleanup stack and optionally invoke it (if execute is non-zero).
The pthread_cleanup_push() function shall push the specified cancellation cleanup handler routine onto the calling thread's cancellation cleanup stack. The cancellation cleanup handler shall be popped from the cancellation cleanup stack and invoked with the argument arg when:
* The thread exits(that is, calls pthread_exit()).
* The thread actsupon a cancellation request.
* The thread calls pthread_cleanup_pop()with a non-zero execute argument.
There isno notion of a cancellation cleanup-safe function. Ifan application 1) has no cancellation points in its signal handlers, 2) blocksany signal whose handler may have cancellation points while calling async-unsafefunctions, or 3) disables cancellation while calling async-unsafe functions,all functions may be safely called from cancellation cleanup routines.
NOTE:
1) Every thread has itself cancellation cleanup stack!
2) Cancellation request means: DEFERRED or ASYNCHRONOUS request!
3) Under Linux, pthread_cleanup_push and pthread_cleanup_popshould be pair used, or compiler error pop-up!
int pthread_join(pthread_t thread, void **value_ptr);
int pthread_detach(pthread_t thread);
The pthread_join() function provides a simple mechanism allowing an application towait for a thread to terminate. After the thread terminates, the application may then choose to clean up resources that were used by the thread. Forinstance, after pthread_join() returns, any application-provided stack storagecould be reclaimed.
The pthread_join() or pthread_detach() function should eventually be called for every thread that is created with the detach state attribute set to PTHREAD_CREATE_JOINABLE so that storage associated with the thread may be reclaimed.
The interaction between pthread_join() and cancellation is well-defined for the following reasons:
* The pthread_join() function, like all other non-async-cancel-safe functions, can only be called with deferred cancelability type.
* Cancellation cannot occur in the disabled cancelability state.
The pthread_detach() function shall indicate to the implementation that storage for the thread thread can be reclaimed when that thread terminates. If thread has not terminated, pthread_detach() shall not cause it to terminate. The effect of multiple pthread_detach() calls on the same target thread is unspecified.
---------------------------------------------------
兄弟的公司：立即购--手机购物，诚信网购
兄弟的公司：立即团
欢迎转载，请注明作者和出处