diff --git a/jaxws-ri/runtime/rt/src/main/java/com/sun/xml/ws/util/ServiceClassLoaderCacheKey.java b/jaxws-ri/runtime/rt/src/main/java/com/sun/xml/ws/util/ServiceClassLoaderCacheKey.java
new file mode 100644
index 000000000..55d66ade2
--- /dev/null
+++ b/jaxws-ri/runtime/rt/src/main/java/com/sun/xml/ws/util/ServiceClassLoaderCacheKey.java
@@ -0,0 +1,34 @@
+package com.sun.xml.ws.util;
+
+import java.util.Objects;
+
+public class ServiceClassLoaderCacheKey<T> {
+  private final Class<T> service;
+  private final ClassLoader loader;
+
+  public ServiceClassLoaderCacheKey(Class<T> service, ClassLoader loader) {
+    this.service = service;
+    this.loader = loader;
+  }
+
+  public Class<T> getService() {
+    return service;
+  }
+
+  public ClassLoader getLoader() {
+    return loader;
+  }
+
+  @Override
+  public boolean equals(Object o) {
+    if (this == o) return true;
+    if (!(o instanceof ServiceClassLoaderCacheKey)) return false;
+    ServiceClassLoaderCacheKey<?> that = (ServiceClassLoaderCacheKey<?>) o;
+    return Objects.equals(service, that.service) && Objects.equals(loader, that.loader);
+  }
+
+  @Override
+  public int hashCode() {
+    return Objects.hash(service, loader);
+  }
+}
diff --git a/jaxws-ri/runtime/rt/src/main/java/com/sun/xml/ws/util/ServiceFinder.java b/jaxws-ri/runtime/rt/src/main/java/com/sun/xml/ws/util/ServiceFinder.java
index 5a16a6f36..165dd8ac6 100644
--- a/jaxws-ri/runtime/rt/src/main/java/com/sun/xml/ws/util/ServiceFinder.java
+++ b/jaxws-ri/runtime/rt/src/main/java/com/sun/xml/ws/util/ServiceFinder.java
@@ -23,9 +23,12 @@
 import java.util.Collections;
 import java.util.Iterator;
 import java.util.List;
+import java.util.Map;
 import java.util.NoSuchElementException;
 import java.util.Objects;
 import java.util.ServiceLoader;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.locks.ReentrantLock;
 
 
 /**
@@ -116,22 +119,26 @@
 public final class ServiceFinder<T> implements Iterable<T> {
 
     private final @NotNull Class<T> serviceClass;
-    private final @NotNull ServiceLoader<T> serviceLoader;
+    private final @NotNull Iterable<T> serviceLoaderIterable;
     private final @Nullable ComponentEx component;
 
+    private static final Map<ServiceClassLoaderCacheKey, Iterable> noResultServiceLoaderCache = new ConcurrentHashMap<>();
+    private static final ReentrantLock cacheLock = new ReentrantLock();
+    private static final int MAX_CACHE_SIZE = 100;
+
     public static <T> ServiceFinder<T> find(@NotNull Class<T> service, @Nullable ClassLoader loader, Component component) {
         ClassLoader cl = loader == null ? Thread.currentThread().getContextClassLoader() : loader;
-        return find(service, component, ServiceLoader.load(service, cl));
+        return find(service, component, retrieveServiceLoaderFromCacheOrCreateNew(service, cl));
     }
 
-    public static <T> ServiceFinder<T> find(@NotNull Class<T> service, Component component, @NotNull ServiceLoader<T> serviceLoader) {
+    public static <T> ServiceFinder<T> find(@NotNull Class<T> service, Component component, @NotNull Iterable<T> serviceLoaderIterable) {
         Class<T> svc = Objects.requireNonNull(service);
-        ServiceLoader<T> sl = Objects.requireNonNull(serviceLoader);
+        Iterable<T> sl = Objects.requireNonNull(serviceLoaderIterable);
         return new ServiceFinder<>(svc, component, sl);
     }
 
     public static <T> ServiceFinder<T> find(@NotNull Class<T> service, Component component) {
-        return find(service, component, ServiceLoader.load(service, Thread.currentThread().getContextClassLoader()));
+        return find(service, component, retrieveServiceLoaderFromCacheOrCreateNew(service, Thread.currentThread().getContextClassLoader()));
     }
 
     /**
@@ -184,17 +191,17 @@ public static <T> ServiceFinder<T> find(@NotNull Class<T> service, @Nullable Cla
      * @see #find(Class, ClassLoader)
      */
     public static <T> ServiceFinder<T> find(@NotNull Class<T> service) {
-        return find(service, ServiceLoader.load(service, Thread.currentThread().getContextClassLoader()));
+        return find(service, retrieveServiceLoaderFromCacheOrCreateNew(service, Thread.currentThread().getContextClassLoader()));
     }
 
-    public static <T> ServiceFinder<T> find(@NotNull Class<T> service, @NotNull ServiceLoader<T> serviceLoader) {
-        return find(service, ContainerResolver.getInstance().getContainer(), serviceLoader);
+    public static <T> ServiceFinder<T> find(@NotNull Class<T> service, @NotNull Iterable<T> serviceLoaderIterable) {
+        return find(service, ContainerResolver.getInstance().getContainer(), serviceLoaderIterable);
     }
 
-    private ServiceFinder(Class<T> service, Component component, ServiceLoader<T> serviceLoader) {
+    private ServiceFinder(Class<T> service, Component component, Iterable<T> serviceLoaderIterable) {
         this.serviceClass = service;
         this.component = getComponentEx(component);
-        this.serviceLoader = serviceLoader;
+        this.serviceLoaderIterable = serviceLoaderIterable;
     }
 
     /**
@@ -209,7 +216,7 @@ private ServiceFinder(Class<T> service, Component component, ServiceLoader<T> se
     @Override
     @SuppressWarnings("unchecked")
     public Iterator<T> iterator() {
-        Iterator<T> it = serviceLoader.iterator();
+        Iterator<T> it = serviceLoaderIterable.iterator();
         return component != null
                 ? new CompositeIterator<>(component.getIterableSPI(serviceClass).iterator(), it)
                 : it;
@@ -238,6 +245,28 @@ private static ComponentEx getComponentEx(Component component) {
         return component != null ? new ComponentExWrapper(component) : null;
     }
 
+    private static <T> Iterable<T> retrieveServiceLoaderFromCacheOrCreateNew(Class<T> service, ClassLoader cl) {
+        ServiceClassLoaderCacheKey<T> cacheKey = new ServiceClassLoaderCacheKey<>(service, cl);
+        Iterable<T> cachedServiceLoaderIterable = noResultServiceLoaderCache.get(cacheKey);
+        if (cachedServiceLoaderIterable != null) {
+            return cachedServiceLoaderIterable;
+        }
+        ServiceLoader<T> serviceLoader = ServiceLoader.load(service, cl);
+        if (!serviceLoader.iterator().hasNext()) {
+            cacheLock.lock();
+            try {
+                if (noResultServiceLoaderCache.size() >= MAX_CACHE_SIZE) {
+                    noResultServiceLoaderCache.remove(noResultServiceLoaderCache.keySet().iterator().next());
+                }
+                noResultServiceLoaderCache.put(cacheKey, Collections.emptyList());
+            } finally {
+                cacheLock.unlock();
+            }
+            return Collections.emptyList();
+        }
+        return serviceLoader;
+    }
+
     private static class ComponentExWrapper implements ComponentEx {
 
         private final Component component;