jdk-sandbox: comparison jdk/src/share/classes/javax/sql/rowset/spi/SyncFactory.java

equal deleted inserted replaced

-:0f32e3c203b8
+:f3e89472692d
 * @see javax.sql.rowset.spi.SyncProvider
 * @see javax.sql.rowset.spi.SyncFactoryException
 */
 public class SyncFactory {
-/*
-* The variable that represents the singleton instance
-* of the <code>SyncFactory</code> class.
-*/
-private static SyncFactory syncFactory = null;
 /**
 * Creates a new <code>SyncFactory</code> object, which is the singleton
 * instance.
 * Having a private constructor guarantees that no more than
 * one <code>SyncProvider</code> object can exist at a time.
 */
 private static Context ic;
 /**
 * The <code>Logger</code> object to be used by the <code>SyncFactory</code>.
 */
-private static Logger rsLogger;
+private static volatile Logger rsLogger;
 /**
 *
 */
 private static Level rsLevel;
 /**
 * Returns the <code>SyncFactory</code> singleton.
 *
 * @return the <code>SyncFactory</code> instance
 */
 public static SyncFactory getSyncFactory() {
+/*
-// This method uses the Singleton Design Pattern
+* Using Initialization on Demand Holder idiom as
-// with Double-Checked Locking Pattern for
+* Effective Java 2nd Edition,ITEM 71, indicates it is more performant
-// 1. Creating single instance of the SyncFactory
+* than the Double-Check Locking idiom.
-// 2. Make the class thread safe, so that at one time
+*/
-//    only one thread enters the synchronized block
+return SyncFactoryHolder.factory;
-//    to instantiate.
-// if syncFactory object is already there
-// don't go into synchronized block and return
-// that object.
-// else go into synchronized block
-if (syncFactory == null) {
-synchronized (SyncFactory.class) {
-if (syncFactory == null) {
-syncFactory = new SyncFactory();
-} //end if
-} //end synchronized block
-} //end if
-return syncFactory;
 }
 /**
 * Removes the designated currently registered synchronization provider from the
 * Factory SPI register.
 }
 parseProperties(properties);
 }
 }
 }
-/**
-* The internal boolean switch that indicates whether a JNDI
-* context has been established or not.
-*/
-private static boolean jndiCtxEstablished = false;
 /**
 * The internal debug switch.
 */
 private static boolean debug = false;
 /**
 SecurityManager sec = System.getSecurityManager();
 if (sec != null) {
 sec.checkPermission(SET_SYNCFACTORY_PERMISSION);
 }
+if(logger == null){
+throw new NullPointerException("You must provide a Logger");
+}
 rsLogger = logger;
 }
 /**
 * Sets the logging object that is used by <code>SyncProvider</code>
 // singleton
 SecurityManager sec = System.getSecurityManager();
 if (sec != null) {
 sec.checkPermission(SET_SYNCFACTORY_PERMISSION);
 }
+if(logger == null){
+throw new NullPointerException("You must provide a Logger");
+}
+logger.setLevel(level);
 rsLogger = logger;
-rsLogger.setLevel(level);
 }
 /**
 * Returns the logging object for applications to retrieve
 * synchronization events posted by SyncProvider implementations.
 *
 * @throws SyncFactoryException if no logging object has been set.
 */
 public static Logger getLogger() throws SyncFactoryException {
+Logger result = rsLogger;
 // only one logger per session
-if (rsLogger == null) {
+if (result == null) {
 throw new SyncFactoryException("(SyncFactory) : No logger has been set");
 }
-return rsLogger;
+return result;
 }
 /**
 * Sets the initial JNDI context from which SyncProvider implementations
 * can be retrieved from a JNDI namespace
 * @throws SyncFactoryException if the supplied JNDI context is null
 * @throws java.lang.SecurityException if a security manager exists and its
 *  {@code checkPermission} method denies calling {@code setJNDIContext}
 * @see SecurityManager#checkPermission
 */
-public static void setJNDIContext(javax.naming.Context ctx)
+public static synchronized void setJNDIContext(javax.naming.Context ctx)
 throws SyncFactoryException {
 SecurityManager sec = System.getSecurityManager();
 if (sec != null) {
 sec.checkPermission(SET_SYNCFACTORY_PERMISSION);
 }
 if (ctx == null) {
 throw new SyncFactoryException("Invalid JNDI context supplied");
 }
 ic = ctx;
-jndiCtxEstablished = true;
+}
-}
+/**
-/**
+* Controls JNDI context initialization.
-* Controls JNDI context intialization.
 *
 * @throws SyncFactoryException if an error occurs parsing the JNDI context
 */
-private static void initJNDIContext() throws SyncFactoryException {
+private static synchronized void initJNDIContext() throws SyncFactoryException {
-if (jndiCtxEstablished && (ic != null) && (lazyJNDICtxRefresh == false)) {
+if ((ic != null) && (lazyJNDICtxRefresh == false)) {
 try {
 parseProperties(parseJNDIContext());
 lazyJNDICtxRefresh = true; // touch JNDI namespace once.
 } catch (NamingException e) {
 e.printStackTrace();
 bindings.next();
 // Re-entrant call into method
 enumerateBindings(bindings, properties);
 }
 }
+/**
+* Lazy initialization Holder class used by {@code getSyncFactory}
+*/
+private static class SyncFactoryHolder {
+static final SyncFactory factory = new SyncFactory();
+}
 }
 /**
 * Internal class that defines the lazy reference construct for each registered
 * SyncProvider implementation.

changeset 7182	f3e89472692d
parent 6846	2cfd1dfb014b
child 7184	70b4f13c6f5d