JvnObjectImpl.java

Go to the documentation of this file.

package jvn;

import java.io.Serializable;


public class JvnObjectImpl implements JvnObject {
        private static final long serialVersionUID = -1348964285294975085L;

        protected Serializable __containedObject = null;

        JvnObjectState __containedObjectLockState = null;

        private int numberOfReadLocks = -1;

        private int jvnObjectId = -1;

        public JvnObjectImpl( Serializable o ) /*throws JvnException*/ {
                __containedObject = o;
                numberOfReadLocks = 0;
                __containedObjectLockState = JvnObjectState.STATE_WLOCKT;
        }

        public void jvnLockRead() throws JvnException {
                // Only process one lock request at a time
                synchronized(__containedObjectLockState) {
                        // Whether we should ask the server for the read lock or not
                        // Asking needs to be done OUTSIDE a synchronized block (deadlock)
                        boolean askServer = false;

                        synchronized(this) {
                                if( __containedObjectLockState == JvnObjectState.STATE_RLOCKC ) {
                                        // We already have a cached read lock
                                        numberOfReadLocks = 1;
                                        __containedObjectLockState = JvnObjectState.STATE_RLOCKT;
//                                      System.out.println("Read lock: upgrading from \"cached\" to \"taken\".");
                                } else if( __containedObjectLockState == JvnObjectState.STATE_RLOCKT ) {
                                        // We already have a lock: simply increment reference count
                                        numberOfReadLocks++;
//                                      System.out.println("Read lock: one more reader (total: "+numberOfReadLocks+")");
                                } else {
                                        // We don't have any read lock, ask the server
//                                      System.out.println("Read lock: obtaining via server");
                                        askServer = true;
                                }
                        }

                        // Ask the server if needed
                        if(askServer){
                                Serializable temp = JvnServerImpl.jvnGetServer().jvnLockRead(jvnObjectId);

                                // Ask server OK, now resync and update datum
                                synchronized(this) {
                                        if(temp==null) {
                                                throw new JvnException("Invalid object received when asking for read lock!");
                                        } else {
                                                numberOfReadLocks = 1;
                                                __containedObject = temp;
                                                __containedObjectLockState = JvnObjectState.STATE_RLOCKT;
//                                              System.out.println("Read lock: obtained via server");
                                        }
                                }
                        }
                }
        }

        public void jvnLockWrite() throws JvnException {
                // Only process one lock request at a time
                synchronized(__containedObjectLockState) {
                        // Whether we should ask the server for the write lock or not
                        // Asking needs to be done OUTSIDE a synchronized block (deadlock)
                        boolean askServer = false;

                        synchronized(this) {
                                if( __containedObjectLockState == JvnObjectState.STATE_WLOCKC ) {
                                        // We already have a write lock cached
                                        __containedObjectLockState = JvnObjectState.STATE_WLOCKT;
//                                      System.out.println("Write lock: upgrading from \"cached\" to \"taken\".");
                                } else {
                                        // The server will contact the coordinator if required
//                                      System.out.println("Write lock: obtaining via server");
                                        askServer = true;
                                }
                        }

                        // Ask the server if needed
                        if(askServer) {
                                Serializable temp = JvnServerImpl.jvnGetServer().jvnLockWrite(jvnObjectId);

                                // Ask server OK, now resync and update datum
                                synchronized(this) {
                                        if( temp!=null ) {
                                                __containedObject = temp;
                                                __containedObjectLockState = JvnObjectState.STATE_WLOCKT;
//                                              System.out.println("Write lock: obtained via server");
                                        } else {
                                                throw new JvnException("Invalid object received when asking for write lock!");
                                        }
                                }
                        }
                }
        }

        public void jvnUnLock() throws JvnException {
                synchronized(this)
                {
                        // Perform the change locally: see "Cohérence: cas de figure 1".
                        if (__containedObjectLockState == JvnObjectState.STATE_WLOCKT) {
                                __containedObjectLockState = JvnObjectState.STATE_WLOCKC;
//                              System.out.println("Write lock: downgrading from \"taken\" to \"cached\".");

                                // Wake threads that are lazily sleeping.
                                this.notifyAll();
                        } else if (__containedObjectLockState == JvnObjectState.STATE_RLOCKT) {
                                numberOfReadLocks--;
//                              System.out.println("Read lock: one less reader (total: "+numberOfReadLocks+")");

                                if( numberOfReadLocks <= 0 ) {
                                        // No more read locks left: set lock status as "read lock
                                        // cached" and notify people that are waiting
//                                      System.out.println("Read lock: downgrading from \"taken\" to \"cached\".");
                                        __containedObjectLockState = JvnObjectState.STATE_RLOCKC;
                                        this.notifyAll();
                                }
                        } else {
                                throw new JvnException("Tried to unlock an object that's not locked !?!");
                        }
                }
        }

        public int jvnGetObjectId() throws JvnException {
                if( jvnObjectId <= 0 ) {
                        throw new JvnException("Current Javanaise Object ID is invalid!");
                } else {
                        return jvnObjectId;
                }
        }

        public void jvnSetObjectId(int id) throws JvnException {
                if( id <= 0 ) {
                        throw new JvnException("Invalid Javanaise Object ID!");
                } else {
                        jvnObjectId = id;
                }
        }

        public Serializable jvnGetObjectState() throws JvnException {
                if( __containedObjectLockState != JvnObjectState.STATE_RLOCKT &&
                        __containedObjectLockState != JvnObjectState.STATE_WLOCKT ) {
                        throw new JvnException("Please make sure you obtain a read or write lock BEFORE getting the object state!");
                } else {
                        return __containedObject;
                }
        }

        public void jvnInvalidateReader() throws JvnException {
                synchronized(this) {
                        if( __containedObjectLockState == JvnObjectState.STATE_RLOCKT ) {
//                              System.out.println("Invalidating reader: current state is \"taken\" ("+numberOfReadLocks+" readers).");
                                try {
                                        // Wait while not ready.
                                        while( __containedObjectLockState == JvnObjectState.STATE_RLOCKT ) {
                                                this.wait();
                                        }
                                } catch (InterruptedException e) {
                                        throw new JvnException( "InterruptedException has occured while invalidating reader!\n" + e);
                                }

                                __containedObjectLockState = JvnObjectState.STATE_NOLOCK;
                        } else if( __containedObjectLockState == JvnObjectState.STATE_RLOCKC ) {
//                              System.out.println("Invalidating reader: current state is \"cached\".");
                                __containedObjectLockState = JvnObjectState.STATE_NOLOCK;
                        } else {
                                // Don't throw this: we sometimes have some small sync issues
                                // for states (duplicate messages are sent), but it's ignorable
//                              throw new JvnException( "Tried to invalidate a reader but object state is not a reading state, it is: " + __containedObjectLockState );
                        }

//                      System.out.println("Reader invalidation OK: current state is \"no lock\".");
                }
        }

        public Serializable jvnInvalidateWriter() throws JvnException {
                synchronized(this) {
                        if( __containedObjectLockState == JvnObjectState.STATE_WLOCKT ) {
//                              System.out.println("Invalidating writer: current state is \"taken\".");
                                try {
                                        // Wait while not ready.
                                        while( __containedObjectLockState == JvnObjectState.STATE_WLOCKT ) {
                                                this.wait();
                                        }
                                } catch (InterruptedException e) {
                                        throw new JvnException( "InterruptedException has occured while invalidating writer!\n" + e);
                                }

                                __containedObjectLockState = JvnObjectState.STATE_NOLOCK;
                        } else if( __containedObjectLockState == JvnObjectState.STATE_WLOCKC ) {
//                              System.out.println("Invalidating writer: current state is \"cached\".");
                                __containedObjectLockState = JvnObjectState.STATE_NOLOCK;
                        } else {
                                // Don't throw this: we sometimes have some small sync issues
                                // for states (duplicate messages are sent), but it's ignorable
//                              throw new JvnException( "Tried to invalidate a writer but object state is not a writing state, it is: " + __containedObjectLockState );
                        }

//                      System.out.println("Writer invalidation OK: current state is \"no lock\".");
                        return __containedObject;
                }
        }

        public Serializable jvnInvalidateWriterForReader() throws JvnException {
                synchronized(this) {
                        if( __containedObjectLockState == JvnObjectState.STATE_WLOCKT ) {
//                              System.out.println("Invalidating writer for reader: current state is \"write lock taken\".");
                                try {
                                        // Wait while not ready.
                                        while( __containedObjectLockState == JvnObjectState.STATE_WLOCKT ) {
                                                this.wait();
                                        }
                                } catch (InterruptedException e) {
                                        throw new JvnException( "InterruptedException has occured while invalidating writer for reader!\n" + e);
                                }

                                __containedObjectLockState = JvnObjectState.STATE_RLOCKC;
                        } else if( __containedObjectLockState == JvnObjectState.STATE_WLOCKC ) {
//                              System.out.println("Invalidating writer for reader: current state is \"write lock cached\".");
                                __containedObjectLockState = JvnObjectState.STATE_RLOCKC;
                        } else {
                                // Don't throw this: we sometimes have some small sync issues
                                // for states (duplicate messages are sent), but it's ignorable
//                              throw new JvnException( "Tried to invalidate a writer but object state is not a writing state, it is: " + __containedObjectLockState );
                        }

//                      System.out.println("Writer invalidation OK: current state is \"read lock cached\".");
                        return __containedObject;
                }
        }
}

---