handle.sendrecv(rpc);
        if (rpc.retval != 0) {
            throw new SmbException(rpc.retval, false);
        }
        this.opened = true;
    }

    @Override
    public synchronized void close() throws IOException {
        if (this.opened) {
            this.opened = false;
            final MsrpcSamrCloseHandle rpc = new MsrpcSamrCloseHandle(this);
            this.handle.sendrecv(rpc);

  }

  private static class TestApplication extends Application {
    private final List<Thread> hooks = new ArrayList<>();

    @Override
    synchronized void addShutdownHook(Thread hook) {
      hooks.add(hook);
    }

    synchronized void shutdown() throws InterruptedException {
      for (Thread hook : hooks) {
        hook.start();
      }
      for (Thread hook : hooks) {
        hook.join();

    /**
     * Returns a {@link Logger}.
     *
     * @param clazz
     *            Class to be used as the logger category. Must not be {@literal null}.
     * @return {@link Logger}
     */
    public static synchronized Logger getLogger(final Class<?> clazz) {
        assertArgumentNotNull("clazz", clazz);

        if (!initialized) {
            initialize();
        }
        Logger logger = loggers.get(clazz);

    Subscriber s1 = Subscriber.create(bus, this, getTestSubscriberMethod("recordingMethod"));
    assertThat(s1).isInstanceOf(Subscriber.SynchronizedSubscriber.class);

    // a thread-safe method should not create a synchronized subscriber
    Subscriber s2 = Subscriber.create(bus, this, getTestSubscriberMethod("threadSafeMethod"));
    assertThat(s2).isNotInstanceOf(Subscriber.SynchronizedSubscriber.class);
  }

                        BufferCache.releaseBuffer(buffer);
                        successCount.incrementAndGet();
                    }
                } catch (Exception e) {
                    synchronized (exceptions) {
                        exceptions.add(e);
                    }
                } finally {
                    endLatch.countDown();
                }
            });
        }

        val totalExceptionBytes = bufferedSource.readInt()
        publicSuffixExceptionListBytes = bufferedSource.readByteString(totalExceptionBytes.toLong())
      }

      synchronized(this) {
        this.bytes = publicSuffixListBytes!!
        this.exceptionBytes = publicSuffixExceptionListBytes!!
      }
    } finally {
      readCompleteLatch.countDown()
    }
  }

        // Test thread safety of fillInStackTrace method
        UserRoleLoginException exception = new UserRoleLoginException(RootAction.class);

        // Create multiple threads to test synchronized method
        Thread thread1 = new Thread(() -> {
            Throwable result = exception.fillInStackTrace();
            assertNull(result);
        });

        Thread thread2 = new Thread(() -> {

    public void setLabelTypeIds(final String[] labelTypeIds) {
        this.labelTypeIds = labelTypeIds;
    }

    public List<LabelType> getLabelTypeList() {
        if (labelTypeList == null) {
            synchronized (this) {
                if (labelTypeList == null) {
                    final FessConfig fessConfig = ComponentUtil.getFessConfig();

    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.
     */