Circular dependency deadlock possibility

[justiny1023]

Is it possible for Dagger to deadlock while providing for dependencies? For example, if there is a circular dependency between Class A and Class B because both inject each other like this:

class ClassA @Inject constructor(classB: Provider<ClassB>) {
   fun logSomeMetrics() {
      // ...
      classB.get().writeSomething();
      // ...
   }
}

class ClassB @Inject constructor(classA: Provider<ClassA>) {
   fun writeSomething() {
      // ...
      classA.get().logSomeMetrics();
      // ...
   }
}

The Provider was used in each class to try to break the circular dependency. Is there ever a race condition or scenario where two threads will deadlock because one is trying to resolve dependency (lazily through get()) for Class A, while the other is trying to resolve dependency (lazily through get()) for Class B?

Or is it guaranteed that both dependencies will be resolved properly without deadlock?

[Chang-Eric]

This should work fine. With these objects as written, they are unscoped, so a new ClassA and ClassB will be be created anyway, so there isn't any locking, so there is no deadlock. Even with these as scoped objects though, there still isn't really a deadlock here because those methods aren't invoked in the constructor. Dagger only covers the constructor call with locks when scoped.

[justiny1023]

@Chang-Eric Thanks Eric. I failed to mention that these are indeed scoped (both scoped to application, so essentially a singleton for the process). It seems even then we just need to avoid lazily initializing in the constructor. I saw some cases of deadlock in Guice like this: https://timothybasanov.com/2015/03/31/guice-singletons-parallelization.html So wasn't sure if Dagger2 had same behavior that we should be aware that would deadlock.

[Chang-Eric]

I'm not familiar enough with that link to comment even though I do have some Guice experience, but I do not think we have a known deadlock issue in Dagger. If you have a concrete case though, please do let us know.