private static class IOExceptionOccurProperties extends Properties {

        /**
         *
         */
        private static final long serialVersionUID = 1L;

        @Override
        public synchronized void load(final InputStream inStream) throws IOException {
            throw new IOException("load");
        }

    }

    /**
     * {@link org.codelibs.core.io.PropertiesUtil#load(Properties, String)}

        // When - Release session to trigger cleanup
        session.release();

        // Then - Trees should be cleared (we can't directly verify as it's internal,
        // but the cleanup code with synchronized block ensures it happens atomically)
        // The important part is that no exception occurs and the operation is atomic
    }

    /**
     * Test concurrent acquire and release operations.
     */

            }
        }

        artifactRepositories = repositorySystem.getEffectiveRepositories(artifactRepositories);

        return artifactRepositories;
    }

    @Override
    public synchronized ProjectRealmCache.CacheRecord createProjectRealm(
            MavenProject project, Model model, ProjectBuildingRequest request)

     */
    @Override
    public void refresh() throws CIFSException {
        log.debug("Refreshing JAAS credentials");
        this.cachedSubject = null;
    }

    @Override
    public synchronized Subject getSubject() {
        if (this.cachedSubject != null) {
            return this.cachedSubject;
        }

        try {
            log.debug("Logging on");
            LoginContext lc;

- Fixed a bug in ValidatingAdmissionPolicy that caused policies which were using CRD parameters to fail to synchronize ([#123080](https://github.com/kubernetes/kubernetes/pull/123080), [@alexzielenski](https://github.com/alexzielenski)) [SIG API Machinery and Testing]

            this.fp = 0L;
        } catch (final CIFSException e) {
            throw SmbException.wrap(e);
        }
    }

    /**
     * @return
     * @throws SmbException
     */
    synchronized SmbFileHandleImpl ensureOpen() throws CIFSException {
        // ensure file is open
        if (this.handle == null || !this.handle.isValid()) {
            // one extra acquire to keep this open till the stream is released

        toArrayCalled = true;
        return super.toArray(a);
      }
    }

    // Test that toArray() is used to make a defensive copy in copyOf(), so concurrently modified
    // synchronized collections can be safely copied.
    TestArrayList<String> toCopy = new TestArrayList<>();
    ImmutableSortedMultiset<String> unused =
        ImmutableSortedMultiset.copyOf(Ordering.natural(), toCopy);

  }

  static class DecoupledClassLoader extends URLClassLoader {

    public DecoupledClassLoader(URL[] urls) {
      super(urls);
    }

    @Override
    protected synchronized Class<?> loadClass(String name, boolean resolve)
        throws ClassNotFoundException {
      // Force Finalizer to load from this class loader, not its parent.
      if (name.equals(Finalizer.class.getName())) {

                            synchronized (project) {
                                cleanProjectLocalRepository(project);
                            }
                        }
                    }
                }
                break;
            case ProjectSucceeded:
            case ForkedProjectSucceeded:
                synchronized (project) {

     * every 60 seconds to balance performance with up-to-date plugin discovery.
     *
     * @return array of data store names sorted alphabetically, never null
     */
    public synchronized String[] getDataStoreNames() {
        final long now = ComponentUtil.getSystemHelper().getCurrentTimeAsLong();
        if (now - lastLoadedTime > 60000L) {
            final List<String> nameList = loadDataStoreNameList();