diff --git a/parsing.lucene/apichanges.xml b/parsing.lucene/apichanges.xml
--- a/parsing.lucene/apichanges.xml
+++ b/parsing.lucene/apichanges.xml
@@ -110,6 +110,24 @@
 <!-- ACTUAL CHANGES BEGIN HERE: -->
 
   <changes>
+  <change id="PriorityAccess">
+    <api name="LuceneSupport"/>
+    <summary>Added <code>IndexManager.priorityAccess</code> to suspend IO during query</summary>
+    <version major="2" minor="9"/>
+    <date day="1" month="2" year="2012"/>
+    <author login="tzezula"/>
+    <compatibility source="compatible" binary="compatible" addition="yes"/>
+    <description>
+        <p>
+            Added <code>IndexManager.priorityAccess</code> to suspend background scan
+            and checking for external changes during query. The methods <code>IndexManager.readAccess</code>
+            and <code>IndexManager.writeAccess</code> were deprecated. The <code>Index</code> is now self
+            guarded and global lock is not needed for correct synchronization.
+        </p>
+    </description>
+    <class package="org.netbeans.modules.parsing.lucene.support" name="IndexManager"/>
+    <issue number="207915"/>
+  </change>
   <change id="MemoryIndex">
     <api name="LuceneSupport"/>
     <summary>Added RAM implementation of Index</summary>
diff --git a/parsing.lucene/manifest.mf b/parsing.lucene/manifest.mf
--- a/parsing.lucene/manifest.mf
+++ b/parsing.lucene/manifest.mf
@@ -2,5 +2,5 @@
 AutoUpdate-Show-In-Client: false
 OpenIDE-Module: org.netbeans.modules.parsing.lucene/2
 OpenIDE-Module-Localizing-Bundle: org/netbeans/modules/parsing/lucene/Bundle.properties
-OpenIDE-Module-Specification-Version: 2.8
+OpenIDE-Module-Specification-Version: 2.9
 
diff --git a/parsing.lucene/src/org/netbeans/modules/parsing/lucene/support/IndexManager.java b/parsing.lucene/src/org/netbeans/modules/parsing/lucene/support/IndexManager.java
--- a/parsing.lucene/src/org/netbeans/modules/parsing/lucene/support/IndexManager.java
+++ b/parsing.lucene/src/org/netbeans/modules/parsing/lucene/support/IndexManager.java
@@ -101,7 +101,11 @@
      * @return the result of the action
      * @throws IOException when the action throws {@link IOException}
      * @throws InterruptedException when the action throws {@link InterruptedException}
+     * @deprecated The {@link Index} is self guarded and global lock acquired by
+     * {@link IndexManager#writeAccess} is not needed for correct synchronization.
+     * To suspend the scan and external changes check during the action use {@link IndexManager#priorityAccess}.
      */
+    @Deprecated
     public static <R> R writeAccess (final Action<R> action) throws IOException, InterruptedException {
         assert action != null;
         lock.writeLock().lock();                    
@@ -134,7 +138,11 @@
      * @return the result of the action
      * @throws IOException when the action throws {@link IOException}
      * @throws InterruptedException when the action throws {@link InterruptedException}
+     * @deprecated The {@link Index} is self guarded and global lock acquired by
+     * {@link IndexManager#readAccess} is not needed for correct synchronization.
+     * To suspend the scan and external changes check during the action use {@link IndexManager#priorityAccess}.
      */
+    @Deprecated
     public static <R> R readAccess (final Action<R> action) throws IOException, InterruptedException {
         assert action != null;
         suspend();
@@ -165,6 +173,42 @@
             resume();
         }
     }
+    
+    /**
+     * Runs the given action as a priority action.
+     * During the priority action scan and checking for external changes are
+     * suspended.
+     * @param action the action to be performed.
+     * @return the result of the action
+     * @throws IOException when the action throws {@link IOException}
+     * @throws InterruptedException when the action throws {@link InterruptedException}
+     * @since 2.9
+     */
+    public static <R> R priorityAccess(final Action<R> action) throws IOException, InterruptedException {
+        assert action != null;
+        suspend();
+        try {
+            return ProvidedExtensions.priorityIO(new Callable<R>() {
+                @Override
+                public R call() throws Exception {
+                    return action.run();
+                }
+            });
+        } catch (IOException ioe) {
+            //rethrow ioe
+            throw ioe;
+        } catch (InterruptedException ie) {
+            //rethrow ioe
+            throw ie;
+        } catch (RuntimeException re) {
+            //rethrow ioe
+            throw re;
+        } catch (Exception e) {
+            throw new IOException(e);
+        } finally {
+            resume();
+        }
+    }
 
     /**
      * Checks if the caller thread holds the {@link IndexManager}'s write lock