Observer pattern infinite loop

Question

I have an situation when i have an Observer to be a also a subject. So let's image with have two entites A and B. When Changes occurs in A's Model other entites should know including B (C,D...Etc).

When Changes occurs in B's Model other entites should know including A (C,D...Etc).

By implmenting the Observer pattern in this way i get an infinite loop betteween A and B.

Is the observer pattren not implmented correctly or do i need another pattren to handle this kind of design ?

Any way her my implementation

public interface ISubject {
    public void registreObserver(IObserver obs);

    public void removeObserver(IObserver obs);

    public void notifyObservers();
}

And the Observer Interface

public interface IObserver {
    public void update(ISubject subject);
}

The Model

import java.util.ArrayList;
import java.util.List;


public class AModel implements ISubject {

    private List<IObserver> listObservers = new ArrayList<>();
    @Override
    public void registreObserver(IObserver obs) {
        listObservers.add(obs);
    }

    @Override
    public void removeObserver(IObserver obs) {
        listObservers.remove(obs);
    }

    public void loadData(){
        notifyObservers();
    }

    @Override
    public void notifyObservers() {
        for (IObserver obv : listObservers) {
            obv.update(AModel.this);
        }
    }
}

BModel

import java.util.ArrayList; import java.util.List;

public class BModel implements ISubject {

    private List<IObserver> listObservers = new ArrayList<>();
    @Override
    public void registreObserver(IObserver obs) {
        listObservers.add(obs);
    }

    @Override
    public void removeObserver(IObserver obs) {
        listObservers.remove(obs);
    }

     public void loadData(){
        notifyObservers();
    }


    @Override
    public void notifyObservers() {
        for (IObserver obv : listObservers) {
            obv.update(BModel.this);
        }
    }
}

The A controller

public class AController implements IObserver {

private AModel model;

public void setModel(AModel model) {
    this.model = model;
}

    @Override
    public void update(ISubject subject) {
        System.out.println(" A Changed");
       model.loadData();
    }
}

The B controller

public class BController implements IObserver {

private BModel model;

public void setModel(BModel model) {
    this.model = model;
}
    @Override
    public void update(ISubject subject) {
        System.out.println(" B Changed");
model.loadData();
    }
}

Main Program

public class Main {

    public static void main(String[] args) {
        AModel aModel = new AModel();
        AModel bModel = new BModel();

        AController aController = new AController();
        aController.setModel(aModel);

        AController bController = new BController();
        bController.setModel(bModel);

        aModel.registreObserver(bController);
        bModel.registreObserver(aController);

        // Here the updates starts a notify b and b notify a and so on 
        aModel.notifyObservers();

    }
}

Answer 1

The reason why you are getting an infinite loop is because each time you update your Observable, you notify its observers, but this notifying process then updates the model again and so it repeats.

Here is an example of how to use the Observer pattern in the way you are looking for:

import java.util.Observable;
import java.util.Observer;

public class Example {

    public static void main(String[] args) {

        Model modelA = new Model();
        Model modelB = new Model();

        Observer aController = (observable, arg) -> {
            System.out.println("A controller: " + arg);
        };

        Observer bController = (observable, arg) -> {
            System.out.println("B controller: " + arg);
        };

        modelA.addObserver(bController);
        modelB.addObserver(aController);

        modelA.update("test");
        modelB.update("test2");
    }
}

class Model extends Observable {

    private String data;

    public void update(String data) {
        this.data = data;
        setChanged();
        notifyObservers(data);
    }
}

Output:

B controller: test

A controller: test2

Answer 2

Although @arizzle's answer works, I think you are misusing the Observer pattern.

Observer

Define a one-to-many dependency between objects so that when one object changes > state, all its dependents are notified and updated automatically.

Source

Your problem seems more like a many-to-many relationship. In this case, I'd recomend you to use the Mediator Pattern to hide this complexity.

This is the canonic UML Diagram for this pattern:

I'll skip the interface/abstract class definition here to avoid bloating the answer.

Basic implementation:

class Mediator {
    private Map<String, Colleague> participants = new HashMap<String, Colleague>();
    public void register(Colleague c) {
        participants.put(c.getName(), c);
        c.setMediator(this);
    }

    public void send(Colleague from, String message, String to) {
        Colleague c = participants.get(to);
        if (c != null && c != from) {
            c.receive(message, from);
        }
    }

    public void send(Colleague from, String message) {
        for (Map.Entry<String, Colleague> e: participants.entrySet()) {}
            Colleague c = e.getValue();
            if (c != from)) {
                c.receive(message, from);
            }
        }
    }
}

abstract class Colleague {
    private Mediator mediator;
    private String name;

    public Colleague(String name) {
        this.name = name;
    }

    public void setMediator(Mediator mediator) {
        this.mediator = mediator;
    }

    public void send(String msg, String to) {
        this.mediator.send(this, msg, to);
    }

    public void send(String msg) {
        this.mediator.send(this, msg);
    }

    abstract public void receive(String msg, Colleague from);
}

class ConcreteColleague1 {
    public void receive(String msg, String from) {
        // do something
        System.out.println("Received msg: " + msg + " from: " + from.getName());
    }
}

class ConcreteColleague2 {
    public void receive(String msg, String from) {
        // do other thing
        System.out.println("Received msg: " + msg + " from: " + from.getName());
    }
}

Using it:

Mediator m = new Mediator();

Colleague c1 = new ConcreteColleague1('foo');
Colleague c2 = new ConcreteColleague2('bar');
Colleague c3 = new ConcreteColleague1('baz');

c1.send("test");
c2.send("test");
c3.send("test");

Will print:

"Received msg: test from: foo"
"Received msg: test from: foo"
"Received msg: test from: bar"
"Received msg: test from: bar"
"Received msg: test from: baz"
"Received msg: test from: baz"

This way, when you broadcast a message, you can know for sure that everyone received it, so you don't need to make another broadcast for each colleague to communicate the new state.