Class SELF That Is Hosted By A Couple Different Classes?

I have a class SELF that is hosted by a couple different classes. Basically, the hosting class HOST calls a method in SELF. SELF is passed HOST as an argument in the constructor, so SELF can call methods in HOST. In normal situations, a call to HOST will do something minor, then return so that SELF can continue. However, for one particular type of HOST, one of the calls from SELF to HOST will cause HOST to call SELF, and so on ad infinitum. A classic, though convoluted, case of recursion. Once again, this is only going to happen for one type of HOST. For other types of HOST, that particular call will not cause HOST to call SELF, so there will be no recursion. Nonetheless, there is no getting around it in one case.

I can see two means to decouple the recursion, and I am wondering which one (or a third) would work best:

1) Add a timer into that particular HOST so that the call from SELF that would trigger the recursion would actually just start the timer in HOST, then return. When the timer ticks, HOST can call SELF. The recursion is broken because the call to SELF is done on the timer event, and not when SELF called HOST.

2) As it happens, HOST makes the first call to SELF in a background thread, which means I don't really need to worry whether this thread blocks or not. Therefore, I could have this background thread spawn a second background thread to make the call to SELF, then have the initial HOST thread JOIN on the second thread. This means that the initial thread will block until the second thread finishes. Meanwhile, the second thread will call HOST, and the HOST won't call back to SELF, it will just return like all the other HOST objects would do. This will allow the second thread to run to completion. When the second thread completes, the first thread will take over and call SELF again on a new second thread. Therefore, the recursion is broken because the secondary thread will always run to completion, and the primary thread will wait for the secondary thread to complete, then call it again.

I tend to prefer the second option, because the first option involves a pause of some length (the minimum for a timer, which is pretty small), while the second doesn't, but the first option is actually a little easier to implement.