About observer pattern

i have some question about the issue of delay time. for example, i have a web base live quote stock system. you know that every time the stock value is changing, once the stock was changed, each clients will update the stock value immediately. If i use observer pattern to apply the system, the subject will montoring the new stock value which is come from other resource, once the new value is updated, it will notify it's observer to update the value. If i have a hundred, a thoursand.. clients/observer which may be stored in a list. then some client will notify immediately and some are not. Is it right? if the concept is right, is there any solution to solve the issues? Thanks.

Let me know if I understand your question:
- you mean if your subject notifies all its observers one by one sequentially in the same thread, then the "last in line" will be notified long after the fist one.
- plus, if one observer takes a long time to process the notification, subsequent observers may not receive their notification before a while.
Well, yes, this is a known problem. A well-known incarnation is listeners processing event in a single event-dispatching thread in AWT or Swing: if one listener takes a long time to complete processing the notification, then all subsequent listeners do not receive the notification in time; worse all other graphical events are blocked, and the UI display freezes, because even the repaint events are pending the first listener method to return.
In Swing the way around this is to ask listener classes to observe a convention: complete quickly all listeners methods - if a time-consuming job must be started as part of processing a notification, spawn another thread for it.
If you don't trust the observers to observe this convention (you may not be the author of all observers code, or your observers are in different JVMs), then you have no option other to spawn multiple threads:
one thread per observer
or, a pool of dispatching threads
or, a pool of dispatching thread with support for timeouts (there is no generic way to reclaim a thread that is timeouting, but you can choose to have a master thread that monitors dispatching threads for timeout and uses the pool as dispatching threads are timeouting).

Similar Messages

Gui design about observer pattern

i have 2 swt components both including a browser component.
they both are instatiated passing a reference to an observable document:
public class ObservableW3CDocument extends java.util.Observable {
private Document document;
private String content;
   * Modifications to the document should be mirrored in by notifications to
   * this document observers
   * @param document
public void setDocument (Document document) {
    this.document = document;
    if(document.getTextContent()!=null) {
      this.content = document.getTextContent();
      System.out.println("Setting content at: "+content);
    this.setChanged();
    notifyObservers(this);
public void setContent (String content) {
    this.content = content;
    try {
      this.document = DOMUtil.parseHTML(new StringReader(content));
    } catch (SAXException e) {
      e.printStackTrace();
    } catch (IOException e) {
      e.printStackTrace();
    this.setChanged();
    notifyObservers(this);
public void setDocumentAndContent(Document d, String c) {
    this.document = d;
    this.content = c;
    this.setChanged();
    notifyObservers(this);
}both components implements thejava.util.Observer interface: the first one refresh its content when ever a new document is set (that it, the observable document registers it as an observer).
. the other one should apply an xpath query over it and display the result in its embedded browser.
My question: should I have 2 copies of the same document going around?
How can i make all this updating process easier to mantain?

I have a question mysef:
Why do you separate Document and content? Would they ever differ? Would it confuse callers if they did differ?That having been said, within ObservableW3CDocument, you do not have any instances of Document. Instead, you have references to the instance of Document. As such, there is no 'harm' in having multiple references (or in constantly resetting the Document reference). The garbage collector will take care of the actual object when no more valid references exist.
- Saish

Observer pattern with TCP

Hello java friends!
I have implemented an auction application over a TCP communication. The client's using a basis Socket and the server is multi threaded with a ServerSocket returning a Socket which is processed in a separate thread. The connection between server and client is closed automatic after each request, so another request from the client would need to be connected over a new connection. It's implemented like this for the sake of performance.
But however, I now want to implement the Observer pattern(which I'm also comfortable with). This would let the client be notified by the server if someone else overbids him in a auction. And I wonder how this could be completed?
I had a thought and it went like this. If the client would also have a ServerSocket then the server would be able to connect to it when ever he would like to notifying the client. What I like by this implementation is that the notification is done without any delay! This is obviously one way to implement it, but I wonder if someone else in here had a better idea,or if someone knew the standard implementation for a situation like this.
Thanks in regards!

superdeportivo wrote:
The sever creates a new thread for every request that the client makes. If performance is important you may want to use a thread pool.
For example the client makes a bid on an auction item. [deleted]This is simplest way to do what you require. I am generally in favour of keeping things simple.
if the Client would like to make another bid then the client would need to go through all the steps again from 1 to 4. Why the fourth step is implemented is because otherwise the client would held a thread live at the server as long as he is connected (using the application) and eventually the server would run out of threads!How many clients do you have at once? You should be able to support 1,000 on a typical PC and 10,000 on a decent server. You can keep the connection/thread for a period of time and drop the connection if the client disconnects or doesn't do anything for a period of time (from a few seconds to a few hours)
Another approach is to use non-blocking IO (see the samples which come with the JDK) In this way a small number of threads can manage a large number of connections.
So lets say if we're using a thread pool with maximum 20 threads, then only 20 clients would be able to connect to the server at the same time (use the application). If the maximum is 2,000 then you can have up to 2,000 clients.
I hope I made my self clear if not please tell me which part wasn't.I think you have made a few assumptions about what performs best or what is possible could have a rethink.
And about the delay, of course the connection delay is what's acceptable for my program.The simplest approach using your current model is for the client to poll the server.
Edited by: Peter__Lawrey on 30-Jan-2009 22:56

How to implement Observer Pattern?

Hello guys,
I have some problems with implementing the observer pattern. So i m making an sound application and i need to put a meter changing with the volume.
I have already the meter designed and the volume is calculated.
So i have a class called Application (is the main class) and this class have the graphic designer from the application, makes the audio capture and calculate the volume.
And i have the MeterMic class and in this class i have the graphic Meter where i send this graphic meter to the application via JPanel.
In MeterMic i have the variable "value" and this variable will make the changes in the bars of the meter and i want to equal the value to the volume from the application. I try referencing by the Application object but doesnt pass the value from the volume.
So i would like to implement the Observer pattern.
I need to observ the variable volume and than the volume have changes i want to send that change to variable value in MeterMic.
My problem is: who is the observer and observ? And what i need to do to implement the pattern.
My best,
David

Kayaman wrote:
DavidHenriques wrote:
So i just need to implement the observers interfaces and than implement the method update and notify in the classes.You should probably forget the Observer/Observable classes, they're Java 1.0 stuffDo you think they are usless just because they are old?
so you don't have to or need to use them, even though the names sound appealing.I still like them because the Observable saves me from repetitively implementing (hopefully thread save) method for notifying the observers...
It's basically the same thing, you just see a lot more talk about Events/Listeners than Observers/Observables these days.The good thing on Events/Listeners is that they are type save which is an importand feature.
But I like to build them on top of Observer/Observable on the event source side.
bye
TPD

Observer Pattern applied in Abap

Observer Pattern
Observer pattern is a well known pattern especially with Java, here i continue my work in patterns.
This is my humble understanding of a way how we can apply observer pattern
The main components of this pattern is:
Observer pattern:
Subject
Observer
Context
Why do we need?
Cant i do without this pattern, well of course you can do although you will be having a tightly coupled application
The main reason is we don't want to couple the objects
The main goal is the " Least knowledge in objects across each other"
The trick here is the use of the Events in ABAP where an event gets raised and then that will be handled by a listener!!
Subject:
Its the main object the core data that we will be working with
You could have multiple implementations of the subject
One approach: is to have an interface where we can extract the event.
Here is a code sample: Subject is data based on the sales order item data when there is a change it will fire the event below
interface lif_subject.
   EVENTS: SUBJECT_IS_CHANGED.
ENDINTERFACE.
Here is the subject:
class lcl_subject definition .
public section.
INTERFACES lif_subject.
   methods CONSTRUCTOR
     importing
       !IV_MATNR type MATNR
       !IV_SPRAS type SPRAS
    methods GET_MATNR
     returning
       value(RV_MATNR) type MATNR .
   methods GET_SPRAS
     returning
       value(RV_SPRAS) type SPRAS .
    methods SET_MATNR
     importing
       !IV_MATNR type MATNR .
   methods SET_SPRAS
     importing
       !IV_SPRAS type SPRAS .
protected section.
private section.
   data MV_MATNR type MATNR .
   data MV_SPRAS type SPRAS .
ENDCLASS.
CLASS lcl_subject IMPLEMENTATION.
METHOD constructor.
   mv_matnr = iv_matnr.
   mv_spras = iv_spras.
ENDMETHOD.
METHOD get_matnr.
   rv_matnr = mv_matnr.
ENDMETHOD.
METHOD get_spras.
   rv_spras = mv_spras.
ENDMETHOD.
METHOD set_matnr.
   mv_matnr = iv_matnr.
   RAISE EVENT lif_subject~SUBJECT_IS_CHANGED.
ENDMETHOD.
METHOD set_spras.
   mv_spras = iv_spras.
   RAISE EVENT lif_subject~SUBJECT_IS_CHANGED.
ENDMETHOD.
ENDCLASS.
Observer:
Observer is the one thats interested in the change of the subject
That could be any observer
Here is the code sample
****Observer
INTERFACE lif_observer.
METHODS: update.
ENDINTERFACE.
class lcl_observer1 DEFINITION.
PUBLIC SECTION.
INTERFACES lif_observer.
ENDCLASS.
class lcl_observer1 IMPLEMENTATION.
method lif_observer~update.
WRITE:/ ' Observer 1 is updated '.
ENDMETHOD.
ENDCLASS.
class lcl_observer2 DEFINITION.
PUBLIC SECTION.
INTERFACES lif_observer.
ENDCLASS.
class lcl_observer2 IMPLEMENTATION.
method lif_observer~update.
WRITE:/ ' Observer 2 is updated '.
ENDMETHOD.
ENDCLASS.
Context: Its the manager of the all communication like a channel
It separates the observer from the observable.
class   lcl_channel definition.
PUBLIC SECTION.
methods: add_observer IMPORTING io_observer type REF TO lif_observer.
methods: remove_observer IMPORTING io_observer type REF TO lif_observer.
methods: constructor.
methods: notify_observers FOR EVENT lif_subject~SUBJECT_IS_CHANGED of lcl_subject IMPORTING sender.
PRIVATE SECTION.
DATA: lo_list type REF TO CL_OBJECT_MAP.
class-DATA: lv_key type i.
ENDCLASS.
Notice that the event listener for the subject is the channel itself
and notify_observers method is responsible for that.
****Manager!!
class   lcl_channel definition.
PUBLIC SECTION.
methods: add_observer IMPORTING io_observer type REF TO lif_observer.
methods: remove_observer IMPORTING io_observer type REF TO lif_observer.
methods: constructor.
methods: notify_observers FOR EVENT lif_subject~SUBJECT_IS_CHANGED of lcl_subject IMPORTING sender.
PRIVATE SECTION.
DATA: lo_list type REF TO CL_OBJECT_MAP.
class-DATA: lv_key type i.
ENDCLASS.
class lcl_channel IMPLEMENTATION.
method constructor.
   create OBJECT lo_list.
   lv_key = 1.
ENDMETHOD.
method add_observer.
lo_list->PUT(
   EXPORTING
     KEY      = lv_key
     VALUE    = io_observer
lv_key = lv_key + 1.
ENDMETHOD.
method remove_observer.
ENDMETHOD.
METHOD notify_observers.
DATA: lo_map_iterator TYPE REF TO CL_OBJECT_COLLECTION_ITERATOR.
DATA: lo_observer type REF TO lif_observer.
break developer.
lo_map_iterator ?= lo_list->GET_VALUES_ITERATOR( ).
while lo_map_iterator->HAS_NEXT( ) = abap_true.
lo_observer ?= lo_map_iterator->GET_NEXT( ).
lo_observer->UPDATE( ).
ENDWHILE.
ENDMETHOD.
Notice the use of the Collections as well cl_object_collections object in SAP Standard
I hope you find this useful
The sample code is attached as a text file
ENDCLASS.

Are you asking to check string in data in the course of running the program, or are you asking how to check patterns in the source of the program itself?
The other replies have covered checking patterns in data.
If you want to check for patterns in the ABAP source itself, you can check for patterns in ABAP source using SCII Code inspector.
Enter SCII and select the object or set of objects to check.
Under the list of checks for Temporary Definition there is area called
Search Functs.
Under Search Functs., if you expand it, there are options to search for
Search of ABAP Tokens
Search ABAP Statement Patterns
Click on the arrow to the left of these and you can specify details about the patterns that you want to search for.
Good luck
Brian

Observer pattern in J2EE

I have a question about the Observer patterne.
I have tried to implement it im my application but without result. First my idea was to save all the client Object references in A linked List in a bean on the server. Then each time a certain event ocurs on my server I will call a method fire() which iterate through my linked list and finds all my client references. Then I will make a "call back" to all the clients which are in my linked list. But my teacher tells my that is not the way to do. He belives that there is a much easier way to make sure that all the clients get updates. But he does't know how to do it. So my question is how do I implements Observer Design patterns in the J2ee enviroment ??

It seems to that one of the solotions to this problem is to use RMI. Apperently it is not possible to make a regular callback to a client in the J2EE enviroment. That,s not good, because you have to make a call back if you want to implement the observer deign patterne. I think it is sad, because one of the most important design pattern is The observer pattern.

Reverse observer pattern

hi,
is it possible to use the reverse of observer pattern
i.e - observer pattern is described normally as there is 1 subject & many observers.
So when the subject changes, it notifies the observers. My problem is I only 1 observer but many things change, so when each of the things (subjects ) change I want to call the observer to get the updates.
Is it possible?
What if the each subject is run in a thread.?
Thank you

is it possible to use the reverse of observer pattern
i.e - observer pattern is described normally as there
is 1 subject & many observers.
So when the subject changes, it notifies the
observers. My problem is I only 1 observer but many
things change, so when each of the things (subjects )
change I want to call the observer to get the
updates.
Is it possible?Yes. Rather than have classes A, B, C register as listeners on class D, have class D register itself as a listener on classes A, B, C. Whenever A, B, or C do something, they'll notify all classes observing them (namely D).
This is not the inverse of observer pattern but rather a different way of utilizing it than what you have described in your question.
>
What if the each subject is run in a thread.?
If classes A, B, C run in separate threads, the pattern implementation does not change too terribly much. Whenever A, B, C do something they will still notify their observers (namely D). But you should realize that since they are multithreaded you may encounter a time when A and B notify D simultaneously. You will need to think about synchronization.

Observer Pattern

Hi. I'm coding the observer pattern with generics. All is well up to a point.
I have an ObserverI interface
public interface ObserverI
<     S extends Subject<S,D>,
     D >
     void update( S subject, D details ) ;
}and a Subject base class
public class Subject
<     S extends Subject<S,D>,
     D >
     private List<ObserverI<S,D> > observers = new ArrayList<ObserverI<S,D> >() ;
     public void attach(ObserverI<S,D> observer) { ... }
     public void detach(ObserverI<S,D> observer) { ... }
     public void notifyObservers(D details) {
          for( ObserverI<S,D> observer : observers )
               observer.update( this, details) ;
}The problem is the call observer.update( this, details) ; The first argument (this) should be of type S, but is of type Subject<S,D>. Thus I get an error.
If I replace that line with observer.update( (S) this, details) ;I only get a warning. (Unchecked cast.)
It seems there should be some way I can express the pattern without the need for any casting or errors. I tried a few things with wild cards
What can I do? Any help appreciated.

ejp is right in that the "extends Subject<S,D>" is not needed. Thanks, ejp, for pointing this out.
But when I get rid of "extends Subject<S,D>" (in both places) I still have the "unchecked cast" warning.
Since posting the original question, I've learnt a few more things:
(0) That the cast may be unchecked, but the call is not. Thus even if "this" is not of type "S", there is ClassCastException
as the argument to update is not of the type expected in the concrete observer. This is reassuring. Crazy stuff does not
happen!
(1) That I could solve the whole problem with the "getThis()" trick, as explained by Angelika Langer at http://www.angelikalanger.com/GenericsFAQ/FAQSections/ProgrammingIdioms.html#FAQ205 . (Very helpful FAQ altogether.) That is, replace "this" with a call to an abstract method getThis that returns S. In the concrete subject, getThis is implemented in the obvious way: "return this".
However, using the getThis() trick seems unsatisfactory, as it forces coders of concrete subclasses of Subject to implement a method for no other purpose than to placate the Generic gods. (In truth there is another justification for using a getThis method, which I may go into in an other post.)
I'm still hoping someone here can post a better solution.
Cheers,
Theo
Edited by: theodore.norvell on Jun 16, 2009 8:13 PM

Observer-observable pattern question

Hi all there!!
I reckon that in the observer-observable pattern, there is an notfiyObserver(object obj) method to invoke the Observer to receive the reference instance obj, and in the observer class, as there is a method called update(observable obr, object obj2), obj is subsituted into obj2 to complete the whole process. so obj from Observable is sent to Observer as obj2. Am i right?
Because I've tried such thing, but seems that the observer receives null object...... sorry that I'm not going to post the code here /_\!! Thank you

Are you sure you are calling notifyObservers(Object arg) and not just notifyObservers()? Because in the later case, the "observer" would receive null as a second argument in its "update" method.
Try to print or do some operation on your arg object before passing it in notifyObservers method to see if it's really not NULL.
Hope this helps..

ActionListener demonstrate Observer Pattern?

Would using ActionListener in a program be considered an example of the observer pattern?

I think you should make sure that the object which uses or displays the data is seperate from the object which contains it.
If this is homework you may get extra marks if you display data changes in more than one way.

The Observer Pattern

I need to help on the Observer pattern. It's true/false questions:
1. The observer pattern lets you vary subjects and observers independently.
2. You cannot reuse subjects without reusing their observers, and vice versa.
3. You cannot add observers without modifying the subject or other observers.
4. The coupling between subjects and observers is abstract and minimal.
5. Like an ordinary request, the notification that a subject sends must specify its receiver.
6. In some situations an observer depends on more than one subject, for example, a spreadsheet may depend on more than one data source.
Thanks
Brendan

Please check if correct. THe reason why I asked for help is because I have not found any good articles on this pattern and it is not part of my curriculum, but we have to answer it.
1. TRUE
2. FALSE
3. FALSE
4. TRUE
5. FALSE
6. TRUE
Please let me knw if I am in the correct direction.
Thanks

Observer Pattern Help

hi,
I am trying to understand how and when you would use an observer pattern. I understand that it allows one class to observe another, i.e if a variable was to change in 1 class all observing classes would be notified of the change. I do not understand how u would implement this, I have seen some examples but they are kinda confusing does anybody have a simple way of showing how this pattern is implemented?
thx
sbains

Dish would be the observable in this case. Waiter and Chef are the /
contain observers. The observer's update method will get called whenever
the observable calls notifyObservers.
public class Dish extends Observable {
    public void setStock(int stock) {
        .. business logic ..
        this.setChanged();
        this.notifyObservers(new Integer(stock));
public class Waiter implements Observer {
    public void update(Observable o, Object arg) {
        Long stock = (Long) arg;
        .. business logic ..
}Note that Listeners are also implementations of the Observer pattern, if
that helps any.

Observer pattern example - JMinesweeper

Hello, I've developed a JMinesweeper desktop game, similar to the one in Windows. The application uses a well known design pattern: Observer Pattern.
The source code is free for anyone who finds it useful:
http://sourceforge.net/projects/jminesweepsorin
My best regards ! :)

ejp is right in that the "extends Subject<S,D>" is not needed. Thanks, ejp, for pointing this out.
But when I get rid of "extends Subject<S,D>" (in both places) I still have the "unchecked cast" warning.
Since posting the original question, I've learnt a few more things:
(0) That the cast may be unchecked, but the call is not. Thus even if "this" is not of type "S", there is ClassCastException
as the argument to update is not of the type expected in the concrete observer. This is reassuring. Crazy stuff does not
happen!
(1) That I could solve the whole problem with the "getThis()" trick, as explained by Angelika Langer at http://www.angelikalanger.com/GenericsFAQ/FAQSections/ProgrammingIdioms.html#FAQ205 . (Very helpful FAQ altogether.) That is, replace "this" with a call to an abstract method getThis that returns S. In the concrete subject, getThis is implemented in the obvious way: "return this".
However, using the getThis() trick seems unsatisfactory, as it forces coders of concrete subclasses of Subject to implement a method for no other purpose than to placate the Generic gods. (In truth there is another justification for using a getThis method, which I may go into in an other post.)
I'm still hoping someone here can post a better solution.
Cheers,
Theo
Edited by: theodore.norvell on Jun 16, 2009 8:13 PM

Observer pattern in BC4J?

Just wondering if anyone has implemented a publisher/subscriber (or observer) pattern with BC4J? For instance, has anyone implemented an application module supporting multiple clients that allows clients to call a method to send a message to all the clients that listen to the sender? Would the performance be much worse if I implement the piece in BC4J rather than implementing it in, say, VisiBroker CORBA or straight UDP datagram sockets?

Actually I have a similar question as well... I wonder if anyone has tried to implement something like a simple chat server that listens to all incoming messages and route those messages to the listening clients. I am not sure how to implement this.

Variation of Observer pattern

Hi,
I'd like to know if there is a common variation of the observer pattern when there is multiple observable object. As an example here is what my register method looks like.
addListener(EventListener, Event) {}So basically an event listener can register to receive notification of a specific event. Now, I know I'll need a list of EventListener for every Event or something like that but I like to use a standard way of doing it if there is one.
Thanks
Francois

Hi,
Thanks for the quick answer but I don't think this apply to me.
I'll try to explain a little more my problem. I have a class watching multiple sensor. An event listener can register to be notified in case of a change of one of the multiple sensor. They have to register to the class that have access to the sensor like that :
SensorWatcher.addListener(EventListener ev, int sourceSensor);This is different from the normal Java event handling because normally (like the JButton for instance) there is one event source with multiple listener so the listener don't have to specify for which event source they are registering. That's why I cannot use the Observer pattern out of the box.
For now, I'm using an Hashtable to map the event source and their event listener vector but it doesn't look that nice to me.
Bye
Francois

About observer pattern

Similar Messages

Maybe you are looking for