Gets the single TinyPlugz instance.

@return The TinyPlugz instance.
978891
public static TinyPlugz getInstance() {
        final TinyPlugz plugz = instance;
        Require.state(plugz != null, "TinyPlugz has not been initialized");
        return plugz;
    }
923854
public static KriptonTaskExecutor getInstance() {
		if (sInstance != null) {
			return sInstance;
		}
		synchronized (KriptonTaskExecutor.class) {
			if (sInstance == null) {
				sInstance = new KriptonTaskExecutor();
			}
		}
		return sInstance;
	}
663322
public static function getInstance()
    {
        if (self::$_instance === null) {
            self::$_instance = oxNew(__CLASS__);
        }

        return self::$_instance;
    }
45094
public static function getInstance()
    {
        static $_instance;

        if (!$_instance) {
            $_instance = new self(new AnConfig(array('service_container' => AnService::getInstance())));
            AnService::set('plg:contentfilter.chain', $_instance);
            AnService::get('com:plugins.helper')->import('contentfilter');
        }

        return $_instance;
    }
904648
public static AnnotationUtilImpl getInstance() {

    if (instance == null) {
      synchronized (AnnotationUtilImpl.class) {
        if (instance == null) {
          AnnotationUtilImpl util = new AnnotationUtilImpl();
          util.setReflectionUtil(ReflectionUtilImpl.getInstance());
          instance = util;
        }
      }
    }
    return instance;
  }
1319660
public Optional<PLZ> getPLZ() {
        if (this.plz == null) {
            return Optional.empty();
        } else {
            return Optional.of(this.plz);
        }
    }
1045964
public static ApptentiveAttachmentLoader getInstance() {
		if (instance == null) {
			synchronized (ApptentiveAttachmentLoader.class) {
				if (instance == null) {
					instance = new ApptentiveAttachmentLoader();
				}
			}
		}
		return instance;
	}
398989
public static JideRepaintManager getInstance() {

        if (JideRepaintManager.instance == null) {
            JideRepaintManager.instance = new JideRepaintManager();
        }

        return JideRepaintManager.instance;
    }
1327528
public static RecurrenceUtil getInstance() {

    if (instance == null) {
      synchronized (RecurrenceUtilImpl.class) {
        if (instance == null) {
          RecurrenceUtilImpl impl = new RecurrenceUtilImpl();
          impl.initialize();
          instance = impl;
        }
      }
    }
    return instance;
  }
786181
public static ClassDescriptorCache getInstance() {
    if (INSTANCE == null) {
      synchronized (ClassDescriptorCache.class) {
        if (INSTANCE == null) {
          INSTANCE = new ClassDescriptorCache();
        }
      }
    }
    return INSTANCE;
  }
1279429
public java.util.List<String> getInstancesToProtect() {
        if (instancesToProtect == null) {
            instancesToProtect = new com.amazonaws.internal.SdkInternalList<String>();
        }
        return instancesToProtect;
    }
1271134
public static DomUtil getInstance() {

    if (instance == null) {
      synchronized (DomUtilImpl.class) {
        if (instance == null) {
          DomUtilImpl util = new DomUtilImpl();
          util.initialize();
          instance = util;
        }
      }
    }
    return instance;
  }
933885
public static SPIProvider getInstance()
   {
      if (me == null)
      {
         final ClassLoader cl = ClassLoaderProvider.getDefaultProvider().getServerIntegrationClassLoader();
         me = SPIProviderResolver.getInstance(cl).getProvider();
      }
      return me;
   }
1240197
public static ProcessUtil getInstance() {

    if (instance == null) {
      synchronized (ProcessUtilImpl.class) {
        if (instance == null) {
          ProcessUtilImpl util = new ProcessUtilImpl();
          util.initialize();
          instance = util;
        }
      }
    }
    return instance;
  }
695869
public Plugin getPlugin(String name) {
		if (mPluginContext != null) {
			return mPluginContext.getPlugin(name);
		}
		return null;
	}
20066
public TinyBus wire(Wireable wireable) {
		assertObjectAndWorkerThread(wireable);
		Context context = mImpl.getNotNullContext();

		if (mWireables == null) {
			mWireables = new ArrayList<Wireable>();
		}
		mWireables.add(wireable);
		
		wireable.onCreate(this, context.getApplicationContext());
		wireable.assertSuperOnCreateCalled();
		
		if (context instanceof Application 
				|| context instanceof Service) {
			wireable.onStart();
		}

        // TODO, what to do with already started activity?
		return this;
	}
1189269
public static IPlatformAdapter getInstance() {
        if (svInstance != null) {
            return svInstance;
        }

        synchronized (PlatformAdapterAccessor.class) {
            if (svInstance != null) {
                // need to check again in case one thread waited on sync block while
                // another
                // initialized the instance
                return svInstance;
            }
            String adapterClassName = null;
            try {
                adapterClassName = AccessController.doPrivileged(new PrivilegedExceptionAction<String>()
                {
                    @Override
                    public String run() throws Exception
                {
                    return System.getProperty(ADAPTER_NAME_PROP);
                }
                });

                if (adapterClassName != null) {
                    // The loaded class must be an instanceof IPlatformAdapter - if not,
                    // the following
                    // line will throw a ClassCastException indicating that the specified
                    // value of the
                    // adapterName property was not a class that implemented
                    // IPlatformAdapter.
                    // This should be a very rare occurrence.
                    Class<? extends IPlatformAdapter> clazz = (Class<? extends IPlatformAdapter>) Class.forName(adapterClassName);
                    svInstance = clazz.newInstance();
                } else {
                    // Expected on Sun/Hybrid/Java 6 VMs
                    svInstance = new DefaultPlatformAdapter();
                }
            } catch (Throwable t) {
                // this means we are in a Harmony Java 7 VM, but are unable to
                // initialize
                // the Harmony platform adapter - this is a fatal error to most WAS
                // processes - must log FFDC and error message, and throw an exception
                // TODO: NLS-ize
                Tr.error(tc, "<Need new error message> - Failed to initialize {0}", new Object[] { adapterClassName });
                // Alex Ffdc.log(t, PlatformAdapterAccessor.class, CLASSNAME, "46");
                // throw new
                // IllegalStateException("Unable to initialize VM PlatformAdapter: " +
                // adapterClassName, t);
                // in this case, we need to use the default adapter -- but expect
                // erroneous behavior...
                svInstance = new DefaultPlatformAdapter();
            }
        }

        if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
            Tr.debug(tc, "chosen adapter is: " + svInstance.getClass().getName());
        }

        return svInstance;
    }