Soeren Sandmann wrote:
this is not quite correct. g_idle/g_timeout functions are called outside the gdk global lock, and so if you use gtk or gdk in a timeout function, you _must_ enclose such calls in gdk_threads_enter/leave() pairs. now, as above, if only the main thread is touching the GUI, you don't need to worry about it. but if, if you're only making gdk/gtk calls from the main thread or in g_idle/g_timeout callbacks (assuming you have _only one_ main loop in the main thread), then you should be ok.Tiago Cogumbreiro <cogumbreiro linus uac pt> writes:Are g_{idle,timeout}_add add thread safe? Can i call them from another problems with no problems whatsoever? I'm am routing all my gui related tasks to these functions and therefore skiping the gdk lock, is this an acceptable procedure?Yes, calling g_idle/timeout_add from another thread is perfectly legal. Those functions will do their own locking, so gdk_threads_enter/leave() are no not needed. And yes, routing all gui related tasks though those functions is acceptable and what I'd usually recommend for using threads with GTK+.
now, on the contrary, glib itself _is_ thread-safe, so the simple act of calling g_idle_add() or g_timeout_add() in a 2nd thread won't cause problems without locking. it's just if you're doing GUI stuff in more than one thread and in the timeout/idle functions, then you need to do the gdk_threads_* stuff in the idle/timeout function.
to summarise: * glib itself (e.g., the main loop) is totally thread-safe * gtk signal callbacks are called inside the gdk lock* g_idle/g_timeout callbacks are called _outside_ the gdk lock, and so gdk_threads_enter/leave() pairs are required if:
- you call gdk/gtk functions in the timeout/idle function - any other thread but the main thread calls gtk/gtk functionseven if that last condition isn't met, it's probably safer to do it anyway if you're going multithreaded, as you never know what you might change later.
this _is_ correct, as gtk signals are indeed handled inside the gdk global lock.There is no need for gdk_threads_enter/leave() in the callbacks either since they will be called from the main gtk+ thread. Of course, if the callbacks are accessing data structures that are modified by other threads, then locking will be needed,
-brian