diff --git a/releases/snapshot-android/api/docs/com/google/common/util/concurrent/Striped.html b/releases/snapshot-android/api/docs/com/google/common/util/concurrent/Striped.html
index 6c5972ba3bc8..f2fef9460a44 100644
--- a/releases/snapshot-android/api/docs/com/google/common/util/concurrent/Striped.html
+++ b/releases/snapshot-android/api/docs/com/google/common/util/concurrent/Striped.html
@@ -403,7 +403,7 @@ <h4>lazyWeakLock</h4>
 <ul class="blockList">
 <li class="blockList">
 <h4>semaphore</h4>
-<pre class="methodSignature">public static&nbsp;<a href="Striped.html" title="class in com.google.common.util.concurrent">Striped</a>&lt;java.util.concurrent.Semaphore&gt;&nbsp;<a href="../../../../../src-html/com/google/common/util/concurrent/Striped.html#line.237">semaphore</a>&#8203;(int&nbsp;stripes,
+<pre class="methodSignature">public static&nbsp;<a href="Striped.html" title="class in com.google.common.util.concurrent">Striped</a>&lt;java.util.concurrent.Semaphore&gt;&nbsp;<a href="../../../../../src-html/com/google/common/util/concurrent/Striped.html#line.245">semaphore</a>&#8203;(int&nbsp;stripes,
                                                                 int&nbsp;permits)</pre>
 <div class="block">Creates a <code>Striped&lt;Semaphore&gt;</code> with eagerly initialized, strongly referenced semaphores,
  with the specified number of permits.</div>
@@ -422,7 +422,7 @@ <h4>semaphore</h4>
 <ul class="blockList">
 <li class="blockList">
 <h4>lazyWeakSemaphore</h4>
-<pre class="methodSignature">public static&nbsp;<a href="Striped.html" title="class in com.google.common.util.concurrent">Striped</a>&lt;java.util.concurrent.Semaphore&gt;&nbsp;<a href="../../../../../src-html/com/google/common/util/concurrent/Striped.html#line.249">lazyWeakSemaphore</a>&#8203;(int&nbsp;stripes,
+<pre class="methodSignature">public static&nbsp;<a href="Striped.html" title="class in com.google.common.util.concurrent">Striped</a>&lt;java.util.concurrent.Semaphore&gt;&nbsp;<a href="../../../../../src-html/com/google/common/util/concurrent/Striped.html#line.257">lazyWeakSemaphore</a>&#8203;(int&nbsp;stripes,
                                                                         int&nbsp;permits)</pre>
 <div class="block">Creates a <code>Striped&lt;Semaphore&gt;</code> with lazily initialized, weakly referenced semaphores,
  with the specified number of permits.</div>
@@ -441,7 +441,7 @@ <h4>lazyWeakSemaphore</h4>
 <ul class="blockList">
 <li class="blockList">
 <h4>readWriteLock</h4>
-<pre class="methodSignature">public static&nbsp;<a href="Striped.html" title="class in com.google.common.util.concurrent">Striped</a>&lt;java.util.concurrent.locks.ReadWriteLock&gt;&nbsp;<a href="../../../../../src-html/com/google/common/util/concurrent/Striped.html#line.260">readWriteLock</a>&#8203;(int&nbsp;stripes)</pre>
+<pre class="methodSignature">public static&nbsp;<a href="Striped.html" title="class in com.google.common.util.concurrent">Striped</a>&lt;java.util.concurrent.locks.ReadWriteLock&gt;&nbsp;<a href="../../../../../src-html/com/google/common/util/concurrent/Striped.html#line.268">readWriteLock</a>&#8203;(int&nbsp;stripes)</pre>
 <div class="block">Creates a <code>Striped&lt;ReadWriteLock&gt;</code> with eagerly initialized, strongly referenced
  read-write locks. Every lock is reentrant.</div>
 <dl>
@@ -458,7 +458,7 @@ <h4>readWriteLock</h4>
 <ul class="blockListLast">
 <li class="blockList">
 <h4>lazyWeakReadWriteLock</h4>
-<pre class="methodSignature">public static&nbsp;<a href="Striped.html" title="class in com.google.common.util.concurrent">Striped</a>&lt;java.util.concurrent.locks.ReadWriteLock&gt;&nbsp;<a href="../../../../../src-html/com/google/common/util/concurrent/Striped.html#line.271">lazyWeakReadWriteLock</a>&#8203;(int&nbsp;stripes)</pre>
+<pre class="methodSignature">public static&nbsp;<a href="Striped.html" title="class in com.google.common.util.concurrent">Striped</a>&lt;java.util.concurrent.locks.ReadWriteLock&gt;&nbsp;<a href="../../../../../src-html/com/google/common/util/concurrent/Striped.html#line.279">lazyWeakReadWriteLock</a>&#8203;(int&nbsp;stripes)</pre>
 <div class="block">Creates a <code>Striped&lt;ReadWriteLock&gt;</code> with lazily initialized, weakly referenced read-write
  locks. Every lock is reentrant.</div>
 <dl>
diff --git a/releases/snapshot-android/api/docs/member-search-index.zip b/releases/snapshot-android/api/docs/member-search-index.zip
index febe5cd76b66..99746d86c7b3 100644
Binary files a/releases/snapshot-android/api/docs/member-search-index.zip and b/releases/snapshot-android/api/docs/member-search-index.zip differ
diff --git a/releases/snapshot-android/api/docs/package-search-index.zip b/releases/snapshot-android/api/docs/package-search-index.zip
index bafb59700de2..c195b34173be 100644
Binary files a/releases/snapshot-android/api/docs/package-search-index.zip and b/releases/snapshot-android/api/docs/package-search-index.zip differ
diff --git a/releases/snapshot-android/api/docs/src-html/com/google/common/util/concurrent/Striped.html b/releases/snapshot-android/api/docs/src-html/com/google/common/util/concurrent/Striped.html
index ed56da265b4b..d60764cee2b3 100644
--- a/releases/snapshot-android/api/docs/src-html/com/google/common/util/concurrent/Striped.html
+++ b/releases/snapshot-android/api/docs/src-html/com/google/common/util/concurrent/Striped.html
@@ -226,332 +226,340 @@
 <span class="sourceLineNo">217</span><a id="line.217">   * @return a new {@code Striped&lt;Lock&gt;}</a>
 <span class="sourceLineNo">218</span><a id="line.218">   */</a>
 <span class="sourceLineNo">219</span><a id="line.219">  public static Striped&lt;Lock&gt; lazyWeakLock(int stripes) {</a>
-<span class="sourceLineNo">220</span><a id="line.220">    return lazy(stripes, () -&gt; new ReentrantLock(false));</a>
+<span class="sourceLineNo">220</span><a id="line.220">    return lazyWeakCustom(stripes, () -&gt; new ReentrantLock(false));</a>
 <span class="sourceLineNo">221</span><a id="line.221">  }</a>
 <span class="sourceLineNo">222</span><a id="line.222"></a>
-<span class="sourceLineNo">223</span><a id="line.223">  private static &lt;L&gt; Striped&lt;L&gt; lazy(int stripes, Supplier&lt;L&gt; supplier) {</a>
-<span class="sourceLineNo">224</span><a id="line.224">    return stripes &lt; LARGE_LAZY_CUTOFF</a>
-<span class="sourceLineNo">225</span><a id="line.225">        ? new SmallLazyStriped&lt;L&gt;(stripes, supplier)</a>
-<span class="sourceLineNo">226</span><a id="line.226">        : new LargeLazyStriped&lt;L&gt;(stripes, supplier);</a>
-<span class="sourceLineNo">227</span><a id="line.227">  }</a>
-<span class="sourceLineNo">228</span><a id="line.228"></a>
-<span class="sourceLineNo">229</span><a id="line.229">  /**</a>
-<span class="sourceLineNo">230</span><a id="line.230">   * Creates a {@code Striped&lt;Semaphore&gt;} with eagerly initialized, strongly referenced semaphores,</a>
-<span class="sourceLineNo">231</span><a id="line.231">   * with the specified number of permits.</a>
-<span class="sourceLineNo">232</span><a id="line.232">   *</a>
-<span class="sourceLineNo">233</span><a id="line.233">   * @param stripes the minimum number of stripes (semaphores) required</a>
-<span class="sourceLineNo">234</span><a id="line.234">   * @param permits the number of permits in each semaphore</a>
-<span class="sourceLineNo">235</span><a id="line.235">   * @return a new {@code Striped&lt;Semaphore&gt;}</a>
-<span class="sourceLineNo">236</span><a id="line.236">   */</a>
-<span class="sourceLineNo">237</span><a id="line.237">  public static Striped&lt;Semaphore&gt; semaphore(int stripes, int permits) {</a>
-<span class="sourceLineNo">238</span><a id="line.238">    return custom(stripes, () -&gt; new PaddedSemaphore(permits));</a>
-<span class="sourceLineNo">239</span><a id="line.239">  }</a>
-<span class="sourceLineNo">240</span><a id="line.240"></a>
-<span class="sourceLineNo">241</span><a id="line.241">  /**</a>
-<span class="sourceLineNo">242</span><a id="line.242">   * Creates a {@code Striped&lt;Semaphore&gt;} with lazily initialized, weakly referenced semaphores,</a>
-<span class="sourceLineNo">243</span><a id="line.243">   * with the specified number of permits.</a>
-<span class="sourceLineNo">244</span><a id="line.244">   *</a>
-<span class="sourceLineNo">245</span><a id="line.245">   * @param stripes the minimum number of stripes (semaphores) required</a>
-<span class="sourceLineNo">246</span><a id="line.246">   * @param permits the number of permits in each semaphore</a>
-<span class="sourceLineNo">247</span><a id="line.247">   * @return a new {@code Striped&lt;Semaphore&gt;}</a>
-<span class="sourceLineNo">248</span><a id="line.248">   */</a>
-<span class="sourceLineNo">249</span><a id="line.249">  public static Striped&lt;Semaphore&gt; lazyWeakSemaphore(int stripes, int permits) {</a>
-<span class="sourceLineNo">250</span><a id="line.250">    return lazy(stripes, () -&gt; new Semaphore(permits, false));</a>
-<span class="sourceLineNo">251</span><a id="line.251">  }</a>
-<span class="sourceLineNo">252</span><a id="line.252"></a>
-<span class="sourceLineNo">253</span><a id="line.253">  /**</a>
-<span class="sourceLineNo">254</span><a id="line.254">   * Creates a {@code Striped&lt;ReadWriteLock&gt;} with eagerly initialized, strongly referenced</a>
-<span class="sourceLineNo">255</span><a id="line.255">   * read-write locks. Every lock is reentrant.</a>
-<span class="sourceLineNo">256</span><a id="line.256">   *</a>
-<span class="sourceLineNo">257</span><a id="line.257">   * @param stripes the minimum number of stripes (locks) required</a>
-<span class="sourceLineNo">258</span><a id="line.258">   * @return a new {@code Striped&lt;ReadWriteLock&gt;}</a>
-<span class="sourceLineNo">259</span><a id="line.259">   */</a>
-<span class="sourceLineNo">260</span><a id="line.260">  public static Striped&lt;ReadWriteLock&gt; readWriteLock(int stripes) {</a>
-<span class="sourceLineNo">261</span><a id="line.261">    return custom(stripes, ReentrantReadWriteLock::new);</a>
-<span class="sourceLineNo">262</span><a id="line.262">  }</a>
-<span class="sourceLineNo">263</span><a id="line.263"></a>
-<span class="sourceLineNo">264</span><a id="line.264">  /**</a>
-<span class="sourceLineNo">265</span><a id="line.265">   * Creates a {@code Striped&lt;ReadWriteLock&gt;} with lazily initialized, weakly referenced read-write</a>
-<span class="sourceLineNo">266</span><a id="line.266">   * locks. Every lock is reentrant.</a>
-<span class="sourceLineNo">267</span><a id="line.267">   *</a>
-<span class="sourceLineNo">268</span><a id="line.268">   * @param stripes the minimum number of stripes (locks) required</a>
-<span class="sourceLineNo">269</span><a id="line.269">   * @return a new {@code Striped&lt;ReadWriteLock&gt;}</a>
-<span class="sourceLineNo">270</span><a id="line.270">   */</a>
-<span class="sourceLineNo">271</span><a id="line.271">  public static Striped&lt;ReadWriteLock&gt; lazyWeakReadWriteLock(int stripes) {</a>
-<span class="sourceLineNo">272</span><a id="line.272">    return lazy(stripes, WeakSafeReadWriteLock::new);</a>
-<span class="sourceLineNo">273</span><a id="line.273">  }</a>
-<span class="sourceLineNo">274</span><a id="line.274">  /**</a>
-<span class="sourceLineNo">275</span><a id="line.275">   * ReadWriteLock implementation whose read and write locks retain a reference back to this lock.</a>
-<span class="sourceLineNo">276</span><a id="line.276">   * Otherwise, a reference to just the read lock or just the write lock would not suffice to ensure</a>
-<span class="sourceLineNo">277</span><a id="line.277">   * the {@code ReadWriteLock} is retained.</a>
+<span class="sourceLineNo">223</span><a id="line.223">  /**</a>
+<span class="sourceLineNo">224</span><a id="line.224">   * Creates a {@code Striped&lt;L&gt;} with lazily initialized, weakly referenced locks. Every lock is</a>
+<span class="sourceLineNo">225</span><a id="line.225">   * obtained from the passed supplier.</a>
+<span class="sourceLineNo">226</span><a id="line.226">   *</a>
+<span class="sourceLineNo">227</span><a id="line.227">   * @param stripes the minimum number of stripes (locks) required</a>
+<span class="sourceLineNo">228</span><a id="line.228">   * @param supplier a {@code Supplier&lt;L&gt;} object to obtain locks from</a>
+<span class="sourceLineNo">229</span><a id="line.229">   * @return a new {@code Striped&lt;L&gt;}</a>
+<span class="sourceLineNo">230</span><a id="line.230">   */</a>
+<span class="sourceLineNo">231</span><a id="line.231">  static &lt;L&gt; Striped&lt;L&gt; lazyWeakCustom(int stripes, Supplier&lt;L&gt; supplier) {</a>
+<span class="sourceLineNo">232</span><a id="line.232">    return stripes &lt; LARGE_LAZY_CUTOFF</a>
+<span class="sourceLineNo">233</span><a id="line.233">        ? new SmallLazyStriped&lt;L&gt;(stripes, supplier)</a>
+<span class="sourceLineNo">234</span><a id="line.234">        : new LargeLazyStriped&lt;L&gt;(stripes, supplier);</a>
+<span class="sourceLineNo">235</span><a id="line.235">  }</a>
+<span class="sourceLineNo">236</span><a id="line.236"></a>
+<span class="sourceLineNo">237</span><a id="line.237">  /**</a>
+<span class="sourceLineNo">238</span><a id="line.238">   * Creates a {@code Striped&lt;Semaphore&gt;} with eagerly initialized, strongly referenced semaphores,</a>
+<span class="sourceLineNo">239</span><a id="line.239">   * with the specified number of permits.</a>
+<span class="sourceLineNo">240</span><a id="line.240">   *</a>
+<span class="sourceLineNo">241</span><a id="line.241">   * @param stripes the minimum number of stripes (semaphores) required</a>
+<span class="sourceLineNo">242</span><a id="line.242">   * @param permits the number of permits in each semaphore</a>
+<span class="sourceLineNo">243</span><a id="line.243">   * @return a new {@code Striped&lt;Semaphore&gt;}</a>
+<span class="sourceLineNo">244</span><a id="line.244">   */</a>
+<span class="sourceLineNo">245</span><a id="line.245">  public static Striped&lt;Semaphore&gt; semaphore(int stripes, int permits) {</a>
+<span class="sourceLineNo">246</span><a id="line.246">    return custom(stripes, () -&gt; new PaddedSemaphore(permits));</a>
+<span class="sourceLineNo">247</span><a id="line.247">  }</a>
+<span class="sourceLineNo">248</span><a id="line.248"></a>
+<span class="sourceLineNo">249</span><a id="line.249">  /**</a>
+<span class="sourceLineNo">250</span><a id="line.250">   * Creates a {@code Striped&lt;Semaphore&gt;} with lazily initialized, weakly referenced semaphores,</a>
+<span class="sourceLineNo">251</span><a id="line.251">   * with the specified number of permits.</a>
+<span class="sourceLineNo">252</span><a id="line.252">   *</a>
+<span class="sourceLineNo">253</span><a id="line.253">   * @param stripes the minimum number of stripes (semaphores) required</a>
+<span class="sourceLineNo">254</span><a id="line.254">   * @param permits the number of permits in each semaphore</a>
+<span class="sourceLineNo">255</span><a id="line.255">   * @return a new {@code Striped&lt;Semaphore&gt;}</a>
+<span class="sourceLineNo">256</span><a id="line.256">   */</a>
+<span class="sourceLineNo">257</span><a id="line.257">  public static Striped&lt;Semaphore&gt; lazyWeakSemaphore(int stripes, int permits) {</a>
+<span class="sourceLineNo">258</span><a id="line.258">    return lazyWeakCustom(stripes, () -&gt; new Semaphore(permits, false));</a>
+<span class="sourceLineNo">259</span><a id="line.259">  }</a>
+<span class="sourceLineNo">260</span><a id="line.260"></a>
+<span class="sourceLineNo">261</span><a id="line.261">  /**</a>
+<span class="sourceLineNo">262</span><a id="line.262">   * Creates a {@code Striped&lt;ReadWriteLock&gt;} with eagerly initialized, strongly referenced</a>
+<span class="sourceLineNo">263</span><a id="line.263">   * read-write locks. Every lock is reentrant.</a>
+<span class="sourceLineNo">264</span><a id="line.264">   *</a>
+<span class="sourceLineNo">265</span><a id="line.265">   * @param stripes the minimum number of stripes (locks) required</a>
+<span class="sourceLineNo">266</span><a id="line.266">   * @return a new {@code Striped&lt;ReadWriteLock&gt;}</a>
+<span class="sourceLineNo">267</span><a id="line.267">   */</a>
+<span class="sourceLineNo">268</span><a id="line.268">  public static Striped&lt;ReadWriteLock&gt; readWriteLock(int stripes) {</a>
+<span class="sourceLineNo">269</span><a id="line.269">    return custom(stripes, ReentrantReadWriteLock::new);</a>
+<span class="sourceLineNo">270</span><a id="line.270">  }</a>
+<span class="sourceLineNo">271</span><a id="line.271"></a>
+<span class="sourceLineNo">272</span><a id="line.272">  /**</a>
+<span class="sourceLineNo">273</span><a id="line.273">   * Creates a {@code Striped&lt;ReadWriteLock&gt;} with lazily initialized, weakly referenced read-write</a>
+<span class="sourceLineNo">274</span><a id="line.274">   * locks. Every lock is reentrant.</a>
+<span class="sourceLineNo">275</span><a id="line.275">   *</a>
+<span class="sourceLineNo">276</span><a id="line.276">   * @param stripes the minimum number of stripes (locks) required</a>
+<span class="sourceLineNo">277</span><a id="line.277">   * @return a new {@code Striped&lt;ReadWriteLock&gt;}</a>
 <span class="sourceLineNo">278</span><a id="line.278">   */</a>
-<span class="sourceLineNo">279</span><a id="line.279">  private static final class WeakSafeReadWriteLock implements ReadWriteLock {</a>
-<span class="sourceLineNo">280</span><a id="line.280">    private final ReadWriteLock delegate;</a>
-<span class="sourceLineNo">281</span><a id="line.281"></a>
-<span class="sourceLineNo">282</span><a id="line.282">    WeakSafeReadWriteLock() {</a>
-<span class="sourceLineNo">283</span><a id="line.283">      this.delegate = new ReentrantReadWriteLock();</a>
-<span class="sourceLineNo">284</span><a id="line.284">    }</a>
-<span class="sourceLineNo">285</span><a id="line.285"></a>
-<span class="sourceLineNo">286</span><a id="line.286">    @Override</a>
-<span class="sourceLineNo">287</span><a id="line.287">    public Lock readLock() {</a>
-<span class="sourceLineNo">288</span><a id="line.288">      return new WeakSafeLock(delegate.readLock(), this);</a>
-<span class="sourceLineNo">289</span><a id="line.289">    }</a>
-<span class="sourceLineNo">290</span><a id="line.290"></a>
-<span class="sourceLineNo">291</span><a id="line.291">    @Override</a>
-<span class="sourceLineNo">292</span><a id="line.292">    public Lock writeLock() {</a>
-<span class="sourceLineNo">293</span><a id="line.293">      return new WeakSafeLock(delegate.writeLock(), this);</a>
-<span class="sourceLineNo">294</span><a id="line.294">    }</a>
-<span class="sourceLineNo">295</span><a id="line.295">  }</a>
-<span class="sourceLineNo">296</span><a id="line.296"></a>
-<span class="sourceLineNo">297</span><a id="line.297">  /** Lock object that ensures a strong reference is retained to a specified object. */</a>
-<span class="sourceLineNo">298</span><a id="line.298">  private static final class WeakSafeLock extends ForwardingLock {</a>
-<span class="sourceLineNo">299</span><a id="line.299">    private final Lock delegate;</a>
-<span class="sourceLineNo">300</span><a id="line.300"></a>
-<span class="sourceLineNo">301</span><a id="line.301">    @SuppressWarnings("unused")</a>
-<span class="sourceLineNo">302</span><a id="line.302">    private final WeakSafeReadWriteLock strongReference;</a>
-<span class="sourceLineNo">303</span><a id="line.303"></a>
-<span class="sourceLineNo">304</span><a id="line.304">    WeakSafeLock(Lock delegate, WeakSafeReadWriteLock strongReference) {</a>
-<span class="sourceLineNo">305</span><a id="line.305">      this.delegate = delegate;</a>
-<span class="sourceLineNo">306</span><a id="line.306">      this.strongReference = strongReference;</a>
-<span class="sourceLineNo">307</span><a id="line.307">    }</a>
+<span class="sourceLineNo">279</span><a id="line.279">  public static Striped&lt;ReadWriteLock&gt; lazyWeakReadWriteLock(int stripes) {</a>
+<span class="sourceLineNo">280</span><a id="line.280">    return lazyWeakCustom(stripes, WeakSafeReadWriteLock::new);</a>
+<span class="sourceLineNo">281</span><a id="line.281">  }</a>
+<span class="sourceLineNo">282</span><a id="line.282">  /**</a>
+<span class="sourceLineNo">283</span><a id="line.283">   * ReadWriteLock implementation whose read and write locks retain a reference back to this lock.</a>
+<span class="sourceLineNo">284</span><a id="line.284">   * Otherwise, a reference to just the read lock or just the write lock would not suffice to ensure</a>
+<span class="sourceLineNo">285</span><a id="line.285">   * the {@code ReadWriteLock} is retained.</a>
+<span class="sourceLineNo">286</span><a id="line.286">   */</a>
+<span class="sourceLineNo">287</span><a id="line.287">  private static final class WeakSafeReadWriteLock implements ReadWriteLock {</a>
+<span class="sourceLineNo">288</span><a id="line.288">    private final ReadWriteLock delegate;</a>
+<span class="sourceLineNo">289</span><a id="line.289"></a>
+<span class="sourceLineNo">290</span><a id="line.290">    WeakSafeReadWriteLock() {</a>
+<span class="sourceLineNo">291</span><a id="line.291">      this.delegate = new ReentrantReadWriteLock();</a>
+<span class="sourceLineNo">292</span><a id="line.292">    }</a>
+<span class="sourceLineNo">293</span><a id="line.293"></a>
+<span class="sourceLineNo">294</span><a id="line.294">    @Override</a>
+<span class="sourceLineNo">295</span><a id="line.295">    public Lock readLock() {</a>
+<span class="sourceLineNo">296</span><a id="line.296">      return new WeakSafeLock(delegate.readLock(), this);</a>
+<span class="sourceLineNo">297</span><a id="line.297">    }</a>
+<span class="sourceLineNo">298</span><a id="line.298"></a>
+<span class="sourceLineNo">299</span><a id="line.299">    @Override</a>
+<span class="sourceLineNo">300</span><a id="line.300">    public Lock writeLock() {</a>
+<span class="sourceLineNo">301</span><a id="line.301">      return new WeakSafeLock(delegate.writeLock(), this);</a>
+<span class="sourceLineNo">302</span><a id="line.302">    }</a>
+<span class="sourceLineNo">303</span><a id="line.303">  }</a>
+<span class="sourceLineNo">304</span><a id="line.304"></a>
+<span class="sourceLineNo">305</span><a id="line.305">  /** Lock object that ensures a strong reference is retained to a specified object. */</a>
+<span class="sourceLineNo">306</span><a id="line.306">  private static final class WeakSafeLock extends ForwardingLock {</a>
+<span class="sourceLineNo">307</span><a id="line.307">    private final Lock delegate;</a>
 <span class="sourceLineNo">308</span><a id="line.308"></a>
-<span class="sourceLineNo">309</span><a id="line.309">    @Override</a>
-<span class="sourceLineNo">310</span><a id="line.310">    Lock delegate() {</a>
-<span class="sourceLineNo">311</span><a id="line.311">      return delegate;</a>
-<span class="sourceLineNo">312</span><a id="line.312">    }</a>
-<span class="sourceLineNo">313</span><a id="line.313"></a>
-<span class="sourceLineNo">314</span><a id="line.314">    @Override</a>
-<span class="sourceLineNo">315</span><a id="line.315">    public Condition newCondition() {</a>
-<span class="sourceLineNo">316</span><a id="line.316">      return new WeakSafeCondition(delegate.newCondition(), strongReference);</a>
-<span class="sourceLineNo">317</span><a id="line.317">    }</a>
-<span class="sourceLineNo">318</span><a id="line.318">  }</a>
-<span class="sourceLineNo">319</span><a id="line.319"></a>
-<span class="sourceLineNo">320</span><a id="line.320">  /** Condition object that ensures a strong reference is retained to a specified object. */</a>
-<span class="sourceLineNo">321</span><a id="line.321">  private static final class WeakSafeCondition extends ForwardingCondition {</a>
-<span class="sourceLineNo">322</span><a id="line.322">    private final Condition delegate;</a>
-<span class="sourceLineNo">323</span><a id="line.323"></a>
-<span class="sourceLineNo">324</span><a id="line.324">    @SuppressWarnings("unused")</a>
-<span class="sourceLineNo">325</span><a id="line.325">    private final WeakSafeReadWriteLock strongReference;</a>
-<span class="sourceLineNo">326</span><a id="line.326"></a>
-<span class="sourceLineNo">327</span><a id="line.327">    WeakSafeCondition(Condition delegate, WeakSafeReadWriteLock strongReference) {</a>
-<span class="sourceLineNo">328</span><a id="line.328">      this.delegate = delegate;</a>
-<span class="sourceLineNo">329</span><a id="line.329">      this.strongReference = strongReference;</a>
-<span class="sourceLineNo">330</span><a id="line.330">    }</a>
+<span class="sourceLineNo">309</span><a id="line.309">    @SuppressWarnings("unused")</a>
+<span class="sourceLineNo">310</span><a id="line.310">    private final WeakSafeReadWriteLock strongReference;</a>
+<span class="sourceLineNo">311</span><a id="line.311"></a>
+<span class="sourceLineNo">312</span><a id="line.312">    WeakSafeLock(Lock delegate, WeakSafeReadWriteLock strongReference) {</a>
+<span class="sourceLineNo">313</span><a id="line.313">      this.delegate = delegate;</a>
+<span class="sourceLineNo">314</span><a id="line.314">      this.strongReference = strongReference;</a>
+<span class="sourceLineNo">315</span><a id="line.315">    }</a>
+<span class="sourceLineNo">316</span><a id="line.316"></a>
+<span class="sourceLineNo">317</span><a id="line.317">    @Override</a>
+<span class="sourceLineNo">318</span><a id="line.318">    Lock delegate() {</a>
+<span class="sourceLineNo">319</span><a id="line.319">      return delegate;</a>
+<span class="sourceLineNo">320</span><a id="line.320">    }</a>
+<span class="sourceLineNo">321</span><a id="line.321"></a>
+<span class="sourceLineNo">322</span><a id="line.322">    @Override</a>
+<span class="sourceLineNo">323</span><a id="line.323">    public Condition newCondition() {</a>
+<span class="sourceLineNo">324</span><a id="line.324">      return new WeakSafeCondition(delegate.newCondition(), strongReference);</a>
+<span class="sourceLineNo">325</span><a id="line.325">    }</a>
+<span class="sourceLineNo">326</span><a id="line.326">  }</a>
+<span class="sourceLineNo">327</span><a id="line.327"></a>
+<span class="sourceLineNo">328</span><a id="line.328">  /** Condition object that ensures a strong reference is retained to a specified object. */</a>
+<span class="sourceLineNo">329</span><a id="line.329">  private static final class WeakSafeCondition extends ForwardingCondition {</a>
+<span class="sourceLineNo">330</span><a id="line.330">    private final Condition delegate;</a>
 <span class="sourceLineNo">331</span><a id="line.331"></a>
-<span class="sourceLineNo">332</span><a id="line.332">    @Override</a>
-<span class="sourceLineNo">333</span><a id="line.333">    Condition delegate() {</a>
-<span class="sourceLineNo">334</span><a id="line.334">      return delegate;</a>
-<span class="sourceLineNo">335</span><a id="line.335">    }</a>
-<span class="sourceLineNo">336</span><a id="line.336">  }</a>
-<span class="sourceLineNo">337</span><a id="line.337"></a>
-<span class="sourceLineNo">338</span><a id="line.338">  private abstract static class PowerOfTwoStriped&lt;L&gt; extends Striped&lt;L&gt; {</a>
-<span class="sourceLineNo">339</span><a id="line.339">    /** Capacity (power of two) minus one, for fast mod evaluation */</a>
-<span class="sourceLineNo">340</span><a id="line.340">    final int mask;</a>
-<span class="sourceLineNo">341</span><a id="line.341"></a>
-<span class="sourceLineNo">342</span><a id="line.342">    PowerOfTwoStriped(int stripes) {</a>
-<span class="sourceLineNo">343</span><a id="line.343">      Preconditions.checkArgument(stripes &gt; 0, "Stripes must be positive");</a>
-<span class="sourceLineNo">344</span><a id="line.344">      this.mask = stripes &gt; Ints.MAX_POWER_OF_TWO ? ALL_SET : ceilToPowerOfTwo(stripes) - 1;</a>
-<span class="sourceLineNo">345</span><a id="line.345">    }</a>
-<span class="sourceLineNo">346</span><a id="line.346"></a>
-<span class="sourceLineNo">347</span><a id="line.347">    @Override</a>
-<span class="sourceLineNo">348</span><a id="line.348">    final int indexFor(Object key) {</a>
-<span class="sourceLineNo">349</span><a id="line.349">      int hash = smear(key.hashCode());</a>
-<span class="sourceLineNo">350</span><a id="line.350">      return hash &amp; mask;</a>
-<span class="sourceLineNo">351</span><a id="line.351">    }</a>
-<span class="sourceLineNo">352</span><a id="line.352"></a>
-<span class="sourceLineNo">353</span><a id="line.353">    @Override</a>
-<span class="sourceLineNo">354</span><a id="line.354">    public final L get(Object key) {</a>
-<span class="sourceLineNo">355</span><a id="line.355">      return getAt(indexFor(key));</a>
-<span class="sourceLineNo">356</span><a id="line.356">    }</a>
-<span class="sourceLineNo">357</span><a id="line.357">  }</a>
-<span class="sourceLineNo">358</span><a id="line.358"></a>
-<span class="sourceLineNo">359</span><a id="line.359">  /**</a>
-<span class="sourceLineNo">360</span><a id="line.360">   * Implementation of Striped where 2^k stripes are represented as an array of the same length,</a>
-<span class="sourceLineNo">361</span><a id="line.361">   * eagerly initialized.</a>
-<span class="sourceLineNo">362</span><a id="line.362">   */</a>
-<span class="sourceLineNo">363</span><a id="line.363">  private static class CompactStriped&lt;L&gt; extends PowerOfTwoStriped&lt;L&gt; {</a>
-<span class="sourceLineNo">364</span><a id="line.364">    /** Size is a power of two. */</a>
-<span class="sourceLineNo">365</span><a id="line.365">    private final Object[] array;</a>
+<span class="sourceLineNo">332</span><a id="line.332">    @SuppressWarnings("unused")</a>
+<span class="sourceLineNo">333</span><a id="line.333">    private final WeakSafeReadWriteLock strongReference;</a>
+<span class="sourceLineNo">334</span><a id="line.334"></a>
+<span class="sourceLineNo">335</span><a id="line.335">    WeakSafeCondition(Condition delegate, WeakSafeReadWriteLock strongReference) {</a>
+<span class="sourceLineNo">336</span><a id="line.336">      this.delegate = delegate;</a>
+<span class="sourceLineNo">337</span><a id="line.337">      this.strongReference = strongReference;</a>
+<span class="sourceLineNo">338</span><a id="line.338">    }</a>
+<span class="sourceLineNo">339</span><a id="line.339"></a>
+<span class="sourceLineNo">340</span><a id="line.340">    @Override</a>
+<span class="sourceLineNo">341</span><a id="line.341">    Condition delegate() {</a>
+<span class="sourceLineNo">342</span><a id="line.342">      return delegate;</a>
+<span class="sourceLineNo">343</span><a id="line.343">    }</a>
+<span class="sourceLineNo">344</span><a id="line.344">  }</a>
+<span class="sourceLineNo">345</span><a id="line.345"></a>
+<span class="sourceLineNo">346</span><a id="line.346">  private abstract static class PowerOfTwoStriped&lt;L&gt; extends Striped&lt;L&gt; {</a>
+<span class="sourceLineNo">347</span><a id="line.347">    /** Capacity (power of two) minus one, for fast mod evaluation */</a>
+<span class="sourceLineNo">348</span><a id="line.348">    final int mask;</a>
+<span class="sourceLineNo">349</span><a id="line.349"></a>
+<span class="sourceLineNo">350</span><a id="line.350">    PowerOfTwoStriped(int stripes) {</a>
+<span class="sourceLineNo">351</span><a id="line.351">      Preconditions.checkArgument(stripes &gt; 0, "Stripes must be positive");</a>
+<span class="sourceLineNo">352</span><a id="line.352">      this.mask = stripes &gt; Ints.MAX_POWER_OF_TWO ? ALL_SET : ceilToPowerOfTwo(stripes) - 1;</a>
+<span class="sourceLineNo">353</span><a id="line.353">    }</a>
+<span class="sourceLineNo">354</span><a id="line.354"></a>
+<span class="sourceLineNo">355</span><a id="line.355">    @Override</a>
+<span class="sourceLineNo">356</span><a id="line.356">    final int indexFor(Object key) {</a>
+<span class="sourceLineNo">357</span><a id="line.357">      int hash = smear(key.hashCode());</a>
+<span class="sourceLineNo">358</span><a id="line.358">      return hash &amp; mask;</a>
+<span class="sourceLineNo">359</span><a id="line.359">    }</a>
+<span class="sourceLineNo">360</span><a id="line.360"></a>
+<span class="sourceLineNo">361</span><a id="line.361">    @Override</a>
+<span class="sourceLineNo">362</span><a id="line.362">    public final L get(Object key) {</a>
+<span class="sourceLineNo">363</span><a id="line.363">      return getAt(indexFor(key));</a>
+<span class="sourceLineNo">364</span><a id="line.364">    }</a>
+<span class="sourceLineNo">365</span><a id="line.365">  }</a>
 <span class="sourceLineNo">366</span><a id="line.366"></a>
-<span class="sourceLineNo">367</span><a id="line.367">    private CompactStriped(int stripes, Supplier&lt;L&gt; supplier) {</a>
-<span class="sourceLineNo">368</span><a id="line.368">      super(stripes);</a>
-<span class="sourceLineNo">369</span><a id="line.369">      Preconditions.checkArgument(stripes &lt;= Ints.MAX_POWER_OF_TWO, "Stripes must be &lt;= 2^30)");</a>
-<span class="sourceLineNo">370</span><a id="line.370"></a>
-<span class="sourceLineNo">371</span><a id="line.371">      this.array = new Object[mask + 1];</a>
-<span class="sourceLineNo">372</span><a id="line.372">      for (int i = 0; i &lt; array.length; i++) {</a>
-<span class="sourceLineNo">373</span><a id="line.373">        array[i] = supplier.get();</a>
-<span class="sourceLineNo">374</span><a id="line.374">      }</a>
-<span class="sourceLineNo">375</span><a id="line.375">    }</a>
-<span class="sourceLineNo">376</span><a id="line.376"></a>
-<span class="sourceLineNo">377</span><a id="line.377">    @SuppressWarnings("unchecked") // we only put L's in the array</a>
-<span class="sourceLineNo">378</span><a id="line.378">    @Override</a>
-<span class="sourceLineNo">379</span><a id="line.379">    public L getAt(int index) {</a>
-<span class="sourceLineNo">380</span><a id="line.380">      return (L) array[index];</a>
-<span class="sourceLineNo">381</span><a id="line.381">    }</a>
-<span class="sourceLineNo">382</span><a id="line.382"></a>
-<span class="sourceLineNo">383</span><a id="line.383">    @Override</a>
-<span class="sourceLineNo">384</span><a id="line.384">    public int size() {</a>
-<span class="sourceLineNo">385</span><a id="line.385">      return array.length;</a>
-<span class="sourceLineNo">386</span><a id="line.386">    }</a>
-<span class="sourceLineNo">387</span><a id="line.387">  }</a>
-<span class="sourceLineNo">388</span><a id="line.388"></a>
-<span class="sourceLineNo">389</span><a id="line.389">  /**</a>
-<span class="sourceLineNo">390</span><a id="line.390">   * Implementation of Striped where up to 2^k stripes can be represented, using an</a>
-<span class="sourceLineNo">391</span><a id="line.391">   * AtomicReferenceArray of size 2^k. To map a user key into a stripe, we take a k-bit slice of the</a>
-<span class="sourceLineNo">392</span><a id="line.392">   * user key's (smeared) hashCode(). The stripes are lazily initialized and are weakly referenced.</a>
-<span class="sourceLineNo">393</span><a id="line.393">   */</a>
-<span class="sourceLineNo">394</span><a id="line.394">  @VisibleForTesting</a>
-<span class="sourceLineNo">395</span><a id="line.395">  static class SmallLazyStriped&lt;L&gt; extends PowerOfTwoStriped&lt;L&gt; {</a>
-<span class="sourceLineNo">396</span><a id="line.396">    final AtomicReferenceArray&lt;@Nullable ArrayReference&lt;? extends L&gt;&gt; locks;</a>
-<span class="sourceLineNo">397</span><a id="line.397">    final Supplier&lt;L&gt; supplier;</a>
-<span class="sourceLineNo">398</span><a id="line.398">    final int size;</a>
-<span class="sourceLineNo">399</span><a id="line.399">    final ReferenceQueue&lt;L&gt; queue = new ReferenceQueue&lt;&gt;();</a>
-<span class="sourceLineNo">400</span><a id="line.400"></a>
-<span class="sourceLineNo">401</span><a id="line.401">    SmallLazyStriped(int stripes, Supplier&lt;L&gt; supplier) {</a>
-<span class="sourceLineNo">402</span><a id="line.402">      super(stripes);</a>
-<span class="sourceLineNo">403</span><a id="line.403">      this.size = (mask == ALL_SET) ? Integer.MAX_VALUE : mask + 1;</a>
-<span class="sourceLineNo">404</span><a id="line.404">      this.locks = new AtomicReferenceArray&lt;&gt;(size);</a>
-<span class="sourceLineNo">405</span><a id="line.405">      this.supplier = supplier;</a>
-<span class="sourceLineNo">406</span><a id="line.406">    }</a>
-<span class="sourceLineNo">407</span><a id="line.407"></a>
-<span class="sourceLineNo">408</span><a id="line.408">    @Override</a>
-<span class="sourceLineNo">409</span><a id="line.409">    public L getAt(int index) {</a>
-<span class="sourceLineNo">410</span><a id="line.410">      if (size != Integer.MAX_VALUE) {</a>
-<span class="sourceLineNo">411</span><a id="line.411">        Preconditions.checkElementIndex(index, size());</a>
-<span class="sourceLineNo">412</span><a id="line.412">      } // else no check necessary, all index values are valid</a>
-<span class="sourceLineNo">413</span><a id="line.413">      ArrayReference&lt;? extends L&gt; existingRef = locks.get(index);</a>
-<span class="sourceLineNo">414</span><a id="line.414">      L existing = existingRef == null ? null : existingRef.get();</a>
-<span class="sourceLineNo">415</span><a id="line.415">      if (existing != null) {</a>
-<span class="sourceLineNo">416</span><a id="line.416">        return existing;</a>
-<span class="sourceLineNo">417</span><a id="line.417">      }</a>
-<span class="sourceLineNo">418</span><a id="line.418">      L created = supplier.get();</a>
-<span class="sourceLineNo">419</span><a id="line.419">      ArrayReference&lt;L&gt; newRef = new ArrayReference&lt;&gt;(created, index, queue);</a>
-<span class="sourceLineNo">420</span><a id="line.420">      while (!locks.compareAndSet(index, existingRef, newRef)) {</a>
-<span class="sourceLineNo">421</span><a id="line.421">        // we raced, we need to re-read and try again</a>
-<span class="sourceLineNo">422</span><a id="line.422">        existingRef = locks.get(index);</a>
-<span class="sourceLineNo">423</span><a id="line.423">        existing = existingRef == null ? null : existingRef.get();</a>
-<span class="sourceLineNo">424</span><a id="line.424">        if (existing != null) {</a>
-<span class="sourceLineNo">425</span><a id="line.425">          return existing;</a>
-<span class="sourceLineNo">426</span><a id="line.426">        }</a>
-<span class="sourceLineNo">427</span><a id="line.427">      }</a>
-<span class="sourceLineNo">428</span><a id="line.428">      drainQueue();</a>
-<span class="sourceLineNo">429</span><a id="line.429">      return created;</a>
-<span class="sourceLineNo">430</span><a id="line.430">    }</a>
-<span class="sourceLineNo">431</span><a id="line.431"></a>
-<span class="sourceLineNo">432</span><a id="line.432">    // N.B. Draining the queue is only necessary to ensure that we don't accumulate empty references</a>
-<span class="sourceLineNo">433</span><a id="line.433">    // in the array. We could skip this if we decide we don't care about holding on to Reference</a>
-<span class="sourceLineNo">434</span><a id="line.434">    // objects indefinitely.</a>
-<span class="sourceLineNo">435</span><a id="line.435">    private void drainQueue() {</a>
-<span class="sourceLineNo">436</span><a id="line.436">      Reference&lt;? extends L&gt; ref;</a>
-<span class="sourceLineNo">437</span><a id="line.437">      while ((ref = queue.poll()) != null) {</a>
-<span class="sourceLineNo">438</span><a id="line.438">        // We only ever register ArrayReferences with the queue so this is always safe.</a>
-<span class="sourceLineNo">439</span><a id="line.439">        ArrayReference&lt;? extends L&gt; arrayRef = (ArrayReference&lt;? extends L&gt;) ref;</a>
-<span class="sourceLineNo">440</span><a id="line.440">        // Try to clear out the array slot, n.b. if we fail that is fine, in either case the</a>
-<span class="sourceLineNo">441</span><a id="line.441">        // arrayRef will be out of the array after this step.</a>
-<span class="sourceLineNo">442</span><a id="line.442">        locks.compareAndSet(arrayRef.index, arrayRef, null);</a>
-<span class="sourceLineNo">443</span><a id="line.443">      }</a>
-<span class="sourceLineNo">444</span><a id="line.444">    }</a>
-<span class="sourceLineNo">445</span><a id="line.445"></a>
-<span class="sourceLineNo">446</span><a id="line.446">    @Override</a>
-<span class="sourceLineNo">447</span><a id="line.447">    public int size() {</a>
-<span class="sourceLineNo">448</span><a id="line.448">      return size;</a>
-<span class="sourceLineNo">449</span><a id="line.449">    }</a>
-<span class="sourceLineNo">450</span><a id="line.450"></a>
-<span class="sourceLineNo">451</span><a id="line.451">    private static final class ArrayReference&lt;L&gt; extends WeakReference&lt;L&gt; {</a>
-<span class="sourceLineNo">452</span><a id="line.452">      final int index;</a>
+<span class="sourceLineNo">367</span><a id="line.367">  /**</a>
+<span class="sourceLineNo">368</span><a id="line.368">   * Implementation of Striped where 2^k stripes are represented as an array of the same length,</a>
+<span class="sourceLineNo">369</span><a id="line.369">   * eagerly initialized.</a>
+<span class="sourceLineNo">370</span><a id="line.370">   */</a>
+<span class="sourceLineNo">371</span><a id="line.371">  private static class CompactStriped&lt;L&gt; extends PowerOfTwoStriped&lt;L&gt; {</a>
+<span class="sourceLineNo">372</span><a id="line.372">    /** Size is a power of two. */</a>
+<span class="sourceLineNo">373</span><a id="line.373">    private final Object[] array;</a>
+<span class="sourceLineNo">374</span><a id="line.374"></a>
+<span class="sourceLineNo">375</span><a id="line.375">    private CompactStriped(int stripes, Supplier&lt;L&gt; supplier) {</a>
+<span class="sourceLineNo">376</span><a id="line.376">      super(stripes);</a>
+<span class="sourceLineNo">377</span><a id="line.377">      Preconditions.checkArgument(stripes &lt;= Ints.MAX_POWER_OF_TWO, "Stripes must be &lt;= 2^30)");</a>
+<span class="sourceLineNo">378</span><a id="line.378"></a>
+<span class="sourceLineNo">379</span><a id="line.379">      this.array = new Object[mask + 1];</a>
+<span class="sourceLineNo">380</span><a id="line.380">      for (int i = 0; i &lt; array.length; i++) {</a>
+<span class="sourceLineNo">381</span><a id="line.381">        array[i] = supplier.get();</a>
+<span class="sourceLineNo">382</span><a id="line.382">      }</a>
+<span class="sourceLineNo">383</span><a id="line.383">    }</a>
+<span class="sourceLineNo">384</span><a id="line.384"></a>
+<span class="sourceLineNo">385</span><a id="line.385">    @SuppressWarnings("unchecked") // we only put L's in the array</a>
+<span class="sourceLineNo">386</span><a id="line.386">    @Override</a>
+<span class="sourceLineNo">387</span><a id="line.387">    public L getAt(int index) {</a>
+<span class="sourceLineNo">388</span><a id="line.388">      return (L) array[index];</a>
+<span class="sourceLineNo">389</span><a id="line.389">    }</a>
+<span class="sourceLineNo">390</span><a id="line.390"></a>
+<span class="sourceLineNo">391</span><a id="line.391">    @Override</a>
+<span class="sourceLineNo">392</span><a id="line.392">    public int size() {</a>
+<span class="sourceLineNo">393</span><a id="line.393">      return array.length;</a>
+<span class="sourceLineNo">394</span><a id="line.394">    }</a>
+<span class="sourceLineNo">395</span><a id="line.395">  }</a>
+<span class="sourceLineNo">396</span><a id="line.396"></a>
+<span class="sourceLineNo">397</span><a id="line.397">  /**</a>
+<span class="sourceLineNo">398</span><a id="line.398">   * Implementation of Striped where up to 2^k stripes can be represented, using an</a>
+<span class="sourceLineNo">399</span><a id="line.399">   * AtomicReferenceArray of size 2^k. To map a user key into a stripe, we take a k-bit slice of the</a>
+<span class="sourceLineNo">400</span><a id="line.400">   * user key's (smeared) hashCode(). The stripes are lazily initialized and are weakly referenced.</a>
+<span class="sourceLineNo">401</span><a id="line.401">   */</a>
+<span class="sourceLineNo">402</span><a id="line.402">  @VisibleForTesting</a>
+<span class="sourceLineNo">403</span><a id="line.403">  static class SmallLazyStriped&lt;L&gt; extends PowerOfTwoStriped&lt;L&gt; {</a>
+<span class="sourceLineNo">404</span><a id="line.404">    final AtomicReferenceArray&lt;@Nullable ArrayReference&lt;? extends L&gt;&gt; locks;</a>
+<span class="sourceLineNo">405</span><a id="line.405">    final Supplier&lt;L&gt; supplier;</a>
+<span class="sourceLineNo">406</span><a id="line.406">    final int size;</a>
+<span class="sourceLineNo">407</span><a id="line.407">    final ReferenceQueue&lt;L&gt; queue = new ReferenceQueue&lt;&gt;();</a>
+<span class="sourceLineNo">408</span><a id="line.408"></a>
+<span class="sourceLineNo">409</span><a id="line.409">    SmallLazyStriped(int stripes, Supplier&lt;L&gt; supplier) {</a>
+<span class="sourceLineNo">410</span><a id="line.410">      super(stripes);</a>
+<span class="sourceLineNo">411</span><a id="line.411">      this.size = (mask == ALL_SET) ? Integer.MAX_VALUE : mask + 1;</a>
+<span class="sourceLineNo">412</span><a id="line.412">      this.locks = new AtomicReferenceArray&lt;&gt;(size);</a>
+<span class="sourceLineNo">413</span><a id="line.413">      this.supplier = supplier;</a>
+<span class="sourceLineNo">414</span><a id="line.414">    }</a>
+<span class="sourceLineNo">415</span><a id="line.415"></a>
+<span class="sourceLineNo">416</span><a id="line.416">    @Override</a>
+<span class="sourceLineNo">417</span><a id="line.417">    public L getAt(int index) {</a>
+<span class="sourceLineNo">418</span><a id="line.418">      if (size != Integer.MAX_VALUE) {</a>
+<span class="sourceLineNo">419</span><a id="line.419">        Preconditions.checkElementIndex(index, size());</a>
+<span class="sourceLineNo">420</span><a id="line.420">      } // else no check necessary, all index values are valid</a>
+<span class="sourceLineNo">421</span><a id="line.421">      ArrayReference&lt;? extends L&gt; existingRef = locks.get(index);</a>
+<span class="sourceLineNo">422</span><a id="line.422">      L existing = existingRef == null ? null : existingRef.get();</a>
+<span class="sourceLineNo">423</span><a id="line.423">      if (existing != null) {</a>
+<span class="sourceLineNo">424</span><a id="line.424">        return existing;</a>
+<span class="sourceLineNo">425</span><a id="line.425">      }</a>
+<span class="sourceLineNo">426</span><a id="line.426">      L created = supplier.get();</a>
+<span class="sourceLineNo">427</span><a id="line.427">      ArrayReference&lt;L&gt; newRef = new ArrayReference&lt;&gt;(created, index, queue);</a>
+<span class="sourceLineNo">428</span><a id="line.428">      while (!locks.compareAndSet(index, existingRef, newRef)) {</a>
+<span class="sourceLineNo">429</span><a id="line.429">        // we raced, we need to re-read and try again</a>
+<span class="sourceLineNo">430</span><a id="line.430">        existingRef = locks.get(index);</a>
+<span class="sourceLineNo">431</span><a id="line.431">        existing = existingRef == null ? null : existingRef.get();</a>
+<span class="sourceLineNo">432</span><a id="line.432">        if (existing != null) {</a>
+<span class="sourceLineNo">433</span><a id="line.433">          return existing;</a>
+<span class="sourceLineNo">434</span><a id="line.434">        }</a>
+<span class="sourceLineNo">435</span><a id="line.435">      }</a>
+<span class="sourceLineNo">436</span><a id="line.436">      drainQueue();</a>
+<span class="sourceLineNo">437</span><a id="line.437">      return created;</a>
+<span class="sourceLineNo">438</span><a id="line.438">    }</a>
+<span class="sourceLineNo">439</span><a id="line.439"></a>
+<span class="sourceLineNo">440</span><a id="line.440">    // N.B. Draining the queue is only necessary to ensure that we don't accumulate empty references</a>
+<span class="sourceLineNo">441</span><a id="line.441">    // in the array. We could skip this if we decide we don't care about holding on to Reference</a>
+<span class="sourceLineNo">442</span><a id="line.442">    // objects indefinitely.</a>
+<span class="sourceLineNo">443</span><a id="line.443">    private void drainQueue() {</a>
+<span class="sourceLineNo">444</span><a id="line.444">      Reference&lt;? extends L&gt; ref;</a>
+<span class="sourceLineNo">445</span><a id="line.445">      while ((ref = queue.poll()) != null) {</a>
+<span class="sourceLineNo">446</span><a id="line.446">        // We only ever register ArrayReferences with the queue so this is always safe.</a>
+<span class="sourceLineNo">447</span><a id="line.447">        ArrayReference&lt;? extends L&gt; arrayRef = (ArrayReference&lt;? extends L&gt;) ref;</a>
+<span class="sourceLineNo">448</span><a id="line.448">        // Try to clear out the array slot, n.b. if we fail that is fine, in either case the</a>
+<span class="sourceLineNo">449</span><a id="line.449">        // arrayRef will be out of the array after this step.</a>
+<span class="sourceLineNo">450</span><a id="line.450">        locks.compareAndSet(arrayRef.index, arrayRef, null);</a>
+<span class="sourceLineNo">451</span><a id="line.451">      }</a>
+<span class="sourceLineNo">452</span><a id="line.452">    }</a>
 <span class="sourceLineNo">453</span><a id="line.453"></a>
-<span class="sourceLineNo">454</span><a id="line.454">      ArrayReference(L referent, int index, ReferenceQueue&lt;L&gt; queue) {</a>
-<span class="sourceLineNo">455</span><a id="line.455">        super(referent, queue);</a>
-<span class="sourceLineNo">456</span><a id="line.456">        this.index = index;</a>
-<span class="sourceLineNo">457</span><a id="line.457">      }</a>
-<span class="sourceLineNo">458</span><a id="line.458">    }</a>
-<span class="sourceLineNo">459</span><a id="line.459">  }</a>
-<span class="sourceLineNo">460</span><a id="line.460"></a>
-<span class="sourceLineNo">461</span><a id="line.461">  /**</a>
-<span class="sourceLineNo">462</span><a id="line.462">   * Implementation of Striped where up to 2^k stripes can be represented, using a ConcurrentMap</a>
-<span class="sourceLineNo">463</span><a id="line.463">   * where the key domain is [0..2^k). To map a user key into a stripe, we take a k-bit slice of the</a>
-<span class="sourceLineNo">464</span><a id="line.464">   * user key's (smeared) hashCode(). The stripes are lazily initialized and are weakly referenced.</a>
-<span class="sourceLineNo">465</span><a id="line.465">   */</a>
-<span class="sourceLineNo">466</span><a id="line.466">  @VisibleForTesting</a>
-<span class="sourceLineNo">467</span><a id="line.467">  static class LargeLazyStriped&lt;L&gt; extends PowerOfTwoStriped&lt;L&gt; {</a>
-<span class="sourceLineNo">468</span><a id="line.468">    final ConcurrentMap&lt;Integer, L&gt; locks;</a>
-<span class="sourceLineNo">469</span><a id="line.469">    final Supplier&lt;L&gt; supplier;</a>
-<span class="sourceLineNo">470</span><a id="line.470">    final int size;</a>
-<span class="sourceLineNo">471</span><a id="line.471"></a>
-<span class="sourceLineNo">472</span><a id="line.472">    LargeLazyStriped(int stripes, Supplier&lt;L&gt; supplier) {</a>
-<span class="sourceLineNo">473</span><a id="line.473">      super(stripes);</a>
-<span class="sourceLineNo">474</span><a id="line.474">      this.size = (mask == ALL_SET) ? Integer.MAX_VALUE : mask + 1;</a>
-<span class="sourceLineNo">475</span><a id="line.475">      this.supplier = supplier;</a>
-<span class="sourceLineNo">476</span><a id="line.476">      this.locks = new MapMaker().weakValues().makeMap();</a>
-<span class="sourceLineNo">477</span><a id="line.477">    }</a>
-<span class="sourceLineNo">478</span><a id="line.478"></a>
-<span class="sourceLineNo">479</span><a id="line.479">    @Override</a>
-<span class="sourceLineNo">480</span><a id="line.480">    public L getAt(int index) {</a>
-<span class="sourceLineNo">481</span><a id="line.481">      if (size != Integer.MAX_VALUE) {</a>
-<span class="sourceLineNo">482</span><a id="line.482">        Preconditions.checkElementIndex(index, size());</a>
-<span class="sourceLineNo">483</span><a id="line.483">      } // else no check necessary, all index values are valid</a>
-<span class="sourceLineNo">484</span><a id="line.484">      L existing = locks.get(index);</a>
-<span class="sourceLineNo">485</span><a id="line.485">      if (existing != null) {</a>
-<span class="sourceLineNo">486</span><a id="line.486">        return existing;</a>
-<span class="sourceLineNo">487</span><a id="line.487">      }</a>
-<span class="sourceLineNo">488</span><a id="line.488">      L created = supplier.get();</a>
-<span class="sourceLineNo">489</span><a id="line.489">      existing = locks.putIfAbsent(index, created);</a>
-<span class="sourceLineNo">490</span><a id="line.490">      return MoreObjects.firstNonNull(existing, created);</a>
-<span class="sourceLineNo">491</span><a id="line.491">    }</a>
-<span class="sourceLineNo">492</span><a id="line.492"></a>
-<span class="sourceLineNo">493</span><a id="line.493">    @Override</a>
-<span class="sourceLineNo">494</span><a id="line.494">    public int size() {</a>
-<span class="sourceLineNo">495</span><a id="line.495">      return size;</a>
-<span class="sourceLineNo">496</span><a id="line.496">    }</a>
-<span class="sourceLineNo">497</span><a id="line.497">  }</a>
-<span class="sourceLineNo">498</span><a id="line.498"></a>
-<span class="sourceLineNo">499</span><a id="line.499">  /** A bit mask were all bits are set. */</a>
-<span class="sourceLineNo">500</span><a id="line.500">  private static final int ALL_SET = ~0;</a>
-<span class="sourceLineNo">501</span><a id="line.501"></a>
-<span class="sourceLineNo">502</span><a id="line.502">  private static int ceilToPowerOfTwo(int x) {</a>
-<span class="sourceLineNo">503</span><a id="line.503">    return 1 &lt;&lt; IntMath.log2(x, RoundingMode.CEILING);</a>
-<span class="sourceLineNo">504</span><a id="line.504">  }</a>
-<span class="sourceLineNo">505</span><a id="line.505"></a>
-<span class="sourceLineNo">506</span><a id="line.506">  /*</a>
-<span class="sourceLineNo">507</span><a id="line.507">   * This method was written by Doug Lea with assistance from members of JCP JSR-166 Expert Group</a>
-<span class="sourceLineNo">508</span><a id="line.508">   * and released to the public domain, as explained at</a>
-<span class="sourceLineNo">509</span><a id="line.509">   * http://creativecommons.org/licenses/publicdomain</a>
-<span class="sourceLineNo">510</span><a id="line.510">   *</a>
-<span class="sourceLineNo">511</span><a id="line.511">   * As of 2010/06/11, this method is identical to the (package private) hash method in OpenJDK 7's</a>
-<span class="sourceLineNo">512</span><a id="line.512">   * java.util.HashMap class.</a>
-<span class="sourceLineNo">513</span><a id="line.513">   */</a>
-<span class="sourceLineNo">514</span><a id="line.514">  // Copied from java/com/google/common/collect/Hashing.java</a>
-<span class="sourceLineNo">515</span><a id="line.515">  private static int smear(int hashCode) {</a>
-<span class="sourceLineNo">516</span><a id="line.516">    hashCode ^= (hashCode &gt;&gt;&gt; 20) ^ (hashCode &gt;&gt;&gt; 12);</a>
-<span class="sourceLineNo">517</span><a id="line.517">    return hashCode ^ (hashCode &gt;&gt;&gt; 7) ^ (hashCode &gt;&gt;&gt; 4);</a>
-<span class="sourceLineNo">518</span><a id="line.518">  }</a>
-<span class="sourceLineNo">519</span><a id="line.519"></a>
-<span class="sourceLineNo">520</span><a id="line.520">  private static class PaddedLock extends ReentrantLock {</a>
-<span class="sourceLineNo">521</span><a id="line.521">    /*</a>
-<span class="sourceLineNo">522</span><a id="line.522">     * Padding from 40 into 64 bytes, same size as cache line. Might be beneficial to add a fourth</a>
-<span class="sourceLineNo">523</span><a id="line.523">     * long here, to minimize chance of interference between consecutive locks, but I couldn't</a>
-<span class="sourceLineNo">524</span><a id="line.524">     * observe any benefit from that.</a>
-<span class="sourceLineNo">525</span><a id="line.525">     */</a>
-<span class="sourceLineNo">526</span><a id="line.526">    long unused1;</a>
-<span class="sourceLineNo">527</span><a id="line.527">    long unused2;</a>
-<span class="sourceLineNo">528</span><a id="line.528">    long unused3;</a>
-<span class="sourceLineNo">529</span><a id="line.529"></a>
-<span class="sourceLineNo">530</span><a id="line.530">    PaddedLock() {</a>
-<span class="sourceLineNo">531</span><a id="line.531">      super(false);</a>
-<span class="sourceLineNo">532</span><a id="line.532">    }</a>
-<span class="sourceLineNo">533</span><a id="line.533">  }</a>
-<span class="sourceLineNo">534</span><a id="line.534"></a>
-<span class="sourceLineNo">535</span><a id="line.535">  private static class PaddedSemaphore extends Semaphore {</a>
-<span class="sourceLineNo">536</span><a id="line.536">    // See PaddedReentrantLock comment</a>
-<span class="sourceLineNo">537</span><a id="line.537">    long unused1;</a>
-<span class="sourceLineNo">538</span><a id="line.538">    long unused2;</a>
-<span class="sourceLineNo">539</span><a id="line.539">    long unused3;</a>
-<span class="sourceLineNo">540</span><a id="line.540"></a>
-<span class="sourceLineNo">541</span><a id="line.541">    PaddedSemaphore(int permits) {</a>
-<span class="sourceLineNo">542</span><a id="line.542">      super(permits, false);</a>
-<span class="sourceLineNo">543</span><a id="line.543">    }</a>
-<span class="sourceLineNo">544</span><a id="line.544">  }</a>
-<span class="sourceLineNo">545</span><a id="line.545">}</a>
+<span class="sourceLineNo">454</span><a id="line.454">    @Override</a>
+<span class="sourceLineNo">455</span><a id="line.455">    public int size() {</a>
+<span class="sourceLineNo">456</span><a id="line.456">      return size;</a>
+<span class="sourceLineNo">457</span><a id="line.457">    }</a>
+<span class="sourceLineNo">458</span><a id="line.458"></a>
+<span class="sourceLineNo">459</span><a id="line.459">    private static final class ArrayReference&lt;L&gt; extends WeakReference&lt;L&gt; {</a>
+<span class="sourceLineNo">460</span><a id="line.460">      final int index;</a>
+<span class="sourceLineNo">461</span><a id="line.461"></a>
+<span class="sourceLineNo">462</span><a id="line.462">      ArrayReference(L referent, int index, ReferenceQueue&lt;L&gt; queue) {</a>
+<span class="sourceLineNo">463</span><a id="line.463">        super(referent, queue);</a>
+<span class="sourceLineNo">464</span><a id="line.464">        this.index = index;</a>
+<span class="sourceLineNo">465</span><a id="line.465">      }</a>
+<span class="sourceLineNo">466</span><a id="line.466">    }</a>
+<span class="sourceLineNo">467</span><a id="line.467">  }</a>
+<span class="sourceLineNo">468</span><a id="line.468"></a>
+<span class="sourceLineNo">469</span><a id="line.469">  /**</a>
+<span class="sourceLineNo">470</span><a id="line.470">   * Implementation of Striped where up to 2^k stripes can be represented, using a ConcurrentMap</a>
+<span class="sourceLineNo">471</span><a id="line.471">   * where the key domain is [0..2^k). To map a user key into a stripe, we take a k-bit slice of the</a>
+<span class="sourceLineNo">472</span><a id="line.472">   * user key's (smeared) hashCode(). The stripes are lazily initialized and are weakly referenced.</a>
+<span class="sourceLineNo">473</span><a id="line.473">   */</a>
+<span class="sourceLineNo">474</span><a id="line.474">  @VisibleForTesting</a>
+<span class="sourceLineNo">475</span><a id="line.475">  static class LargeLazyStriped&lt;L&gt; extends PowerOfTwoStriped&lt;L&gt; {</a>
+<span class="sourceLineNo">476</span><a id="line.476">    final ConcurrentMap&lt;Integer, L&gt; locks;</a>
+<span class="sourceLineNo">477</span><a id="line.477">    final Supplier&lt;L&gt; supplier;</a>
+<span class="sourceLineNo">478</span><a id="line.478">    final int size;</a>
+<span class="sourceLineNo">479</span><a id="line.479"></a>
+<span class="sourceLineNo">480</span><a id="line.480">    LargeLazyStriped(int stripes, Supplier&lt;L&gt; supplier) {</a>
+<span class="sourceLineNo">481</span><a id="line.481">      super(stripes);</a>
+<span class="sourceLineNo">482</span><a id="line.482">      this.size = (mask == ALL_SET) ? Integer.MAX_VALUE : mask + 1;</a>
+<span class="sourceLineNo">483</span><a id="line.483">      this.supplier = supplier;</a>
+<span class="sourceLineNo">484</span><a id="line.484">      this.locks = new MapMaker().weakValues().makeMap();</a>
+<span class="sourceLineNo">485</span><a id="line.485">    }</a>
+<span class="sourceLineNo">486</span><a id="line.486"></a>
+<span class="sourceLineNo">487</span><a id="line.487">    @Override</a>
+<span class="sourceLineNo">488</span><a id="line.488">    public L getAt(int index) {</a>
+<span class="sourceLineNo">489</span><a id="line.489">      if (size != Integer.MAX_VALUE) {</a>
+<span class="sourceLineNo">490</span><a id="line.490">        Preconditions.checkElementIndex(index, size());</a>
+<span class="sourceLineNo">491</span><a id="line.491">      } // else no check necessary, all index values are valid</a>
+<span class="sourceLineNo">492</span><a id="line.492">      L existing = locks.get(index);</a>
+<span class="sourceLineNo">493</span><a id="line.493">      if (existing != null) {</a>
+<span class="sourceLineNo">494</span><a id="line.494">        return existing;</a>
+<span class="sourceLineNo">495</span><a id="line.495">      }</a>
+<span class="sourceLineNo">496</span><a id="line.496">      L created = supplier.get();</a>
+<span class="sourceLineNo">497</span><a id="line.497">      existing = locks.putIfAbsent(index, created);</a>
+<span class="sourceLineNo">498</span><a id="line.498">      return MoreObjects.firstNonNull(existing, created);</a>
+<span class="sourceLineNo">499</span><a id="line.499">    }</a>
+<span class="sourceLineNo">500</span><a id="line.500"></a>
+<span class="sourceLineNo">501</span><a id="line.501">    @Override</a>
+<span class="sourceLineNo">502</span><a id="line.502">    public int size() {</a>
+<span class="sourceLineNo">503</span><a id="line.503">      return size;</a>
+<span class="sourceLineNo">504</span><a id="line.504">    }</a>
+<span class="sourceLineNo">505</span><a id="line.505">  }</a>
+<span class="sourceLineNo">506</span><a id="line.506"></a>
+<span class="sourceLineNo">507</span><a id="line.507">  /** A bit mask were all bits are set. */</a>
+<span class="sourceLineNo">508</span><a id="line.508">  private static final int ALL_SET = ~0;</a>
+<span class="sourceLineNo">509</span><a id="line.509"></a>
+<span class="sourceLineNo">510</span><a id="line.510">  private static int ceilToPowerOfTwo(int x) {</a>
+<span class="sourceLineNo">511</span><a id="line.511">    return 1 &lt;&lt; IntMath.log2(x, RoundingMode.CEILING);</a>
+<span class="sourceLineNo">512</span><a id="line.512">  }</a>
+<span class="sourceLineNo">513</span><a id="line.513"></a>
+<span class="sourceLineNo">514</span><a id="line.514">  /*</a>
+<span class="sourceLineNo">515</span><a id="line.515">   * This method was written by Doug Lea with assistance from members of JCP JSR-166 Expert Group</a>
+<span class="sourceLineNo">516</span><a id="line.516">   * and released to the public domain, as explained at</a>
+<span class="sourceLineNo">517</span><a id="line.517">   * http://creativecommons.org/licenses/publicdomain</a>
+<span class="sourceLineNo">518</span><a id="line.518">   *</a>
+<span class="sourceLineNo">519</span><a id="line.519">   * As of 2010/06/11, this method is identical to the (package private) hash method in OpenJDK 7's</a>
+<span class="sourceLineNo">520</span><a id="line.520">   * java.util.HashMap class.</a>
+<span class="sourceLineNo">521</span><a id="line.521">   */</a>
+<span class="sourceLineNo">522</span><a id="line.522">  // Copied from java/com/google/common/collect/Hashing.java</a>
+<span class="sourceLineNo">523</span><a id="line.523">  private static int smear(int hashCode) {</a>
+<span class="sourceLineNo">524</span><a id="line.524">    hashCode ^= (hashCode &gt;&gt;&gt; 20) ^ (hashCode &gt;&gt;&gt; 12);</a>
+<span class="sourceLineNo">525</span><a id="line.525">    return hashCode ^ (hashCode &gt;&gt;&gt; 7) ^ (hashCode &gt;&gt;&gt; 4);</a>
+<span class="sourceLineNo">526</span><a id="line.526">  }</a>
+<span class="sourceLineNo">527</span><a id="line.527"></a>
+<span class="sourceLineNo">528</span><a id="line.528">  private static class PaddedLock extends ReentrantLock {</a>
+<span class="sourceLineNo">529</span><a id="line.529">    /*</a>
+<span class="sourceLineNo">530</span><a id="line.530">     * Padding from 40 into 64 bytes, same size as cache line. Might be beneficial to add a fourth</a>
+<span class="sourceLineNo">531</span><a id="line.531">     * long here, to minimize chance of interference between consecutive locks, but I couldn't</a>
+<span class="sourceLineNo">532</span><a id="line.532">     * observe any benefit from that.</a>
+<span class="sourceLineNo">533</span><a id="line.533">     */</a>
+<span class="sourceLineNo">534</span><a id="line.534">    long unused1;</a>
+<span class="sourceLineNo">535</span><a id="line.535">    long unused2;</a>
+<span class="sourceLineNo">536</span><a id="line.536">    long unused3;</a>
+<span class="sourceLineNo">537</span><a id="line.537"></a>
+<span class="sourceLineNo">538</span><a id="line.538">    PaddedLock() {</a>
+<span class="sourceLineNo">539</span><a id="line.539">      super(false);</a>
+<span class="sourceLineNo">540</span><a id="line.540">    }</a>
+<span class="sourceLineNo">541</span><a id="line.541">  }</a>
+<span class="sourceLineNo">542</span><a id="line.542"></a>
+<span class="sourceLineNo">543</span><a id="line.543">  private static class PaddedSemaphore extends Semaphore {</a>
+<span class="sourceLineNo">544</span><a id="line.544">    // See PaddedReentrantLock comment</a>
+<span class="sourceLineNo">545</span><a id="line.545">    long unused1;</a>
+<span class="sourceLineNo">546</span><a id="line.546">    long unused2;</a>
+<span class="sourceLineNo">547</span><a id="line.547">    long unused3;</a>
+<span class="sourceLineNo">548</span><a id="line.548"></a>
+<span class="sourceLineNo">549</span><a id="line.549">    PaddedSemaphore(int permits) {</a>
+<span class="sourceLineNo">550</span><a id="line.550">      super(permits, false);</a>
+<span class="sourceLineNo">551</span><a id="line.551">    }</a>
+<span class="sourceLineNo">552</span><a id="line.552">  }</a>
+<span class="sourceLineNo">553</span><a id="line.553">}</a>
 
 
 
diff --git a/releases/snapshot-android/api/docs/type-search-index.zip b/releases/snapshot-android/api/docs/type-search-index.zip
index fbd4f49fdc06..c95a8d8fc257 100644
Binary files a/releases/snapshot-android/api/docs/type-search-index.zip and b/releases/snapshot-android/api/docs/type-search-index.zip differ
diff --git a/releases/snapshot-jre/api/docs/com/google/common/util/concurrent/Striped.html b/releases/snapshot-jre/api/docs/com/google/common/util/concurrent/Striped.html
index bf4f3e36ed12..24cfa9a9b3aa 100644
--- a/releases/snapshot-jre/api/docs/com/google/common/util/concurrent/Striped.html
+++ b/releases/snapshot-jre/api/docs/com/google/common/util/concurrent/Striped.html
@@ -403,7 +403,7 @@ <h4>lazyWeakLock</h4>
 <ul class="blockList">
 <li class="blockList">
 <h4>semaphore</h4>
-<pre class="methodSignature">public static&nbsp;<a href="Striped.html" title="class in com.google.common.util.concurrent">Striped</a>&lt;java.util.concurrent.Semaphore&gt;&nbsp;<a href="../../../../../src-html/com/google/common/util/concurrent/Striped.html#line.237">semaphore</a>&#8203;(int&nbsp;stripes,
+<pre class="methodSignature">public static&nbsp;<a href="Striped.html" title="class in com.google.common.util.concurrent">Striped</a>&lt;java.util.concurrent.Semaphore&gt;&nbsp;<a href="../../../../../src-html/com/google/common/util/concurrent/Striped.html#line.245">semaphore</a>&#8203;(int&nbsp;stripes,
                                                                 int&nbsp;permits)</pre>
 <div class="block">Creates a <code>Striped&lt;Semaphore&gt;</code> with eagerly initialized, strongly referenced semaphores,
  with the specified number of permits.</div>
@@ -422,7 +422,7 @@ <h4>semaphore</h4>
 <ul class="blockList">
 <li class="blockList">
 <h4>lazyWeakSemaphore</h4>
-<pre class="methodSignature">public static&nbsp;<a href="Striped.html" title="class in com.google.common.util.concurrent">Striped</a>&lt;java.util.concurrent.Semaphore&gt;&nbsp;<a href="../../../../../src-html/com/google/common/util/concurrent/Striped.html#line.249">lazyWeakSemaphore</a>&#8203;(int&nbsp;stripes,
+<pre class="methodSignature">public static&nbsp;<a href="Striped.html" title="class in com.google.common.util.concurrent">Striped</a>&lt;java.util.concurrent.Semaphore&gt;&nbsp;<a href="../../../../../src-html/com/google/common/util/concurrent/Striped.html#line.257">lazyWeakSemaphore</a>&#8203;(int&nbsp;stripes,
                                                                         int&nbsp;permits)</pre>
 <div class="block">Creates a <code>Striped&lt;Semaphore&gt;</code> with lazily initialized, weakly referenced semaphores,
  with the specified number of permits.</div>
@@ -441,7 +441,7 @@ <h4>lazyWeakSemaphore</h4>
 <ul class="blockList">
 <li class="blockList">
 <h4>readWriteLock</h4>
-<pre class="methodSignature">public static&nbsp;<a href="Striped.html" title="class in com.google.common.util.concurrent">Striped</a>&lt;java.util.concurrent.locks.ReadWriteLock&gt;&nbsp;<a href="../../../../../src-html/com/google/common/util/concurrent/Striped.html#line.260">readWriteLock</a>&#8203;(int&nbsp;stripes)</pre>
+<pre class="methodSignature">public static&nbsp;<a href="Striped.html" title="class in com.google.common.util.concurrent">Striped</a>&lt;java.util.concurrent.locks.ReadWriteLock&gt;&nbsp;<a href="../../../../../src-html/com/google/common/util/concurrent/Striped.html#line.268">readWriteLock</a>&#8203;(int&nbsp;stripes)</pre>
 <div class="block">Creates a <code>Striped&lt;ReadWriteLock&gt;</code> with eagerly initialized, strongly referenced
  read-write locks. Every lock is reentrant.</div>
 <dl>
@@ -458,7 +458,7 @@ <h4>readWriteLock</h4>
 <ul class="blockListLast">
 <li class="blockList">
 <h4>lazyWeakReadWriteLock</h4>
-<pre class="methodSignature">public static&nbsp;<a href="Striped.html" title="class in com.google.common.util.concurrent">Striped</a>&lt;java.util.concurrent.locks.ReadWriteLock&gt;&nbsp;<a href="../../../../../src-html/com/google/common/util/concurrent/Striped.html#line.271">lazyWeakReadWriteLock</a>&#8203;(int&nbsp;stripes)</pre>
+<pre class="methodSignature">public static&nbsp;<a href="Striped.html" title="class in com.google.common.util.concurrent">Striped</a>&lt;java.util.concurrent.locks.ReadWriteLock&gt;&nbsp;<a href="../../../../../src-html/com/google/common/util/concurrent/Striped.html#line.279">lazyWeakReadWriteLock</a>&#8203;(int&nbsp;stripes)</pre>
 <div class="block">Creates a <code>Striped&lt;ReadWriteLock&gt;</code> with lazily initialized, weakly referenced read-write
  locks. Every lock is reentrant.</div>
 <dl>
diff --git a/releases/snapshot-jre/api/docs/member-search-index.zip b/releases/snapshot-jre/api/docs/member-search-index.zip
index 79cee464b5d3..3f572008d0b5 100644
Binary files a/releases/snapshot-jre/api/docs/member-search-index.zip and b/releases/snapshot-jre/api/docs/member-search-index.zip differ
diff --git a/releases/snapshot-jre/api/docs/package-search-index.zip b/releases/snapshot-jre/api/docs/package-search-index.zip
index e76268bfbd3c..5707e9e94a6f 100644
Binary files a/releases/snapshot-jre/api/docs/package-search-index.zip and b/releases/snapshot-jre/api/docs/package-search-index.zip differ
diff --git a/releases/snapshot-jre/api/docs/src-html/com/google/common/util/concurrent/Striped.html b/releases/snapshot-jre/api/docs/src-html/com/google/common/util/concurrent/Striped.html
index ed56da265b4b..d60764cee2b3 100644
--- a/releases/snapshot-jre/api/docs/src-html/com/google/common/util/concurrent/Striped.html
+++ b/releases/snapshot-jre/api/docs/src-html/com/google/common/util/concurrent/Striped.html
@@ -226,332 +226,340 @@
 <span class="sourceLineNo">217</span><a id="line.217">   * @return a new {@code Striped&lt;Lock&gt;}</a>
 <span class="sourceLineNo">218</span><a id="line.218">   */</a>
 <span class="sourceLineNo">219</span><a id="line.219">  public static Striped&lt;Lock&gt; lazyWeakLock(int stripes) {</a>
-<span class="sourceLineNo">220</span><a id="line.220">    return lazy(stripes, () -&gt; new ReentrantLock(false));</a>
+<span class="sourceLineNo">220</span><a id="line.220">    return lazyWeakCustom(stripes, () -&gt; new ReentrantLock(false));</a>
 <span class="sourceLineNo">221</span><a id="line.221">  }</a>
 <span class="sourceLineNo">222</span><a id="line.222"></a>
-<span class="sourceLineNo">223</span><a id="line.223">  private static &lt;L&gt; Striped&lt;L&gt; lazy(int stripes, Supplier&lt;L&gt; supplier) {</a>
-<span class="sourceLineNo">224</span><a id="line.224">    return stripes &lt; LARGE_LAZY_CUTOFF</a>
-<span class="sourceLineNo">225</span><a id="line.225">        ? new SmallLazyStriped&lt;L&gt;(stripes, supplier)</a>
-<span class="sourceLineNo">226</span><a id="line.226">        : new LargeLazyStriped&lt;L&gt;(stripes, supplier);</a>
-<span class="sourceLineNo">227</span><a id="line.227">  }</a>
-<span class="sourceLineNo">228</span><a id="line.228"></a>
-<span class="sourceLineNo">229</span><a id="line.229">  /**</a>
-<span class="sourceLineNo">230</span><a id="line.230">   * Creates a {@code Striped&lt;Semaphore&gt;} with eagerly initialized, strongly referenced semaphores,</a>
-<span class="sourceLineNo">231</span><a id="line.231">   * with the specified number of permits.</a>
-<span class="sourceLineNo">232</span><a id="line.232">   *</a>
-<span class="sourceLineNo">233</span><a id="line.233">   * @param stripes the minimum number of stripes (semaphores) required</a>
-<span class="sourceLineNo">234</span><a id="line.234">   * @param permits the number of permits in each semaphore</a>
-<span class="sourceLineNo">235</span><a id="line.235">   * @return a new {@code Striped&lt;Semaphore&gt;}</a>
-<span class="sourceLineNo">236</span><a id="line.236">   */</a>
-<span class="sourceLineNo">237</span><a id="line.237">  public static Striped&lt;Semaphore&gt; semaphore(int stripes, int permits) {</a>
-<span class="sourceLineNo">238</span><a id="line.238">    return custom(stripes, () -&gt; new PaddedSemaphore(permits));</a>
-<span class="sourceLineNo">239</span><a id="line.239">  }</a>
-<span class="sourceLineNo">240</span><a id="line.240"></a>
-<span class="sourceLineNo">241</span><a id="line.241">  /**</a>
-<span class="sourceLineNo">242</span><a id="line.242">   * Creates a {@code Striped&lt;Semaphore&gt;} with lazily initialized, weakly referenced semaphores,</a>
-<span class="sourceLineNo">243</span><a id="line.243">   * with the specified number of permits.</a>
-<span class="sourceLineNo">244</span><a id="line.244">   *</a>
-<span class="sourceLineNo">245</span><a id="line.245">   * @param stripes the minimum number of stripes (semaphores) required</a>
-<span class="sourceLineNo">246</span><a id="line.246">   * @param permits the number of permits in each semaphore</a>
-<span class="sourceLineNo">247</span><a id="line.247">   * @return a new {@code Striped&lt;Semaphore&gt;}</a>
-<span class="sourceLineNo">248</span><a id="line.248">   */</a>
-<span class="sourceLineNo">249</span><a id="line.249">  public static Striped&lt;Semaphore&gt; lazyWeakSemaphore(int stripes, int permits) {</a>
-<span class="sourceLineNo">250</span><a id="line.250">    return lazy(stripes, () -&gt; new Semaphore(permits, false));</a>
-<span class="sourceLineNo">251</span><a id="line.251">  }</a>
-<span class="sourceLineNo">252</span><a id="line.252"></a>
-<span class="sourceLineNo">253</span><a id="line.253">  /**</a>
-<span class="sourceLineNo">254</span><a id="line.254">   * Creates a {@code Striped&lt;ReadWriteLock&gt;} with eagerly initialized, strongly referenced</a>
-<span class="sourceLineNo">255</span><a id="line.255">   * read-write locks. Every lock is reentrant.</a>
-<span class="sourceLineNo">256</span><a id="line.256">   *</a>
-<span class="sourceLineNo">257</span><a id="line.257">   * @param stripes the minimum number of stripes (locks) required</a>
-<span class="sourceLineNo">258</span><a id="line.258">   * @return a new {@code Striped&lt;ReadWriteLock&gt;}</a>
-<span class="sourceLineNo">259</span><a id="line.259">   */</a>
-<span class="sourceLineNo">260</span><a id="line.260">  public static Striped&lt;ReadWriteLock&gt; readWriteLock(int stripes) {</a>
-<span class="sourceLineNo">261</span><a id="line.261">    return custom(stripes, ReentrantReadWriteLock::new);</a>
-<span class="sourceLineNo">262</span><a id="line.262">  }</a>
-<span class="sourceLineNo">263</span><a id="line.263"></a>
-<span class="sourceLineNo">264</span><a id="line.264">  /**</a>
-<span class="sourceLineNo">265</span><a id="line.265">   * Creates a {@code Striped&lt;ReadWriteLock&gt;} with lazily initialized, weakly referenced read-write</a>
-<span class="sourceLineNo">266</span><a id="line.266">   * locks. Every lock is reentrant.</a>
-<span class="sourceLineNo">267</span><a id="line.267">   *</a>
-<span class="sourceLineNo">268</span><a id="line.268">   * @param stripes the minimum number of stripes (locks) required</a>
-<span class="sourceLineNo">269</span><a id="line.269">   * @return a new {@code Striped&lt;ReadWriteLock&gt;}</a>
-<span class="sourceLineNo">270</span><a id="line.270">   */</a>
-<span class="sourceLineNo">271</span><a id="line.271">  public static Striped&lt;ReadWriteLock&gt; lazyWeakReadWriteLock(int stripes) {</a>
-<span class="sourceLineNo">272</span><a id="line.272">    return lazy(stripes, WeakSafeReadWriteLock::new);</a>
-<span class="sourceLineNo">273</span><a id="line.273">  }</a>
-<span class="sourceLineNo">274</span><a id="line.274">  /**</a>
-<span class="sourceLineNo">275</span><a id="line.275">   * ReadWriteLock implementation whose read and write locks retain a reference back to this lock.</a>
-<span class="sourceLineNo">276</span><a id="line.276">   * Otherwise, a reference to just the read lock or just the write lock would not suffice to ensure</a>
-<span class="sourceLineNo">277</span><a id="line.277">   * the {@code ReadWriteLock} is retained.</a>
+<span class="sourceLineNo">223</span><a id="line.223">  /**</a>
+<span class="sourceLineNo">224</span><a id="line.224">   * Creates a {@code Striped&lt;L&gt;} with lazily initialized, weakly referenced locks. Every lock is</a>
+<span class="sourceLineNo">225</span><a id="line.225">   * obtained from the passed supplier.</a>
+<span class="sourceLineNo">226</span><a id="line.226">   *</a>
+<span class="sourceLineNo">227</span><a id="line.227">   * @param stripes the minimum number of stripes (locks) required</a>
+<span class="sourceLineNo">228</span><a id="line.228">   * @param supplier a {@code Supplier&lt;L&gt;} object to obtain locks from</a>
+<span class="sourceLineNo">229</span><a id="line.229">   * @return a new {@code Striped&lt;L&gt;}</a>
+<span class="sourceLineNo">230</span><a id="line.230">   */</a>
+<span class="sourceLineNo">231</span><a id="line.231">  static &lt;L&gt; Striped&lt;L&gt; lazyWeakCustom(int stripes, Supplier&lt;L&gt; supplier) {</a>
+<span class="sourceLineNo">232</span><a id="line.232">    return stripes &lt; LARGE_LAZY_CUTOFF</a>
+<span class="sourceLineNo">233</span><a id="line.233">        ? new SmallLazyStriped&lt;L&gt;(stripes, supplier)</a>
+<span class="sourceLineNo">234</span><a id="line.234">        : new LargeLazyStriped&lt;L&gt;(stripes, supplier);</a>
+<span class="sourceLineNo">235</span><a id="line.235">  }</a>
+<span class="sourceLineNo">236</span><a id="line.236"></a>
+<span class="sourceLineNo">237</span><a id="line.237">  /**</a>
+<span class="sourceLineNo">238</span><a id="line.238">   * Creates a {@code Striped&lt;Semaphore&gt;} with eagerly initialized, strongly referenced semaphores,</a>
+<span class="sourceLineNo">239</span><a id="line.239">   * with the specified number of permits.</a>
+<span class="sourceLineNo">240</span><a id="line.240">   *</a>
+<span class="sourceLineNo">241</span><a id="line.241">   * @param stripes the minimum number of stripes (semaphores) required</a>
+<span class="sourceLineNo">242</span><a id="line.242">   * @param permits the number of permits in each semaphore</a>
+<span class="sourceLineNo">243</span><a id="line.243">   * @return a new {@code Striped&lt;Semaphore&gt;}</a>
+<span class="sourceLineNo">244</span><a id="line.244">   */</a>
+<span class="sourceLineNo">245</span><a id="line.245">  public static Striped&lt;Semaphore&gt; semaphore(int stripes, int permits) {</a>
+<span class="sourceLineNo">246</span><a id="line.246">    return custom(stripes, () -&gt; new PaddedSemaphore(permits));</a>
+<span class="sourceLineNo">247</span><a id="line.247">  }</a>
+<span class="sourceLineNo">248</span><a id="line.248"></a>
+<span class="sourceLineNo">249</span><a id="line.249">  /**</a>
+<span class="sourceLineNo">250</span><a id="line.250">   * Creates a {@code Striped&lt;Semaphore&gt;} with lazily initialized, weakly referenced semaphores,</a>
+<span class="sourceLineNo">251</span><a id="line.251">   * with the specified number of permits.</a>
+<span class="sourceLineNo">252</span><a id="line.252">   *</a>
+<span class="sourceLineNo">253</span><a id="line.253">   * @param stripes the minimum number of stripes (semaphores) required</a>
+<span class="sourceLineNo">254</span><a id="line.254">   * @param permits the number of permits in each semaphore</a>
+<span class="sourceLineNo">255</span><a id="line.255">   * @return a new {@code Striped&lt;Semaphore&gt;}</a>
+<span class="sourceLineNo">256</span><a id="line.256">   */</a>
+<span class="sourceLineNo">257</span><a id="line.257">  public static Striped&lt;Semaphore&gt; lazyWeakSemaphore(int stripes, int permits) {</a>
+<span class="sourceLineNo">258</span><a id="line.258">    return lazyWeakCustom(stripes, () -&gt; new Semaphore(permits, false));</a>
+<span class="sourceLineNo">259</span><a id="line.259">  }</a>
+<span class="sourceLineNo">260</span><a id="line.260"></a>
+<span class="sourceLineNo">261</span><a id="line.261">  /**</a>
+<span class="sourceLineNo">262</span><a id="line.262">   * Creates a {@code Striped&lt;ReadWriteLock&gt;} with eagerly initialized, strongly referenced</a>
+<span class="sourceLineNo">263</span><a id="line.263">   * read-write locks. Every lock is reentrant.</a>
+<span class="sourceLineNo">264</span><a id="line.264">   *</a>
+<span class="sourceLineNo">265</span><a id="line.265">   * @param stripes the minimum number of stripes (locks) required</a>
+<span class="sourceLineNo">266</span><a id="line.266">   * @return a new {@code Striped&lt;ReadWriteLock&gt;}</a>
+<span class="sourceLineNo">267</span><a id="line.267">   */</a>
+<span class="sourceLineNo">268</span><a id="line.268">  public static Striped&lt;ReadWriteLock&gt; readWriteLock(int stripes) {</a>
+<span class="sourceLineNo">269</span><a id="line.269">    return custom(stripes, ReentrantReadWriteLock::new);</a>
+<span class="sourceLineNo">270</span><a id="line.270">  }</a>
+<span class="sourceLineNo">271</span><a id="line.271"></a>
+<span class="sourceLineNo">272</span><a id="line.272">  /**</a>
+<span class="sourceLineNo">273</span><a id="line.273">   * Creates a {@code Striped&lt;ReadWriteLock&gt;} with lazily initialized, weakly referenced read-write</a>
+<span class="sourceLineNo">274</span><a id="line.274">   * locks. Every lock is reentrant.</a>
+<span class="sourceLineNo">275</span><a id="line.275">   *</a>
+<span class="sourceLineNo">276</span><a id="line.276">   * @param stripes the minimum number of stripes (locks) required</a>
+<span class="sourceLineNo">277</span><a id="line.277">   * @return a new {@code Striped&lt;ReadWriteLock&gt;}</a>
 <span class="sourceLineNo">278</span><a id="line.278">   */</a>
-<span class="sourceLineNo">279</span><a id="line.279">  private static final class WeakSafeReadWriteLock implements ReadWriteLock {</a>
-<span class="sourceLineNo">280</span><a id="line.280">    private final ReadWriteLock delegate;</a>
-<span class="sourceLineNo">281</span><a id="line.281"></a>
-<span class="sourceLineNo">282</span><a id="line.282">    WeakSafeReadWriteLock() {</a>
-<span class="sourceLineNo">283</span><a id="line.283">      this.delegate = new ReentrantReadWriteLock();</a>
-<span class="sourceLineNo">284</span><a id="line.284">    }</a>
-<span class="sourceLineNo">285</span><a id="line.285"></a>
-<span class="sourceLineNo">286</span><a id="line.286">    @Override</a>
-<span class="sourceLineNo">287</span><a id="line.287">    public Lock readLock() {</a>
-<span class="sourceLineNo">288</span><a id="line.288">      return new WeakSafeLock(delegate.readLock(), this);</a>
-<span class="sourceLineNo">289</span><a id="line.289">    }</a>
-<span class="sourceLineNo">290</span><a id="line.290"></a>
-<span class="sourceLineNo">291</span><a id="line.291">    @Override</a>
-<span class="sourceLineNo">292</span><a id="line.292">    public Lock writeLock() {</a>
-<span class="sourceLineNo">293</span><a id="line.293">      return new WeakSafeLock(delegate.writeLock(), this);</a>
-<span class="sourceLineNo">294</span><a id="line.294">    }</a>
-<span class="sourceLineNo">295</span><a id="line.295">  }</a>
-<span class="sourceLineNo">296</span><a id="line.296"></a>
-<span class="sourceLineNo">297</span><a id="line.297">  /** Lock object that ensures a strong reference is retained to a specified object. */</a>
-<span class="sourceLineNo">298</span><a id="line.298">  private static final class WeakSafeLock extends ForwardingLock {</a>
-<span class="sourceLineNo">299</span><a id="line.299">    private final Lock delegate;</a>
-<span class="sourceLineNo">300</span><a id="line.300"></a>
-<span class="sourceLineNo">301</span><a id="line.301">    @SuppressWarnings("unused")</a>
-<span class="sourceLineNo">302</span><a id="line.302">    private final WeakSafeReadWriteLock strongReference;</a>
-<span class="sourceLineNo">303</span><a id="line.303"></a>
-<span class="sourceLineNo">304</span><a id="line.304">    WeakSafeLock(Lock delegate, WeakSafeReadWriteLock strongReference) {</a>
-<span class="sourceLineNo">305</span><a id="line.305">      this.delegate = delegate;</a>
-<span class="sourceLineNo">306</span><a id="line.306">      this.strongReference = strongReference;</a>
-<span class="sourceLineNo">307</span><a id="line.307">    }</a>
+<span class="sourceLineNo">279</span><a id="line.279">  public static Striped&lt;ReadWriteLock&gt; lazyWeakReadWriteLock(int stripes) {</a>
+<span class="sourceLineNo">280</span><a id="line.280">    return lazyWeakCustom(stripes, WeakSafeReadWriteLock::new);</a>
+<span class="sourceLineNo">281</span><a id="line.281">  }</a>
+<span class="sourceLineNo">282</span><a id="line.282">  /**</a>
+<span class="sourceLineNo">283</span><a id="line.283">   * ReadWriteLock implementation whose read and write locks retain a reference back to this lock.</a>
+<span class="sourceLineNo">284</span><a id="line.284">   * Otherwise, a reference to just the read lock or just the write lock would not suffice to ensure</a>
+<span class="sourceLineNo">285</span><a id="line.285">   * the {@code ReadWriteLock} is retained.</a>
+<span class="sourceLineNo">286</span><a id="line.286">   */</a>
+<span class="sourceLineNo">287</span><a id="line.287">  private static final class WeakSafeReadWriteLock implements ReadWriteLock {</a>
+<span class="sourceLineNo">288</span><a id="line.288">    private final ReadWriteLock delegate;</a>
+<span class="sourceLineNo">289</span><a id="line.289"></a>
+<span class="sourceLineNo">290</span><a id="line.290">    WeakSafeReadWriteLock() {</a>
+<span class="sourceLineNo">291</span><a id="line.291">      this.delegate = new ReentrantReadWriteLock();</a>
+<span class="sourceLineNo">292</span><a id="line.292">    }</a>
+<span class="sourceLineNo">293</span><a id="line.293"></a>
+<span class="sourceLineNo">294</span><a id="line.294">    @Override</a>
+<span class="sourceLineNo">295</span><a id="line.295">    public Lock readLock() {</a>
+<span class="sourceLineNo">296</span><a id="line.296">      return new WeakSafeLock(delegate.readLock(), this);</a>
+<span class="sourceLineNo">297</span><a id="line.297">    }</a>
+<span class="sourceLineNo">298</span><a id="line.298"></a>
+<span class="sourceLineNo">299</span><a id="line.299">    @Override</a>
+<span class="sourceLineNo">300</span><a id="line.300">    public Lock writeLock() {</a>
+<span class="sourceLineNo">301</span><a id="line.301">      return new WeakSafeLock(delegate.writeLock(), this);</a>
+<span class="sourceLineNo">302</span><a id="line.302">    }</a>
+<span class="sourceLineNo">303</span><a id="line.303">  }</a>
+<span class="sourceLineNo">304</span><a id="line.304"></a>
+<span class="sourceLineNo">305</span><a id="line.305">  /** Lock object that ensures a strong reference is retained to a specified object. */</a>
+<span class="sourceLineNo">306</span><a id="line.306">  private static final class WeakSafeLock extends ForwardingLock {</a>
+<span class="sourceLineNo">307</span><a id="line.307">    private final Lock delegate;</a>
 <span class="sourceLineNo">308</span><a id="line.308"></a>
-<span class="sourceLineNo">309</span><a id="line.309">    @Override</a>
-<span class="sourceLineNo">310</span><a id="line.310">    Lock delegate() {</a>
-<span class="sourceLineNo">311</span><a id="line.311">      return delegate;</a>
-<span class="sourceLineNo">312</span><a id="line.312">    }</a>
-<span class="sourceLineNo">313</span><a id="line.313"></a>
-<span class="sourceLineNo">314</span><a id="line.314">    @Override</a>
-<span class="sourceLineNo">315</span><a id="line.315">    public Condition newCondition() {</a>
-<span class="sourceLineNo">316</span><a id="line.316">      return new WeakSafeCondition(delegate.newCondition(), strongReference);</a>
-<span class="sourceLineNo">317</span><a id="line.317">    }</a>
-<span class="sourceLineNo">318</span><a id="line.318">  }</a>
-<span class="sourceLineNo">319</span><a id="line.319"></a>
-<span class="sourceLineNo">320</span><a id="line.320">  /** Condition object that ensures a strong reference is retained to a specified object. */</a>
-<span class="sourceLineNo">321</span><a id="line.321">  private static final class WeakSafeCondition extends ForwardingCondition {</a>
-<span class="sourceLineNo">322</span><a id="line.322">    private final Condition delegate;</a>
-<span class="sourceLineNo">323</span><a id="line.323"></a>
-<span class="sourceLineNo">324</span><a id="line.324">    @SuppressWarnings("unused")</a>
-<span class="sourceLineNo">325</span><a id="line.325">    private final WeakSafeReadWriteLock strongReference;</a>
-<span class="sourceLineNo">326</span><a id="line.326"></a>
-<span class="sourceLineNo">327</span><a id="line.327">    WeakSafeCondition(Condition delegate, WeakSafeReadWriteLock strongReference) {</a>
-<span class="sourceLineNo">328</span><a id="line.328">      this.delegate = delegate;</a>
-<span class="sourceLineNo">329</span><a id="line.329">      this.strongReference = strongReference;</a>
-<span class="sourceLineNo">330</span><a id="line.330">    }</a>
+<span class="sourceLineNo">309</span><a id="line.309">    @SuppressWarnings("unused")</a>
+<span class="sourceLineNo">310</span><a id="line.310">    private final WeakSafeReadWriteLock strongReference;</a>
+<span class="sourceLineNo">311</span><a id="line.311"></a>
+<span class="sourceLineNo">312</span><a id="line.312">    WeakSafeLock(Lock delegate, WeakSafeReadWriteLock strongReference) {</a>
+<span class="sourceLineNo">313</span><a id="line.313">      this.delegate = delegate;</a>
+<span class="sourceLineNo">314</span><a id="line.314">      this.strongReference = strongReference;</a>
+<span class="sourceLineNo">315</span><a id="line.315">    }</a>
+<span class="sourceLineNo">316</span><a id="line.316"></a>
+<span class="sourceLineNo">317</span><a id="line.317">    @Override</a>
+<span class="sourceLineNo">318</span><a id="line.318">    Lock delegate() {</a>
+<span class="sourceLineNo">319</span><a id="line.319">      return delegate;</a>
+<span class="sourceLineNo">320</span><a id="line.320">    }</a>
+<span class="sourceLineNo">321</span><a id="line.321"></a>
+<span class="sourceLineNo">322</span><a id="line.322">    @Override</a>
+<span class="sourceLineNo">323</span><a id="line.323">    public Condition newCondition() {</a>
+<span class="sourceLineNo">324</span><a id="line.324">      return new WeakSafeCondition(delegate.newCondition(), strongReference);</a>
+<span class="sourceLineNo">325</span><a id="line.325">    }</a>
+<span class="sourceLineNo">326</span><a id="line.326">  }</a>
+<span class="sourceLineNo">327</span><a id="line.327"></a>
+<span class="sourceLineNo">328</span><a id="line.328">  /** Condition object that ensures a strong reference is retained to a specified object. */</a>
+<span class="sourceLineNo">329</span><a id="line.329">  private static final class WeakSafeCondition extends ForwardingCondition {</a>
+<span class="sourceLineNo">330</span><a id="line.330">    private final Condition delegate;</a>
 <span class="sourceLineNo">331</span><a id="line.331"></a>
-<span class="sourceLineNo">332</span><a id="line.332">    @Override</a>
-<span class="sourceLineNo">333</span><a id="line.333">    Condition delegate() {</a>
-<span class="sourceLineNo">334</span><a id="line.334">      return delegate;</a>
-<span class="sourceLineNo">335</span><a id="line.335">    }</a>
-<span class="sourceLineNo">336</span><a id="line.336">  }</a>
-<span class="sourceLineNo">337</span><a id="line.337"></a>
-<span class="sourceLineNo">338</span><a id="line.338">  private abstract static class PowerOfTwoStriped&lt;L&gt; extends Striped&lt;L&gt; {</a>
-<span class="sourceLineNo">339</span><a id="line.339">    /** Capacity (power of two) minus one, for fast mod evaluation */</a>
-<span class="sourceLineNo">340</span><a id="line.340">    final int mask;</a>
-<span class="sourceLineNo">341</span><a id="line.341"></a>
-<span class="sourceLineNo">342</span><a id="line.342">    PowerOfTwoStriped(int stripes) {</a>
-<span class="sourceLineNo">343</span><a id="line.343">      Preconditions.checkArgument(stripes &gt; 0, "Stripes must be positive");</a>
-<span class="sourceLineNo">344</span><a id="line.344">      this.mask = stripes &gt; Ints.MAX_POWER_OF_TWO ? ALL_SET : ceilToPowerOfTwo(stripes) - 1;</a>
-<span class="sourceLineNo">345</span><a id="line.345">    }</a>
-<span class="sourceLineNo">346</span><a id="line.346"></a>
-<span class="sourceLineNo">347</span><a id="line.347">    @Override</a>
-<span class="sourceLineNo">348</span><a id="line.348">    final int indexFor(Object key) {</a>
-<span class="sourceLineNo">349</span><a id="line.349">      int hash = smear(key.hashCode());</a>
-<span class="sourceLineNo">350</span><a id="line.350">      return hash &amp; mask;</a>
-<span class="sourceLineNo">351</span><a id="line.351">    }</a>
-<span class="sourceLineNo">352</span><a id="line.352"></a>
-<span class="sourceLineNo">353</span><a id="line.353">    @Override</a>
-<span class="sourceLineNo">354</span><a id="line.354">    public final L get(Object key) {</a>
-<span class="sourceLineNo">355</span><a id="line.355">      return getAt(indexFor(key));</a>
-<span class="sourceLineNo">356</span><a id="line.356">    }</a>
-<span class="sourceLineNo">357</span><a id="line.357">  }</a>
-<span class="sourceLineNo">358</span><a id="line.358"></a>
-<span class="sourceLineNo">359</span><a id="line.359">  /**</a>
-<span class="sourceLineNo">360</span><a id="line.360">   * Implementation of Striped where 2^k stripes are represented as an array of the same length,</a>
-<span class="sourceLineNo">361</span><a id="line.361">   * eagerly initialized.</a>
-<span class="sourceLineNo">362</span><a id="line.362">   */</a>
-<span class="sourceLineNo">363</span><a id="line.363">  private static class CompactStriped&lt;L&gt; extends PowerOfTwoStriped&lt;L&gt; {</a>
-<span class="sourceLineNo">364</span><a id="line.364">    /** Size is a power of two. */</a>
-<span class="sourceLineNo">365</span><a id="line.365">    private final Object[] array;</a>
+<span class="sourceLineNo">332</span><a id="line.332">    @SuppressWarnings("unused")</a>
+<span class="sourceLineNo">333</span><a id="line.333">    private final WeakSafeReadWriteLock strongReference;</a>
+<span class="sourceLineNo">334</span><a id="line.334"></a>
+<span class="sourceLineNo">335</span><a id="line.335">    WeakSafeCondition(Condition delegate, WeakSafeReadWriteLock strongReference) {</a>
+<span class="sourceLineNo">336</span><a id="line.336">      this.delegate = delegate;</a>
+<span class="sourceLineNo">337</span><a id="line.337">      this.strongReference = strongReference;</a>
+<span class="sourceLineNo">338</span><a id="line.338">    }</a>
+<span class="sourceLineNo">339</span><a id="line.339"></a>
+<span class="sourceLineNo">340</span><a id="line.340">    @Override</a>
+<span class="sourceLineNo">341</span><a id="line.341">    Condition delegate() {</a>
+<span class="sourceLineNo">342</span><a id="line.342">      return delegate;</a>
+<span class="sourceLineNo">343</span><a id="line.343">    }</a>
+<span class="sourceLineNo">344</span><a id="line.344">  }</a>
+<span class="sourceLineNo">345</span><a id="line.345"></a>
+<span class="sourceLineNo">346</span><a id="line.346">  private abstract static class PowerOfTwoStriped&lt;L&gt; extends Striped&lt;L&gt; {</a>
+<span class="sourceLineNo">347</span><a id="line.347">    /** Capacity (power of two) minus one, for fast mod evaluation */</a>
+<span class="sourceLineNo">348</span><a id="line.348">    final int mask;</a>
+<span class="sourceLineNo">349</span><a id="line.349"></a>
+<span class="sourceLineNo">350</span><a id="line.350">    PowerOfTwoStriped(int stripes) {</a>
+<span class="sourceLineNo">351</span><a id="line.351">      Preconditions.checkArgument(stripes &gt; 0, "Stripes must be positive");</a>
+<span class="sourceLineNo">352</span><a id="line.352">      this.mask = stripes &gt; Ints.MAX_POWER_OF_TWO ? ALL_SET : ceilToPowerOfTwo(stripes) - 1;</a>
+<span class="sourceLineNo">353</span><a id="line.353">    }</a>
+<span class="sourceLineNo">354</span><a id="line.354"></a>
+<span class="sourceLineNo">355</span><a id="line.355">    @Override</a>
+<span class="sourceLineNo">356</span><a id="line.356">    final int indexFor(Object key) {</a>
+<span class="sourceLineNo">357</span><a id="line.357">      int hash = smear(key.hashCode());</a>
+<span class="sourceLineNo">358</span><a id="line.358">      return hash &amp; mask;</a>
+<span class="sourceLineNo">359</span><a id="line.359">    }</a>
+<span class="sourceLineNo">360</span><a id="line.360"></a>
+<span class="sourceLineNo">361</span><a id="line.361">    @Override</a>
+<span class="sourceLineNo">362</span><a id="line.362">    public final L get(Object key) {</a>
+<span class="sourceLineNo">363</span><a id="line.363">      return getAt(indexFor(key));</a>
+<span class="sourceLineNo">364</span><a id="line.364">    }</a>
+<span class="sourceLineNo">365</span><a id="line.365">  }</a>
 <span class="sourceLineNo">366</span><a id="line.366"></a>
-<span class="sourceLineNo">367</span><a id="line.367">    private CompactStriped(int stripes, Supplier&lt;L&gt; supplier) {</a>
-<span class="sourceLineNo">368</span><a id="line.368">      super(stripes);</a>
-<span class="sourceLineNo">369</span><a id="line.369">      Preconditions.checkArgument(stripes &lt;= Ints.MAX_POWER_OF_TWO, "Stripes must be &lt;= 2^30)");</a>
-<span class="sourceLineNo">370</span><a id="line.370"></a>
-<span class="sourceLineNo">371</span><a id="line.371">      this.array = new Object[mask + 1];</a>
-<span class="sourceLineNo">372</span><a id="line.372">      for (int i = 0; i &lt; array.length; i++) {</a>
-<span class="sourceLineNo">373</span><a id="line.373">        array[i] = supplier.get();</a>
-<span class="sourceLineNo">374</span><a id="line.374">      }</a>
-<span class="sourceLineNo">375</span><a id="line.375">    }</a>
-<span class="sourceLineNo">376</span><a id="line.376"></a>
-<span class="sourceLineNo">377</span><a id="line.377">    @SuppressWarnings("unchecked") // we only put L's in the array</a>
-<span class="sourceLineNo">378</span><a id="line.378">    @Override</a>
-<span class="sourceLineNo">379</span><a id="line.379">    public L getAt(int index) {</a>
-<span class="sourceLineNo">380</span><a id="line.380">      return (L) array[index];</a>
-<span class="sourceLineNo">381</span><a id="line.381">    }</a>
-<span class="sourceLineNo">382</span><a id="line.382"></a>
-<span class="sourceLineNo">383</span><a id="line.383">    @Override</a>
-<span class="sourceLineNo">384</span><a id="line.384">    public int size() {</a>
-<span class="sourceLineNo">385</span><a id="line.385">      return array.length;</a>
-<span class="sourceLineNo">386</span><a id="line.386">    }</a>
-<span class="sourceLineNo">387</span><a id="line.387">  }</a>
-<span class="sourceLineNo">388</span><a id="line.388"></a>
-<span class="sourceLineNo">389</span><a id="line.389">  /**</a>
-<span class="sourceLineNo">390</span><a id="line.390">   * Implementation of Striped where up to 2^k stripes can be represented, using an</a>
-<span class="sourceLineNo">391</span><a id="line.391">   * AtomicReferenceArray of size 2^k. To map a user key into a stripe, we take a k-bit slice of the</a>
-<span class="sourceLineNo">392</span><a id="line.392">   * user key's (smeared) hashCode(). The stripes are lazily initialized and are weakly referenced.</a>
-<span class="sourceLineNo">393</span><a id="line.393">   */</a>
-<span class="sourceLineNo">394</span><a id="line.394">  @VisibleForTesting</a>
-<span class="sourceLineNo">395</span><a id="line.395">  static class SmallLazyStriped&lt;L&gt; extends PowerOfTwoStriped&lt;L&gt; {</a>
-<span class="sourceLineNo">396</span><a id="line.396">    final AtomicReferenceArray&lt;@Nullable ArrayReference&lt;? extends L&gt;&gt; locks;</a>
-<span class="sourceLineNo">397</span><a id="line.397">    final Supplier&lt;L&gt; supplier;</a>
-<span class="sourceLineNo">398</span><a id="line.398">    final int size;</a>
-<span class="sourceLineNo">399</span><a id="line.399">    final ReferenceQueue&lt;L&gt; queue = new ReferenceQueue&lt;&gt;();</a>
-<span class="sourceLineNo">400</span><a id="line.400"></a>
-<span class="sourceLineNo">401</span><a id="line.401">    SmallLazyStriped(int stripes, Supplier&lt;L&gt; supplier) {</a>
-<span class="sourceLineNo">402</span><a id="line.402">      super(stripes);</a>
-<span class="sourceLineNo">403</span><a id="line.403">      this.size = (mask == ALL_SET) ? Integer.MAX_VALUE : mask + 1;</a>
-<span class="sourceLineNo">404</span><a id="line.404">      this.locks = new AtomicReferenceArray&lt;&gt;(size);</a>
-<span class="sourceLineNo">405</span><a id="line.405">      this.supplier = supplier;</a>
-<span class="sourceLineNo">406</span><a id="line.406">    }</a>
-<span class="sourceLineNo">407</span><a id="line.407"></a>
-<span class="sourceLineNo">408</span><a id="line.408">    @Override</a>
-<span class="sourceLineNo">409</span><a id="line.409">    public L getAt(int index) {</a>
-<span class="sourceLineNo">410</span><a id="line.410">      if (size != Integer.MAX_VALUE) {</a>
-<span class="sourceLineNo">411</span><a id="line.411">        Preconditions.checkElementIndex(index, size());</a>
-<span class="sourceLineNo">412</span><a id="line.412">      } // else no check necessary, all index values are valid</a>
-<span class="sourceLineNo">413</span><a id="line.413">      ArrayReference&lt;? extends L&gt; existingRef = locks.get(index);</a>
-<span class="sourceLineNo">414</span><a id="line.414">      L existing = existingRef == null ? null : existingRef.get();</a>
-<span class="sourceLineNo">415</span><a id="line.415">      if (existing != null) {</a>
-<span class="sourceLineNo">416</span><a id="line.416">        return existing;</a>
-<span class="sourceLineNo">417</span><a id="line.417">      }</a>
-<span class="sourceLineNo">418</span><a id="line.418">      L created = supplier.get();</a>
-<span class="sourceLineNo">419</span><a id="line.419">      ArrayReference&lt;L&gt; newRef = new ArrayReference&lt;&gt;(created, index, queue);</a>
-<span class="sourceLineNo">420</span><a id="line.420">      while (!locks.compareAndSet(index, existingRef, newRef)) {</a>
-<span class="sourceLineNo">421</span><a id="line.421">        // we raced, we need to re-read and try again</a>
-<span class="sourceLineNo">422</span><a id="line.422">        existingRef = locks.get(index);</a>
-<span class="sourceLineNo">423</span><a id="line.423">        existing = existingRef == null ? null : existingRef.get();</a>
-<span class="sourceLineNo">424</span><a id="line.424">        if (existing != null) {</a>
-<span class="sourceLineNo">425</span><a id="line.425">          return existing;</a>
-<span class="sourceLineNo">426</span><a id="line.426">        }</a>
-<span class="sourceLineNo">427</span><a id="line.427">      }</a>
-<span class="sourceLineNo">428</span><a id="line.428">      drainQueue();</a>
-<span class="sourceLineNo">429</span><a id="line.429">      return created;</a>
-<span class="sourceLineNo">430</span><a id="line.430">    }</a>
-<span class="sourceLineNo">431</span><a id="line.431"></a>
-<span class="sourceLineNo">432</span><a id="line.432">    // N.B. Draining the queue is only necessary to ensure that we don't accumulate empty references</a>
-<span class="sourceLineNo">433</span><a id="line.433">    // in the array. We could skip this if we decide we don't care about holding on to Reference</a>
-<span class="sourceLineNo">434</span><a id="line.434">    // objects indefinitely.</a>
-<span class="sourceLineNo">435</span><a id="line.435">    private void drainQueue() {</a>
-<span class="sourceLineNo">436</span><a id="line.436">      Reference&lt;? extends L&gt; ref;</a>
-<span class="sourceLineNo">437</span><a id="line.437">      while ((ref = queue.poll()) != null) {</a>
-<span class="sourceLineNo">438</span><a id="line.438">        // We only ever register ArrayReferences with the queue so this is always safe.</a>
-<span class="sourceLineNo">439</span><a id="line.439">        ArrayReference&lt;? extends L&gt; arrayRef = (ArrayReference&lt;? extends L&gt;) ref;</a>
-<span class="sourceLineNo">440</span><a id="line.440">        // Try to clear out the array slot, n.b. if we fail that is fine, in either case the</a>
-<span class="sourceLineNo">441</span><a id="line.441">        // arrayRef will be out of the array after this step.</a>
-<span class="sourceLineNo">442</span><a id="line.442">        locks.compareAndSet(arrayRef.index, arrayRef, null);</a>
-<span class="sourceLineNo">443</span><a id="line.443">      }</a>
-<span class="sourceLineNo">444</span><a id="line.444">    }</a>
-<span class="sourceLineNo">445</span><a id="line.445"></a>
-<span class="sourceLineNo">446</span><a id="line.446">    @Override</a>
-<span class="sourceLineNo">447</span><a id="line.447">    public int size() {</a>
-<span class="sourceLineNo">448</span><a id="line.448">      return size;</a>
-<span class="sourceLineNo">449</span><a id="line.449">    }</a>
-<span class="sourceLineNo">450</span><a id="line.450"></a>
-<span class="sourceLineNo">451</span><a id="line.451">    private static final class ArrayReference&lt;L&gt; extends WeakReference&lt;L&gt; {</a>
-<span class="sourceLineNo">452</span><a id="line.452">      final int index;</a>
+<span class="sourceLineNo">367</span><a id="line.367">  /**</a>
+<span class="sourceLineNo">368</span><a id="line.368">   * Implementation of Striped where 2^k stripes are represented as an array of the same length,</a>
+<span class="sourceLineNo">369</span><a id="line.369">   * eagerly initialized.</a>
+<span class="sourceLineNo">370</span><a id="line.370">   */</a>
+<span class="sourceLineNo">371</span><a id="line.371">  private static class CompactStriped&lt;L&gt; extends PowerOfTwoStriped&lt;L&gt; {</a>
+<span class="sourceLineNo">372</span><a id="line.372">    /** Size is a power of two. */</a>
+<span class="sourceLineNo">373</span><a id="line.373">    private final Object[] array;</a>
+<span class="sourceLineNo">374</span><a id="line.374"></a>
+<span class="sourceLineNo">375</span><a id="line.375">    private CompactStriped(int stripes, Supplier&lt;L&gt; supplier) {</a>
+<span class="sourceLineNo">376</span><a id="line.376">      super(stripes);</a>
+<span class="sourceLineNo">377</span><a id="line.377">      Preconditions.checkArgument(stripes &lt;= Ints.MAX_POWER_OF_TWO, "Stripes must be &lt;= 2^30)");</a>
+<span class="sourceLineNo">378</span><a id="line.378"></a>
+<span class="sourceLineNo">379</span><a id="line.379">      this.array = new Object[mask + 1];</a>
+<span class="sourceLineNo">380</span><a id="line.380">      for (int i = 0; i &lt; array.length; i++) {</a>
+<span class="sourceLineNo">381</span><a id="line.381">        array[i] = supplier.get();</a>
+<span class="sourceLineNo">382</span><a id="line.382">      }</a>
+<span class="sourceLineNo">383</span><a id="line.383">    }</a>
+<span class="sourceLineNo">384</span><a id="line.384"></a>
+<span class="sourceLineNo">385</span><a id="line.385">    @SuppressWarnings("unchecked") // we only put L's in the array</a>
+<span class="sourceLineNo">386</span><a id="line.386">    @Override</a>
+<span class="sourceLineNo">387</span><a id="line.387">    public L getAt(int index) {</a>
+<span class="sourceLineNo">388</span><a id="line.388">      return (L) array[index];</a>
+<span class="sourceLineNo">389</span><a id="line.389">    }</a>
+<span class="sourceLineNo">390</span><a id="line.390"></a>
+<span class="sourceLineNo">391</span><a id="line.391">    @Override</a>
+<span class="sourceLineNo">392</span><a id="line.392">    public int size() {</a>
+<span class="sourceLineNo">393</span><a id="line.393">      return array.length;</a>
+<span class="sourceLineNo">394</span><a id="line.394">    }</a>
+<span class="sourceLineNo">395</span><a id="line.395">  }</a>
+<span class="sourceLineNo">396</span><a id="line.396"></a>
+<span class="sourceLineNo">397</span><a id="line.397">  /**</a>
+<span class="sourceLineNo">398</span><a id="line.398">   * Implementation of Striped where up to 2^k stripes can be represented, using an</a>
+<span class="sourceLineNo">399</span><a id="line.399">   * AtomicReferenceArray of size 2^k. To map a user key into a stripe, we take a k-bit slice of the</a>
+<span class="sourceLineNo">400</span><a id="line.400">   * user key's (smeared) hashCode(). The stripes are lazily initialized and are weakly referenced.</a>
+<span class="sourceLineNo">401</span><a id="line.401">   */</a>
+<span class="sourceLineNo">402</span><a id="line.402">  @VisibleForTesting</a>
+<span class="sourceLineNo">403</span><a id="line.403">  static class SmallLazyStriped&lt;L&gt; extends PowerOfTwoStriped&lt;L&gt; {</a>
+<span class="sourceLineNo">404</span><a id="line.404">    final AtomicReferenceArray&lt;@Nullable ArrayReference&lt;? extends L&gt;&gt; locks;</a>
+<span class="sourceLineNo">405</span><a id="line.405">    final Supplier&lt;L&gt; supplier;</a>
+<span class="sourceLineNo">406</span><a id="line.406">    final int size;</a>
+<span class="sourceLineNo">407</span><a id="line.407">    final ReferenceQueue&lt;L&gt; queue = new ReferenceQueue&lt;&gt;();</a>
+<span class="sourceLineNo">408</span><a id="line.408"></a>
+<span class="sourceLineNo">409</span><a id="line.409">    SmallLazyStriped(int stripes, Supplier&lt;L&gt; supplier) {</a>
+<span class="sourceLineNo">410</span><a id="line.410">      super(stripes);</a>
+<span class="sourceLineNo">411</span><a id="line.411">      this.size = (mask == ALL_SET) ? Integer.MAX_VALUE : mask + 1;</a>
+<span class="sourceLineNo">412</span><a id="line.412">      this.locks = new AtomicReferenceArray&lt;&gt;(size);</a>
+<span class="sourceLineNo">413</span><a id="line.413">      this.supplier = supplier;</a>
+<span class="sourceLineNo">414</span><a id="line.414">    }</a>
+<span class="sourceLineNo">415</span><a id="line.415"></a>
+<span class="sourceLineNo">416</span><a id="line.416">    @Override</a>
+<span class="sourceLineNo">417</span><a id="line.417">    public L getAt(int index) {</a>
+<span class="sourceLineNo">418</span><a id="line.418">      if (size != Integer.MAX_VALUE) {</a>
+<span class="sourceLineNo">419</span><a id="line.419">        Preconditions.checkElementIndex(index, size());</a>
+<span class="sourceLineNo">420</span><a id="line.420">      } // else no check necessary, all index values are valid</a>
+<span class="sourceLineNo">421</span><a id="line.421">      ArrayReference&lt;? extends L&gt; existingRef = locks.get(index);</a>
+<span class="sourceLineNo">422</span><a id="line.422">      L existing = existingRef == null ? null : existingRef.get();</a>
+<span class="sourceLineNo">423</span><a id="line.423">      if (existing != null) {</a>
+<span class="sourceLineNo">424</span><a id="line.424">        return existing;</a>
+<span class="sourceLineNo">425</span><a id="line.425">      }</a>
+<span class="sourceLineNo">426</span><a id="line.426">      L created = supplier.get();</a>
+<span class="sourceLineNo">427</span><a id="line.427">      ArrayReference&lt;L&gt; newRef = new ArrayReference&lt;&gt;(created, index, queue);</a>
+<span class="sourceLineNo">428</span><a id="line.428">      while (!locks.compareAndSet(index, existingRef, newRef)) {</a>
+<span class="sourceLineNo">429</span><a id="line.429">        // we raced, we need to re-read and try again</a>
+<span class="sourceLineNo">430</span><a id="line.430">        existingRef = locks.get(index);</a>
+<span class="sourceLineNo">431</span><a id="line.431">        existing = existingRef == null ? null : existingRef.get();</a>
+<span class="sourceLineNo">432</span><a id="line.432">        if (existing != null) {</a>
+<span class="sourceLineNo">433</span><a id="line.433">          return existing;</a>
+<span class="sourceLineNo">434</span><a id="line.434">        }</a>
+<span class="sourceLineNo">435</span><a id="line.435">      }</a>
+<span class="sourceLineNo">436</span><a id="line.436">      drainQueue();</a>
+<span class="sourceLineNo">437</span><a id="line.437">      return created;</a>
+<span class="sourceLineNo">438</span><a id="line.438">    }</a>
+<span class="sourceLineNo">439</span><a id="line.439"></a>
+<span class="sourceLineNo">440</span><a id="line.440">    // N.B. Draining the queue is only necessary to ensure that we don't accumulate empty references</a>
+<span class="sourceLineNo">441</span><a id="line.441">    // in the array. We could skip this if we decide we don't care about holding on to Reference</a>
+<span class="sourceLineNo">442</span><a id="line.442">    // objects indefinitely.</a>
+<span class="sourceLineNo">443</span><a id="line.443">    private void drainQueue() {</a>
+<span class="sourceLineNo">444</span><a id="line.444">      Reference&lt;? extends L&gt; ref;</a>
+<span class="sourceLineNo">445</span><a id="line.445">      while ((ref = queue.poll()) != null) {</a>
+<span class="sourceLineNo">446</span><a id="line.446">        // We only ever register ArrayReferences with the queue so this is always safe.</a>
+<span class="sourceLineNo">447</span><a id="line.447">        ArrayReference&lt;? extends L&gt; arrayRef = (ArrayReference&lt;? extends L&gt;) ref;</a>
+<span class="sourceLineNo">448</span><a id="line.448">        // Try to clear out the array slot, n.b. if we fail that is fine, in either case the</a>
+<span class="sourceLineNo">449</span><a id="line.449">        // arrayRef will be out of the array after this step.</a>
+<span class="sourceLineNo">450</span><a id="line.450">        locks.compareAndSet(arrayRef.index, arrayRef, null);</a>
+<span class="sourceLineNo">451</span><a id="line.451">      }</a>
+<span class="sourceLineNo">452</span><a id="line.452">    }</a>
 <span class="sourceLineNo">453</span><a id="line.453"></a>
-<span class="sourceLineNo">454</span><a id="line.454">      ArrayReference(L referent, int index, ReferenceQueue&lt;L&gt; queue) {</a>
-<span class="sourceLineNo">455</span><a id="line.455">        super(referent, queue);</a>
-<span class="sourceLineNo">456</span><a id="line.456">        this.index = index;</a>
-<span class="sourceLineNo">457</span><a id="line.457">      }</a>
-<span class="sourceLineNo">458</span><a id="line.458">    }</a>
-<span class="sourceLineNo">459</span><a id="line.459">  }</a>
-<span class="sourceLineNo">460</span><a id="line.460"></a>
-<span class="sourceLineNo">461</span><a id="line.461">  /**</a>
-<span class="sourceLineNo">462</span><a id="line.462">   * Implementation of Striped where up to 2^k stripes can be represented, using a ConcurrentMap</a>
-<span class="sourceLineNo">463</span><a id="line.463">   * where the key domain is [0..2^k). To map a user key into a stripe, we take a k-bit slice of the</a>
-<span class="sourceLineNo">464</span><a id="line.464">   * user key's (smeared) hashCode(). The stripes are lazily initialized and are weakly referenced.</a>
-<span class="sourceLineNo">465</span><a id="line.465">   */</a>
-<span class="sourceLineNo">466</span><a id="line.466">  @VisibleForTesting</a>
-<span class="sourceLineNo">467</span><a id="line.467">  static class LargeLazyStriped&lt;L&gt; extends PowerOfTwoStriped&lt;L&gt; {</a>
-<span class="sourceLineNo">468</span><a id="line.468">    final ConcurrentMap&lt;Integer, L&gt; locks;</a>
-<span class="sourceLineNo">469</span><a id="line.469">    final Supplier&lt;L&gt; supplier;</a>
-<span class="sourceLineNo">470</span><a id="line.470">    final int size;</a>
-<span class="sourceLineNo">471</span><a id="line.471"></a>
-<span class="sourceLineNo">472</span><a id="line.472">    LargeLazyStriped(int stripes, Supplier&lt;L&gt; supplier) {</a>
-<span class="sourceLineNo">473</span><a id="line.473">      super(stripes);</a>
-<span class="sourceLineNo">474</span><a id="line.474">      this.size = (mask == ALL_SET) ? Integer.MAX_VALUE : mask + 1;</a>
-<span class="sourceLineNo">475</span><a id="line.475">      this.supplier = supplier;</a>
-<span class="sourceLineNo">476</span><a id="line.476">      this.locks = new MapMaker().weakValues().makeMap();</a>
-<span class="sourceLineNo">477</span><a id="line.477">    }</a>
-<span class="sourceLineNo">478</span><a id="line.478"></a>
-<span class="sourceLineNo">479</span><a id="line.479">    @Override</a>
-<span class="sourceLineNo">480</span><a id="line.480">    public L getAt(int index) {</a>
-<span class="sourceLineNo">481</span><a id="line.481">      if (size != Integer.MAX_VALUE) {</a>
-<span class="sourceLineNo">482</span><a id="line.482">        Preconditions.checkElementIndex(index, size());</a>
-<span class="sourceLineNo">483</span><a id="line.483">      } // else no check necessary, all index values are valid</a>
-<span class="sourceLineNo">484</span><a id="line.484">      L existing = locks.get(index);</a>
-<span class="sourceLineNo">485</span><a id="line.485">      if (existing != null) {</a>
-<span class="sourceLineNo">486</span><a id="line.486">        return existing;</a>
-<span class="sourceLineNo">487</span><a id="line.487">      }</a>
-<span class="sourceLineNo">488</span><a id="line.488">      L created = supplier.get();</a>
-<span class="sourceLineNo">489</span><a id="line.489">      existing = locks.putIfAbsent(index, created);</a>
-<span class="sourceLineNo">490</span><a id="line.490">      return MoreObjects.firstNonNull(existing, created);</a>
-<span class="sourceLineNo">491</span><a id="line.491">    }</a>
-<span class="sourceLineNo">492</span><a id="line.492"></a>
-<span class="sourceLineNo">493</span><a id="line.493">    @Override</a>
-<span class="sourceLineNo">494</span><a id="line.494">    public int size() {</a>
-<span class="sourceLineNo">495</span><a id="line.495">      return size;</a>
-<span class="sourceLineNo">496</span><a id="line.496">    }</a>
-<span class="sourceLineNo">497</span><a id="line.497">  }</a>
-<span class="sourceLineNo">498</span><a id="line.498"></a>
-<span class="sourceLineNo">499</span><a id="line.499">  /** A bit mask were all bits are set. */</a>
-<span class="sourceLineNo">500</span><a id="line.500">  private static final int ALL_SET = ~0;</a>
-<span class="sourceLineNo">501</span><a id="line.501"></a>
-<span class="sourceLineNo">502</span><a id="line.502">  private static int ceilToPowerOfTwo(int x) {</a>
-<span class="sourceLineNo">503</span><a id="line.503">    return 1 &lt;&lt; IntMath.log2(x, RoundingMode.CEILING);</a>
-<span class="sourceLineNo">504</span><a id="line.504">  }</a>
-<span class="sourceLineNo">505</span><a id="line.505"></a>
-<span class="sourceLineNo">506</span><a id="line.506">  /*</a>
-<span class="sourceLineNo">507</span><a id="line.507">   * This method was written by Doug Lea with assistance from members of JCP JSR-166 Expert Group</a>
-<span class="sourceLineNo">508</span><a id="line.508">   * and released to the public domain, as explained at</a>
-<span class="sourceLineNo">509</span><a id="line.509">   * http://creativecommons.org/licenses/publicdomain</a>
-<span class="sourceLineNo">510</span><a id="line.510">   *</a>
-<span class="sourceLineNo">511</span><a id="line.511">   * As of 2010/06/11, this method is identical to the (package private) hash method in OpenJDK 7's</a>
-<span class="sourceLineNo">512</span><a id="line.512">   * java.util.HashMap class.</a>
-<span class="sourceLineNo">513</span><a id="line.513">   */</a>
-<span class="sourceLineNo">514</span><a id="line.514">  // Copied from java/com/google/common/collect/Hashing.java</a>
-<span class="sourceLineNo">515</span><a id="line.515">  private static int smear(int hashCode) {</a>
-<span class="sourceLineNo">516</span><a id="line.516">    hashCode ^= (hashCode &gt;&gt;&gt; 20) ^ (hashCode &gt;&gt;&gt; 12);</a>
-<span class="sourceLineNo">517</span><a id="line.517">    return hashCode ^ (hashCode &gt;&gt;&gt; 7) ^ (hashCode &gt;&gt;&gt; 4);</a>
-<span class="sourceLineNo">518</span><a id="line.518">  }</a>
-<span class="sourceLineNo">519</span><a id="line.519"></a>
-<span class="sourceLineNo">520</span><a id="line.520">  private static class PaddedLock extends ReentrantLock {</a>
-<span class="sourceLineNo">521</span><a id="line.521">    /*</a>
-<span class="sourceLineNo">522</span><a id="line.522">     * Padding from 40 into 64 bytes, same size as cache line. Might be beneficial to add a fourth</a>
-<span class="sourceLineNo">523</span><a id="line.523">     * long here, to minimize chance of interference between consecutive locks, but I couldn't</a>
-<span class="sourceLineNo">524</span><a id="line.524">     * observe any benefit from that.</a>
-<span class="sourceLineNo">525</span><a id="line.525">     */</a>
-<span class="sourceLineNo">526</span><a id="line.526">    long unused1;</a>
-<span class="sourceLineNo">527</span><a id="line.527">    long unused2;</a>
-<span class="sourceLineNo">528</span><a id="line.528">    long unused3;</a>
-<span class="sourceLineNo">529</span><a id="line.529"></a>
-<span class="sourceLineNo">530</span><a id="line.530">    PaddedLock() {</a>
-<span class="sourceLineNo">531</span><a id="line.531">      super(false);</a>
-<span class="sourceLineNo">532</span><a id="line.532">    }</a>
-<span class="sourceLineNo">533</span><a id="line.533">  }</a>
-<span class="sourceLineNo">534</span><a id="line.534"></a>
-<span class="sourceLineNo">535</span><a id="line.535">  private static class PaddedSemaphore extends Semaphore {</a>
-<span class="sourceLineNo">536</span><a id="line.536">    // See PaddedReentrantLock comment</a>
-<span class="sourceLineNo">537</span><a id="line.537">    long unused1;</a>
-<span class="sourceLineNo">538</span><a id="line.538">    long unused2;</a>
-<span class="sourceLineNo">539</span><a id="line.539">    long unused3;</a>
-<span class="sourceLineNo">540</span><a id="line.540"></a>
-<span class="sourceLineNo">541</span><a id="line.541">    PaddedSemaphore(int permits) {</a>
-<span class="sourceLineNo">542</span><a id="line.542">      super(permits, false);</a>
-<span class="sourceLineNo">543</span><a id="line.543">    }</a>
-<span class="sourceLineNo">544</span><a id="line.544">  }</a>
-<span class="sourceLineNo">545</span><a id="line.545">}</a>
+<span class="sourceLineNo">454</span><a id="line.454">    @Override</a>
+<span class="sourceLineNo">455</span><a id="line.455">    public int size() {</a>
+<span class="sourceLineNo">456</span><a id="line.456">      return size;</a>
+<span class="sourceLineNo">457</span><a id="line.457">    }</a>
+<span class="sourceLineNo">458</span><a id="line.458"></a>
+<span class="sourceLineNo">459</span><a id="line.459">    private static final class ArrayReference&lt;L&gt; extends WeakReference&lt;L&gt; {</a>
+<span class="sourceLineNo">460</span><a id="line.460">      final int index;</a>
+<span class="sourceLineNo">461</span><a id="line.461"></a>
+<span class="sourceLineNo">462</span><a id="line.462">      ArrayReference(L referent, int index, ReferenceQueue&lt;L&gt; queue) {</a>
+<span class="sourceLineNo">463</span><a id="line.463">        super(referent, queue);</a>
+<span class="sourceLineNo">464</span><a id="line.464">        this.index = index;</a>
+<span class="sourceLineNo">465</span><a id="line.465">      }</a>
+<span class="sourceLineNo">466</span><a id="line.466">    }</a>
+<span class="sourceLineNo">467</span><a id="line.467">  }</a>
+<span class="sourceLineNo">468</span><a id="line.468"></a>
+<span class="sourceLineNo">469</span><a id="line.469">  /**</a>
+<span class="sourceLineNo">470</span><a id="line.470">   * Implementation of Striped where up to 2^k stripes can be represented, using a ConcurrentMap</a>
+<span class="sourceLineNo">471</span><a id="line.471">   * where the key domain is [0..2^k). To map a user key into a stripe, we take a k-bit slice of the</a>
+<span class="sourceLineNo">472</span><a id="line.472">   * user key's (smeared) hashCode(). The stripes are lazily initialized and are weakly referenced.</a>
+<span class="sourceLineNo">473</span><a id="line.473">   */</a>
+<span class="sourceLineNo">474</span><a id="line.474">  @VisibleForTesting</a>
+<span class="sourceLineNo">475</span><a id="line.475">  static class LargeLazyStriped&lt;L&gt; extends PowerOfTwoStriped&lt;L&gt; {</a>
+<span class="sourceLineNo">476</span><a id="line.476">    final ConcurrentMap&lt;Integer, L&gt; locks;</a>
+<span class="sourceLineNo">477</span><a id="line.477">    final Supplier&lt;L&gt; supplier;</a>
+<span class="sourceLineNo">478</span><a id="line.478">    final int size;</a>
+<span class="sourceLineNo">479</span><a id="line.479"></a>
+<span class="sourceLineNo">480</span><a id="line.480">    LargeLazyStriped(int stripes, Supplier&lt;L&gt; supplier) {</a>
+<span class="sourceLineNo">481</span><a id="line.481">      super(stripes);</a>
+<span class="sourceLineNo">482</span><a id="line.482">      this.size = (mask == ALL_SET) ? Integer.MAX_VALUE : mask + 1;</a>
+<span class="sourceLineNo">483</span><a id="line.483">      this.supplier = supplier;</a>
+<span class="sourceLineNo">484</span><a id="line.484">      this.locks = new MapMaker().weakValues().makeMap();</a>
+<span class="sourceLineNo">485</span><a id="line.485">    }</a>
+<span class="sourceLineNo">486</span><a id="line.486"></a>
+<span class="sourceLineNo">487</span><a id="line.487">    @Override</a>
+<span class="sourceLineNo">488</span><a id="line.488">    public L getAt(int index) {</a>
+<span class="sourceLineNo">489</span><a id="line.489">      if (size != Integer.MAX_VALUE) {</a>
+<span class="sourceLineNo">490</span><a id="line.490">        Preconditions.checkElementIndex(index, size());</a>
+<span class="sourceLineNo">491</span><a id="line.491">      } // else no check necessary, all index values are valid</a>
+<span class="sourceLineNo">492</span><a id="line.492">      L existing = locks.get(index);</a>
+<span class="sourceLineNo">493</span><a id="line.493">      if (existing != null) {</a>
+<span class="sourceLineNo">494</span><a id="line.494">        return existing;</a>
+<span class="sourceLineNo">495</span><a id="line.495">      }</a>
+<span class="sourceLineNo">496</span><a id="line.496">      L created = supplier.get();</a>
+<span class="sourceLineNo">497</span><a id="line.497">      existing = locks.putIfAbsent(index, created);</a>
+<span class="sourceLineNo">498</span><a id="line.498">      return MoreObjects.firstNonNull(existing, created);</a>
+<span class="sourceLineNo">499</span><a id="line.499">    }</a>
+<span class="sourceLineNo">500</span><a id="line.500"></a>
+<span class="sourceLineNo">501</span><a id="line.501">    @Override</a>
+<span class="sourceLineNo">502</span><a id="line.502">    public int size() {</a>
+<span class="sourceLineNo">503</span><a id="line.503">      return size;</a>
+<span class="sourceLineNo">504</span><a id="line.504">    }</a>
+<span class="sourceLineNo">505</span><a id="line.505">  }</a>
+<span class="sourceLineNo">506</span><a id="line.506"></a>
+<span class="sourceLineNo">507</span><a id="line.507">  /** A bit mask were all bits are set. */</a>
+<span class="sourceLineNo">508</span><a id="line.508">  private static final int ALL_SET = ~0;</a>
+<span class="sourceLineNo">509</span><a id="line.509"></a>
+<span class="sourceLineNo">510</span><a id="line.510">  private static int ceilToPowerOfTwo(int x) {</a>
+<span class="sourceLineNo">511</span><a id="line.511">    return 1 &lt;&lt; IntMath.log2(x, RoundingMode.CEILING);</a>
+<span class="sourceLineNo">512</span><a id="line.512">  }</a>
+<span class="sourceLineNo">513</span><a id="line.513"></a>
+<span class="sourceLineNo">514</span><a id="line.514">  /*</a>
+<span class="sourceLineNo">515</span><a id="line.515">   * This method was written by Doug Lea with assistance from members of JCP JSR-166 Expert Group</a>
+<span class="sourceLineNo">516</span><a id="line.516">   * and released to the public domain, as explained at</a>
+<span class="sourceLineNo">517</span><a id="line.517">   * http://creativecommons.org/licenses/publicdomain</a>
+<span class="sourceLineNo">518</span><a id="line.518">   *</a>
+<span class="sourceLineNo">519</span><a id="line.519">   * As of 2010/06/11, this method is identical to the (package private) hash method in OpenJDK 7's</a>
+<span class="sourceLineNo">520</span><a id="line.520">   * java.util.HashMap class.</a>
+<span class="sourceLineNo">521</span><a id="line.521">   */</a>
+<span class="sourceLineNo">522</span><a id="line.522">  // Copied from java/com/google/common/collect/Hashing.java</a>
+<span class="sourceLineNo">523</span><a id="line.523">  private static int smear(int hashCode) {</a>
+<span class="sourceLineNo">524</span><a id="line.524">    hashCode ^= (hashCode &gt;&gt;&gt; 20) ^ (hashCode &gt;&gt;&gt; 12);</a>
+<span class="sourceLineNo">525</span><a id="line.525">    return hashCode ^ (hashCode &gt;&gt;&gt; 7) ^ (hashCode &gt;&gt;&gt; 4);</a>
+<span class="sourceLineNo">526</span><a id="line.526">  }</a>
+<span class="sourceLineNo">527</span><a id="line.527"></a>
+<span class="sourceLineNo">528</span><a id="line.528">  private static class PaddedLock extends ReentrantLock {</a>
+<span class="sourceLineNo">529</span><a id="line.529">    /*</a>
+<span class="sourceLineNo">530</span><a id="line.530">     * Padding from 40 into 64 bytes, same size as cache line. Might be beneficial to add a fourth</a>
+<span class="sourceLineNo">531</span><a id="line.531">     * long here, to minimize chance of interference between consecutive locks, but I couldn't</a>
+<span class="sourceLineNo">532</span><a id="line.532">     * observe any benefit from that.</a>
+<span class="sourceLineNo">533</span><a id="line.533">     */</a>
+<span class="sourceLineNo">534</span><a id="line.534">    long unused1;</a>
+<span class="sourceLineNo">535</span><a id="line.535">    long unused2;</a>
+<span class="sourceLineNo">536</span><a id="line.536">    long unused3;</a>
+<span class="sourceLineNo">537</span><a id="line.537"></a>
+<span class="sourceLineNo">538</span><a id="line.538">    PaddedLock() {</a>
+<span class="sourceLineNo">539</span><a id="line.539">      super(false);</a>
+<span class="sourceLineNo">540</span><a id="line.540">    }</a>
+<span class="sourceLineNo">541</span><a id="line.541">  }</a>
+<span class="sourceLineNo">542</span><a id="line.542"></a>
+<span class="sourceLineNo">543</span><a id="line.543">  private static class PaddedSemaphore extends Semaphore {</a>
+<span class="sourceLineNo">544</span><a id="line.544">    // See PaddedReentrantLock comment</a>
+<span class="sourceLineNo">545</span><a id="line.545">    long unused1;</a>
+<span class="sourceLineNo">546</span><a id="line.546">    long unused2;</a>
+<span class="sourceLineNo">547</span><a id="line.547">    long unused3;</a>
+<span class="sourceLineNo">548</span><a id="line.548"></a>
+<span class="sourceLineNo">549</span><a id="line.549">    PaddedSemaphore(int permits) {</a>
+<span class="sourceLineNo">550</span><a id="line.550">      super(permits, false);</a>
+<span class="sourceLineNo">551</span><a id="line.551">    }</a>
+<span class="sourceLineNo">552</span><a id="line.552">  }</a>
+<span class="sourceLineNo">553</span><a id="line.553">}</a>
 
 
 
diff --git a/releases/snapshot-jre/api/docs/type-search-index.zip b/releases/snapshot-jre/api/docs/type-search-index.zip
index 5179e037ac4f..0f5fab8f6e8d 100644
Binary files a/releases/snapshot-jre/api/docs/type-search-index.zip and b/releases/snapshot-jre/api/docs/type-search-index.zip differ