46

I have the following classes. 

public class B 
{
    public A a;

    public B()
    {
        a= new A();
        System.out.println("Creating B");
    }
}

and 

public class A 
{
    public B b;

    public A()
    {
        b = new B();
        System.out.println("Creating A");
    }

    public static void main(String[] args) 
    {
        A a = new A();
    }
}

As can be clearly seen, there is a circular dependency between the classes. if I try to run class A, I eventually get a StackOverflowError.

If a dependency graph is created, where nodes are classes, then this dependency can be easily identified (at least for graphs with few nodes). Then why does the JVM not identify this, at least at runtime? Instead of a throwing StackOverflowError, JVM can at least give a warning before starting execution.

[Update] Some languages cannot have circular dependencies, because then the source code will not build. For example, see this question and the accepted answer. If circular dependency is a design smell for C# then why is it not for Java? Only because Java can(compile code with circular dependencies)?

[update2] Recently found jCarder. According to the website, it finds potential deadlocks by dynamically instrumenting Java byte codes and looking for cycles in the object graph. Can anyone explain how does the tool find the cycles?

Improve this question
5
  • Why do you expect to get a warning on this? Did you read somewhere that JVM will do this for you? Commented Sep 5, 2010 at 13:01
  • 1
    The sort of problem is very easy for the developer to detect and first. The JVM tends to warn a bout problems you cannot detect easily, like a corrupt class file. Commented Sep 5, 2010 at 14:31
  • 1
    I love how only 2 of the 5 answers (as of the time I write this) really answer your question: why doesn't the compiler detect and warn about the potential issue. And neither of those 2 is the highest voted (again, at least at the time I write this). Commented Sep 5, 2010 at 17:09
  • 1
    @BertF: seven years later, still true. Commented Mar 27, 2018 at 14:36
  • Who selected the accepted answer then? Commented Jul 14, 2018 at 13:01

5 Answers 5

Reset to default
45

The constructor of your class A calls the constructor of class B. The constructor of class B calls the constructor of class A. You have an infinite recursion call, that's why you end up having a StackOverflowError.

Java supports having circular dependencies between classes, the problem here is only related to constructors calling each others.

You can try with something like:

A a = new A();
B b = new B();

a.setB(b);
b.setA(a);
Improve this answer
Sign up to request clarification or add additional context in comments.

7 Comments

But aren't circular dependencies bad? If you actually have circular dependencies in the code (like the example you gave), isn't it an indicator of bad design? If yes, then why does java support it? If not, then can you point me to some cases where design involving circular dependency is preferred?
How about producer/consumer or any callback/event situation? Something like this will end up happening, though probably not literally depending between two classes. Maybe interfaces.
It's not really clear what 'dependency' means in this case. Dependency is often translating to X needs to happen before Y.
To give a real life example: You could for example rename A to Parent and B to Child. Such relations occur frequently in computing (the Parent class needs to know how it's child is and the Child class needs to know who the Parent is), e.g. when working with XML documents (child tags are enclosed in parent tags etc.)
This does not answer the question (about why the problem is not detected before runtime by adequate tools).
|
22

Its perfectly valid in Java to have a circular relationship between 2 classes (although questions could be asked about the design), however in your case you have the unusual action of each instance creating an instance of the other in its constructor (this being the actual cause of the StackOverflowError).

This particular pattern is known a mutual recursion where you have 2 methods A and B (a constructor is mostly just a special case of a method) and A calls B and B calls A. Detecting an infinitely loop in the relationship between these 2 methods is possible in the trivial case (the one you've supplied), but solving it for the general is akin the solving the halting problem. Given that solving the halting problem is impossible, compliers generally don't bother trying even for the simple cases.

It might be possible to cover a few of simple cases using a FindBugs pattern, but it would not be correct for all cases.

Improve this answer

Comments

13

It isn't necessarily as easy as in your example. I believe solving this problem would be equal to solving the halting problem which -- as we all know -- is impossible.

Improve this answer

3 Comments

I agree, determining whether there is a circular dependency for complex cases might not be feasible. But, we can approximate, in which case the JVM might just indicate that there is a potential circular dependency. The developer can then review the code.
I'd think that most cases a compiler could detect by approximation in reasonable time are those that jump right at you (like the example in your question). Having this as a requirement would make writing the compilers very difficult while gaining little.
The JVM is approximating this test, via the stack limit. A more robust execution model with an endless stack would simply fail to halt; stack frame limitations are a desirable mechanism for finding exactly this kind of problem. I would argue that you will almost never encounter a stack overflow that isn't a circular dependency.
5

If you really have a use case like this, you could create the objects on demand (lazily) and use a getter:

public class B 
{
    private A a;

    public B()
    {
        System.out.println("Creating B");
    }

    public A getA()
    {
      if (a == null)
        a = new A();

      return a;
    }
}

(and similarly for the class A). So only the necessary objects are created if when you e.g. do:

a.getB().getA().getB().getA()
Improve this answer

1 Comment

Not best practice but a beautiful idea!
1

A similar workaround to getters/setters using composition and and constructor injection for the dependencies. The big thing to note is that the objects don't create the instance to the other classes, they are passed in (aka injection).

public interface A {}
public interface B {}

public class AProxy implements A {
    private A delegate;

    public void setDelegate(A a) {
        delegate = a;
    }

    // Any implementation methods delegate to 'delegate'
    // public void doStuff() { delegate.doStuff() }
}

public class AImpl implements A {
    private final B b;

    AImpl(B b) {
        this.b = b;
    }
}

public class BImpl implements B {
    private final A a;

    BImpl(A a) {
        this.a = a;
    }
}

public static void main(String[] args) {
    A proxy = new AProxy();
    B b = new BImpl(proxy);
    A a = new AImpl(b);
    proxy.setDelegate(a);
}
Improve this answer

2 Comments

I don't see how this solves the problem, since you are relying on the implementor of B to not call any methods on A in B's constructor when A is injected. Doing so would cause the method invocation to occur on the proxy, which would ultimately result in a NullPointerException since you'd like proxy those calls on the A (which would be null).
The same can be said for the getter/setter case. The point here is that to create an instance, a parameter must be passed to the constructor. The proxy instance here allows for a "late binding" which breaks the circular dependency. Is it clean? No. Is it a viable solution? Yes, in the short term but definitely not in the long term. The correct solution would be a better design where A and B are oblivious to each other. eg: C c = new C(A, B)

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.