From: RĂ©mi Denis-Courmont Date: Sat, 1 Aug 2009 20:59:41 +0000 (+0300) Subject: vlc_detach: releases a thread handle asynchronously X-Git-Tag: 1.1.0-ff~4626 X-Git-Url: https://git.sesse.net/?a=commitdiff_plain;h=6cecd8ecf80090d4818c5aa4a9e9f00d15d982c2;p=vlc vlc_detach: releases a thread handle asynchronously Note that this can only be used safely in the core. In a plug-in, it would introduce a race whereby dlclose() unmaps the code segment that a detached thread is running (this was discussed over a year ago). For that, we'd need something a bit more involved along the lines of Win32's FreeLibraryAndExitThread(). --- diff --git a/src/libvlc.h b/src/libvlc.h index 15a8d2150f..3d15f9560e 100644 --- a/src/libvlc.h +++ b/src/libvlc.h @@ -58,6 +58,9 @@ vlc_list_t *vlc_list_find( vlc_object_t *, int, int ); * Threads subsystem */ +/* This cannot be used as is from plugins: */ +void vlc_detach (vlc_thread_t); + /* Hopefully, no need to export this. There is a new thread API instead. */ void vlc_thread_cancel (vlc_object_t *); int vlc_object_waitpipe (vlc_object_t *obj); diff --git a/src/misc/pthread.c b/src/misc/pthread.c index 068cfa8fa7..d3f1dbd1e8 100644 --- a/src/misc/pthread.c +++ b/src/misc/pthread.c @@ -589,10 +589,10 @@ void vlc_cancel (vlc_thread_t thread_id) * occur. * @warning * A thread cannot join itself (normally VLC will abort if this is attempted). + * Also, a detached thread cannot be joined. * * @param handle thread handle * @param p_result [OUT] pointer to write the thread return value or NULL - * @return 0 on success, a standard error code otherwise. */ void vlc_join (vlc_thread_t handle, void **result) { @@ -600,6 +600,28 @@ void vlc_join (vlc_thread_t handle, void **result) VLC_THREAD_ASSERT ("joining thread"); } +/** + * Detaches a thread. When the specified thread completes, it will be + * automatically destroyed (in particular, its stack will be reclaimed), + * instead of waiting for another thread to call vlc_join(). If the thread has + * already completed, it will be destroyed immediately. + * + * When a thread performs some work asynchronously and may complete much + * earlier than it can be joined, detaching the thread can save memory. + * However, care must be taken that any resources used by a detached thread + * remains valid until the thread completes. This will typically involve some + * kind of thread-safe signaling. + * + * A thread may detach itself. + * + * @param handle thread handle + */ +void vlc_detach (vlc_thread_t handle) +{ + int val = pthread_detach (handle); + VLC_THREAD_ASSERT ("detaching thread"); +} + /** * Save the current cancellation state (enabled or disabled), then disable * cancellation for the calling thread. diff --git a/src/misc/w32thread.c b/src/misc/w32thread.c index bf806f9cd0..5b337e4f70 100644 --- a/src/misc/w32thread.c +++ b/src/misc/w32thread.c @@ -497,6 +497,10 @@ void vlc_join (vlc_thread_t handle, void **result) #endif } +void vlc_detach (vlc_thread_t handle) +{ + CloseHandle (handle); +} /*** Thread cancellation ***/