Un-register the object name from JMX but this throws exceptions. Use the {@link #unregister(Object)} if you want
it to be silent.
15725
public synchronized void unregisterThrow(ObjectName objName) throws JMException {
		if (mbeanServer == null) {
			throw new JMException("JmxServer has not be started");
		}
		mbeanServer.unregisterMBean(objName);
		registeredCount--;
	}
183732
private void unbind(String jndiName) throws NamingException {
        InitialContext initialContext = new InitialContext();
        initialContext.unbind(jndiName);
    }
393058
public void unregister(Collector m) {
    synchronized (collectorsToNames) {
      List<String> names = collectorsToNames.remove(m);
      for (String name : names) {
        namesToCollectors.remove(name);
      }
    }
  }
754817
public <EventT> boolean unregister(Object key, Class<EventT> eventClass) {
    LOG.debug("[{}] Unregistering {} for {}", logPrefix, key, eventClass);
    return listeners.remove(eventClass, key);
  }
638404
def unregisterAPI(self, name):
        
        if name.startswith('public/'):
            target = 'public'
            name = name[len('public/'):]
        else:
            target = self.servicename
            name = name
        removes = [m for m in self.handler.handlers.keys() if m.target == target and m.name == name]
        for m in removes:
            self.handler.unregisterHandler(m)
1116427
def unregister(self, obj=None):
        
        if obj is None:
            self.__databases.clear()
            self.__schemas.clear()
        elif isinstance(obj, orb.Schema):
            self.__schemas.pop(obj.name(), None)
        elif isinstance(obj, orb.Database):
            if obj == self.__current_db:
                self.__current_db = None
            self.__databases.pop(obj.name(), None)
        else:
            self.__current_db = None
            self.__schemas.pop(obj, None)
            self.__databases.pop(obj, None)
51564
def unregister(self, shared_object):
        
        if shared_object not in self._shared_objects.keys():
            self.log.warning("Can not unregister shared object %s" % shared_object)
        else:
            del (self._shared_objects[shared_object])
            self.log.debug("Shared object %s got unregistered" % shared_object)
813748
static void unregister(Object value) {
        if (value != null) {
            Map<Object, Object> m = getRegistry();
            if (m != null) {
                m.remove(value);
                if (m.isEmpty()) {
                    REGISTRY.remove();
                }
            }
        }
    }
191008
@Override
    public void unregisterService(ServiceInstance<T> service) throws Exception
    {
        Entry<T> entry = services.remove(service.getId());
        internalUnregisterService(entry);
    }
944298
@Override
    public void unregister(Module module) {
        if (module == null) {
            // May happen on departure.
            return;
        }
        LOGGER.info("Removing Jackson module {}", module.getModuleName());
        synchronized (lock) {
            if (modules.remove(module)) {
                rebuildMappers();
            }
        }
    }
1023379
public void unbind() throws Throwable
   {
      if (name == null)
         throw new IllegalArgumentException("Name is null");

      if (trace)
         log.trace("Unbinding " + name);

      Context context = null;
      try
      {
         Properties properties = new Properties();
         properties.setProperty(Context.PROVIDER_URL, jndiProtocol + "://" + jndiHost + ":" + jndiPort);
         context = new InitialContext(properties);


         Util.unbind(context, name);

         objs.remove(name);

         if (log.isDebugEnabled())
            log.debug("Unbound " + name);
      }
      catch (Throwable t)
      {
         log.exceptionDuringUnbind(t);
      }
      finally
      {
         if (context != null)
         {
            try
            {
               context.close();
            }
            catch (NamingException ne)
            {
               // Ignore
            }
         }
      }
   }
775298
def unregister(self, collector):
        """"""
        with self._lock:
            for name in self._collector_to_names[collector]:
                del self._names_to_collectors[name]
            del self._collector_to_names[collector]
882374
@Override
    public final void setName(String name) {
        log.debug("Set name: {}", name);
        if (this.name == null && StringUtils.isNotBlank(name)) {
            // reset of the name is no longer allowed
            this.name = name;
            // unregister from jmx
            if (oName != null) {
                unregisterJMX();
            }
            // register
            registerJMX();
        } else {
            log.info("Scope {} name reset to: {} disallowed", this.name, name);
        }
    }
678545
function unregister (o) {
    _chain = _chain.filter(function(a) {
      return !(a.key in o);
    });

    for(var key in o)
      delete _keysIndex[key];
  }
773064
public boolean unregister(BeanId beanId, boolean dropRef) // f111627
    throws CSIException
    {
        boolean removed = false;

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            Tr.entry(tc, "unregister",
                     new Object[] { beanId, new Boolean(dropRef) }); // d181569

        ByteArray wrapperKey = beanId.getByteArray(); // d181569

        try
        {
            EJSWrapperCommon wrapperCommon = (EJSWrapperCommon) // f111627
            wrapperCache.removeAndDiscard(wrapperKey, dropRef);
            if (wrapperCommon != null) { // f111627
                removed = true;
            }
        } catch (IllegalOperationException ex)
        {
            // Object is pinned and cannot be removed from the cache
            // Swallow the exception for now, and let the Eviction thread
            // take care of the object later
            FFDCFilter.processException(ex, CLASS_NAME + ".unregister", "351", this);
            if (TraceComponent.isAnyTracingEnabled() && tc.isEventEnabled()) { // d144064
                Tr.event(tc,
                         "unregister ignoring IllegalOperationException for object "
                                         + beanId); // d181569
                Tr.event(tc, "Exception: " + ex);
            }
        } catch (DiscardException ex)
        {
            FFDCFilter.processException(ex, CLASS_NAME + ".unregister", "358", this);
            if (TraceComponent.isAnyTracingEnabled() && tc.isEventEnabled()) // d144064
                Tr.event(tc, "Unable to discard element");
        }

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            Tr.exit(tc, "unregister");

        return removed;
    }
1333968
public void unregister(Object eventListener) throws MangooEventBusException {
        Objects.requireNonNull(eventListener, Required.EVENT_LISTENER.toString());
        
        try {
            this.eventBus.unregister(eventListener);
        } catch (IllegalArgumentException e) {
            throw new MangooEventBusException(e);
        }

        if (this.listeners.get() > 0) {
            this.listeners.getAndDecrement();            
        }
    }
980368
public static void unregisterMXBean(CacheProxy<?, ?> cache, MBeanType type) {
    ObjectName objectName = getObjectName(cache, type);
    unregister(objectName);
  }