ACE Frequently Made Mistakes

symptom ACE_Task::getq() returns the error resource temporarily unavailable
probable cause Your Task is a subclass of ACE_Task<ACE_NULL_SYNCH> and you are using it in a multithreaded program.
solution Try using ACE_Task<ACE_MT_SYNCH> instead so that the associated Message_Queue is configured for access by multiple threads.

symptom ACE_Task::wait() throws an assert violation
probable cause When you activate()d your Task, you specified THR_DETACHED, which causes wait() to be unable to perform what you want it to.
solution Make sure you specify the flag THR_JOINABLE when activating your ACE_Task object.

symptom Apparent race conditions when spawning threads (or activating Tasks) from within a constructor.
probable cause You are not guaranteed to have a valid this pointer until the constructor has exited. Threads spawned from a constructor are free to run immediately, and may attempt to use an invalid this pointer.
solution Move your Task activations and other thread-spawning activites out of the constructor.

symptom Compiler issues warnings/erros regarding using too few template arguments, such as "'ACE_Svc_Handler' : too few template arguments".
probable cause Instead of using the appropriate macro, you supplied an actual class name as a parameter. This will fail depending upon platform and compiler, due to the way templates are handled.
solution Instead of instantiating a template class like ACE_Svc_Handler<ACE_SOCK_Stream, ACE_NULL_SYNCH>, use the form of ACE_Svc_Handler<ACE_SOCK_STREAM, ACE_NULL_SYNCH> which circumvents the platform peculiarities by using the macro. This also applies to some other template classes.

symptom Unable to compare ACE_thread_t variables (such as ACE_Thread::self()) using operator== ().
probable cause On some platforms, thread ids are numeric, and on some, they aren't. On some implementations, simple a == b comparisons are legal and sane. Some are not.
solution Use the ACE_OS::thr_equal() function to reliably compare thread ids, regardless of platform.

symptom ACE_Reactor::run_event_loop() does not seem to function correctly for a Reactor created in your application.
probable cause You have not set the ACE_Reactor::instance() to refer to your new reactor. run_event_loop only functions on the reactor currently installed as the global Singleton.
solution Use the ACE_Reactor::instance(ACE_Reactor *, int delete_reactor = 0) static method to install your reactor as the global Singleton before calling run_event_loop().

symptom Infinite recursion when you invoke ACE_Reactor::remove_handler()
probable cause You are invoking remove_handler() from within handle_close() (or a method invoked by handle_close()) but you have not specified the DONT_CALL flag.
solution Be sure to OR in the DONT_CALL flag in this situation.
e.g. --
    int MyHandler::handle_close (ACE_HANDLE handle,
                                 ACE_Reactor_Mask close_mask)
    {
        ...
        my_reactor_->remove_handler( this,
                                    ACE_Event_Handler::READ_MASK |
                                    ACE_Event_Handler::DONT_CALL );
        ...
        return 0;
    }
    

symptom Application crashes after deleting Event_Handler.
probable cause You left a dangling pointer to the Event_Handler in the Reactor. It is the application's responsibility to remove all pending notifications, timer events and completely remove the event handler I/O registrations before removing the event handler. Also, the application should remove the event handler from the reactor before closing the underlying file descriptor / handle. Otherwise:
  • The reactor does not know how to remove the event handler, because the handle is used as the identifier for the event handlers
  • The file descriptor / handle may be reused by another thread, leading to nasty race conditions.
solution
  • Use reference counted event handlers. The reactor and the application cooperate to remove the event handler when the last reference goes away.
  • Remember to call purge_pending_notifications(), remove_handler() and cancel_timer() before deleting the event handler.

maintained by bob@werken.com
Back to ACE Documentation Home.