pthread_resume_np(3) [netbsd man page]

PTHREAD_SUSPEND_NP(3)					   BSD Library Functions Manual 				     PTHREAD_SUSPEND_NP(3)

NAME

     pthread_suspend_np, pthread_resume_np -- suspend/resume the given thread

LIBRARY

     POSIX Threads Library (libpthread, -lpthread)

SYNOPSIS

     #include <pthread.h>

     int
     pthread_suspend_np(pthread_t thread);

     int
     pthread_resume_np(pthread_t thread);

DESCRIPTION

     The pthread_suspend_np() function suspends the thread given as argument.  If thread is the currently running thread as returned by
     pthread_self(3), the function fails and returns EDEADLK.  Otherwise, it removes the named thread from the running queue, and adds it to the
     suspended queue.  The thread will remain blocked until pthread_resume_np() is called on it.  In other words, pthread_resume_np() resumes the
     thread given as argument, if it was suspended.

RETURN VALUES

     Both functions return 0 on success and an error number indicating the reason for the failure.

COMPATIBILITY

     These functions are non-standard extensions.

ERRORS

     The pthread_suspend_np() function may fail if:

     [EDEADLK]		The thread requested to suspend was the currently running thread.

     [ESRCH]		The supplied thread was invalid.

     The pthread_resume_np() function may fail if:

     [ESRCH]		The supplied thread was invalid.

NOTES

     Some pthread_suspend_np() implementations may allow suspending the current thread.  This is dangerous, because the semantics of the function
     would then require the scheduler to schedule another thread, causing a thread context switch.  Since that context switch can happen in a sig-
     nal handler by someone calling pthread_suspend_np() in a signal handler, this is currently not allowed.

     In pthread_resume_np() the NetBSD implementation does not check if the thread argument is not already suspended.  Some implementations might
     return an error condition if pthread_resume_np() is called on a non-suspended thread.

SEE ALSO

     pthread_attr_setcreatesuspend_np(3), pthread_self(3)

BSD
								   July 9, 2010 							       BSD

pthread_resume_np(3T)													     pthread_resume_np(3T)

NAME

       pthread_resume_np(), pthread_continue(), pthread_suspend() - resume execution of a thread, continue execution of a thread, and suspend exe-
       cution of a thread

SYNOPSIS

PARAMETERS

	      thread	whose execution is to be suspended or resumed.

	      flags	Flags to be used by The valid values are:

			The target thread's suspension count is decremented by one. If the target
			       thread was suspended and has a suspend count greater than one, the thread will not resume execution.

			The target thread's suspension count is set to zero. The target
			       will resume execution even if its suspend count was greater than one.

DESCRIPTION

       The function suspends execution of the target thread specified by thread.  The target thread may not  be  suspended  immediately  (at  that
       exact  instant).  On successful return from the function, thread is no longer executing. Once a thread has been suspended, subsequent calls
       to the function increment a per thread suspension count and return immediately.

       Calling with the calling thread specified in thread is allowed.	Note that in this case the calling thread shall be suspended during execu-
       tion of the function call and shall only return after another thread has called the or function for thread.

       The  function resumes the execution of the target thread thread.  If thread was suspended by multiple calls to only one call to is required
       to resume the execution of thread.  Calling for a target thread that is not suspended shall have no effect and return no  errors.   Calling
       is equivalent to calling with the flags parameter specified as

       The function resumes the execution of the target thread specified by thread.  If the flags argument is the target thread's suspension count
       is decremented by one. If the flags argument is the target thread's suspension count is set to zero. When the  target  thread's	suspension
       count  reaches  zero,  the  target thread is allowed to continue execution. Calling for a target thread that is not suspended shall have no
       effect and return no errors.

WARNING

       This warning is applicable if any of the following conditions is true for a threaded application:

       a.  The or environment variable is set to either or

       b.  The application's binary is brought forward from a HP-UX 11i v1 release.

       In either of the above conditions, it is strongly recommended to set the environment variable to if the application uses which is not POSIX
       compliant.  Failing to do so, can lead to undefined behavior.

RETURN VALUE

       If successful, and return zero. Otherwise, an error number shall be returned to indicate the error (the variable is not set).

ERRORS

       If any of the following occur, the function returns the corresponding error number.

	      [ESRCH]	     The target thread thread is not in the current process.

	      [EDEADLK]      The  target  thread thread is the last running thread in the process.  The operation would result in deadlock for the
			     process.

       If any of the following occur, the and functions return the corresponding error number.

	      [ESRCH]	     The target thread thread is not in the current process.

	      [EINVAL]	     The value specified by flags is invalid.

APPLICATION USAGE

       This functionality enables a process that is multithreaded to temporarily suspend all activity to a single thread  of  control.	 When  the
       process	is  single  threaded, the address space is not changing, and a consistent view of the process can be gathered.	One example of its
       use is for garbage collecting.  The garbage collector runs asynchronously within the process and assumes that the process is  not  changing
       while it is running.

       Suspending  a  thread  may  have  adverse effects on an application. If a thread is suspended while it holds a critical resource, such as a
       mutex or a read-write lock, the application may stop or even deadlock until the thread is continued. While the thread is  suspended,  other
       threads	which may contend for the same resource must block until the thread is continued. Depending on application behavior, this may even
       result in deadlock. Application programmers are advised to either a) only suspend threads which call  async-signal  safe  functions  or	b)
       ensure that the suspending thread does not contend for the same resources that the suspended thread may have acquired.  Note: this includes
       resources that may be acquired by libraries.

       The and functions cannot reliably be used for thread synchronization.  Synchronization  primitives  like  mutexes,  semaphores,	read-write
       locks, and condition variables should be used instead.

AUTHOR

       and were developed by X/Open.

       was developed by HP.

SEE ALSO

       pthread_create(3T).

STANDARDS CONFORMANCE

								  Pthread Library					     pthread_resume_np(3T)