ignite-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From yzhda...@apache.org
Subject [06/27] incubator-ignite git commit: IGNITE-59 Support lock, lockAll. Make async oprtations work via IgniteAsyncSupport.
Date Wed, 21 Jan 2015 17:30:28 GMT
IGNITE-59 Support lock, lockAll. Make async oprtations work via IgniteAsyncSupport.


Project: http://git-wip-us.apache.org/repos/asf/incubator-ignite/repo
Commit: http://git-wip-us.apache.org/repos/asf/incubator-ignite/commit/cbb74d61
Tree: http://git-wip-us.apache.org/repos/asf/incubator-ignite/tree/cbb74d61
Diff: http://git-wip-us.apache.org/repos/asf/incubator-ignite/diff/cbb74d61

Branch: refs/heads/ignite-53
Commit: cbb74d610a42083fb220e2171eddfe99be19502d
Parents: 9b3cd61
Author: sevdokimov <sevdokimov@gridgain.com>
Authored: Mon Jan 19 21:19:54 2015 +0300
Committer: sevdokimov <sevdokimov@gridgain.com>
Committed: Mon Jan 19 21:19:54 2015 +0300

----------------------------------------------------------------------
 .../main/java/org/apache/ignite/CacheLock.java  |  45 ++----
 .../processors/cache/CacheLockAsyncImpl.java    | 144 +++++++++++++++++++
 .../processors/cache/CacheLockImpl.java         |  36 +++--
 .../cache/GridCacheAbstractFullApiSelfTest.java |  55 ++++---
 .../GridCacheMultiNodeLockAbstractTest.java     |  58 +++++---
 .../dht/GridCacheColocatedDebugTest.java        |  16 ++-
 .../near/GridCachePartitionedLockSelfTest.java  |  15 +-
 .../GridCacheLocalMultithreadedSelfTest.java    |  24 ++--
 8 files changed, 281 insertions(+), 112 deletions(-)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/cbb74d61/modules/core/src/main/java/org/apache/ignite/CacheLock.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/CacheLock.java b/modules/core/src/main/java/org/apache/ignite/CacheLock.java
index 9be14e0..f395261 100644
--- a/modules/core/src/main/java/org/apache/ignite/CacheLock.java
+++ b/modules/core/src/main/java/org/apache/ignite/CacheLock.java
@@ -18,8 +18,6 @@
 package org.apache.ignite;
 
 import org.apache.ignite.lang.*;
-import org.apache.ignite.transactions.*;
-import org.gridgain.grid.cache.*;
 
 import java.util.concurrent.*;
 import java.util.concurrent.locks.*;
@@ -27,7 +25,7 @@ import java.util.concurrent.locks.*;
 /**
  * Lock associated with some cache keys.
  */
-public interface CacheLock extends Lock {
+public interface CacheLock extends Lock, IgniteAsyncSupport {
     /**
      * Checks if any node holds lock on at least one key associated with this {@code CacheLock}.
      * <p>
@@ -50,37 +48,14 @@ public interface CacheLock extends Lock {
      */
     public boolean isLockedByThread();
 
-    /**
-     * Asynchronously acquires lock on a cached object with keys associated with this {@code
CacheLock}.
-     * <h2 class="header">Transactions</h2>
-     * Locks are not transactional and should not be used from within transactions. If you
do
-     * need explicit locking within transaction, then you should use
-     * {@link IgniteTxConcurrency#PESSIMISTIC} concurrency control for transaction
-     * which will acquire explicit locks for relevant cache operations.
-     * <h2 class="header">Cache Flags</h2>
-     * This method is not available if any of the following flags are set on projection:
-     * {@link GridCacheFlag#LOCAL}, {@link GridCacheFlag#READ}.
-     *
-     * @return Future for the lock operation. The future will return {@code true}.
-     */
-    public IgniteFuture<Boolean> lockAsync();
+    /** {@inheritDoc} */
+    @IgniteAsyncSupported
+    @Override public void lock();
 
-    /**
-     * Asynchronously acquires lock on a cached object with given keys associated with this
{@code CacheLock}.
-     * <h2 class="header">Transactions</h2>
-     * Locks are not transactional and should not be used from within transactions. If you
do
-     * need explicit locking within transaction, then you should use
-     * {@link IgniteTxConcurrency#PESSIMISTIC} concurrency control for transaction
-     * which will acquire explicit locks for relevant cache operations.
-     * <h2 class="header">Cache Flags</h2>
-     * This method is not available if any of the following flags are set on projection:
-     * {@link GridCacheFlag#LOCAL}, {@link GridCacheFlag#READ}.
-     *
-     * @param timeout The maximum time to wait for the lock. If the time is less than or
equal to zero, the method will
-     *      not wait at all.
-     * @param unit The time unit of the {@code timeout} argument.
-     * @return Future for the lock operation. The future will return {@code true} whenever
locks are acquired before
-     *      timeout is expired, {@code false} otherwise.
-     */
-    public IgniteFuture<Boolean> lockAsync(long timeout, TimeUnit unit);
+    /** {@inheritDoc} */
+    @IgniteAsyncSupported
+    @Override public boolean tryLock(long time, TimeUnit unit) throws InterruptedException;
+
+    /** {@inheritDoc} */
+    @Override public CacheLock enableAsync();
 }

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/cbb74d61/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/CacheLockAsyncImpl.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/CacheLockAsyncImpl.java
b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/CacheLockAsyncImpl.java
new file mode 100644
index 0000000..4b058bd
--- /dev/null
+++ b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/CacheLockAsyncImpl.java
@@ -0,0 +1,144 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.ignite.internal.processors.cache;
+
+import org.apache.ignite.*;
+import org.apache.ignite.lang.*;
+import org.gridgain.grid.*;
+import org.gridgain.grid.kernal.processors.cache.*;
+import org.jetbrains.annotations.*;
+
+import javax.cache.*;
+import java.util.*;
+import java.util.concurrent.*;
+import java.util.concurrent.locks.*;
+
+/**
+ *
+ * @param <K>
+ */
+class CacheLockAsyncImpl<K> implements CacheLock {
+    /** */
+    private final GridCacheProjectionEx<K, ?> delegate;
+
+    /** */
+    private final Collection<? extends K> keys;
+
+    /** Future for previous asynchronous operation. */
+    protected ThreadLocal<IgniteFuture<?>> curFut;
+
+    /**
+     * @param delegate Delegate.
+     * @param keys Keys.
+     */
+    CacheLockAsyncImpl(GridCacheProjectionEx<K, ?> delegate, Collection<? extends
K> keys) {
+        this.delegate = delegate;
+        this.keys = keys;
+    }
+
+    /** {@inheritDoc} */
+    @Override public boolean isLocked() {
+        for (K key : keys) {
+            if (!delegate.isLocked(key))
+                return false;
+        }
+
+        return true;
+    }
+
+    /** {@inheritDoc} */
+    @Override public boolean isLockedByThread() {
+        for (K key : keys) {
+            if (!delegate.isLockedByThread(key))
+                return false;
+        }
+
+        return true;
+    }
+
+    /** {@inheritDoc} */
+    @Override public void lock() {
+        IgniteFuture<Boolean> fut = delegate.lockAllAsync(keys, 0);
+
+        curFut.set(fut);
+    }
+
+    /** {@inheritDoc} */
+    @Override public void lockInterruptibly() throws InterruptedException {
+        tryLock(-1, TimeUnit.MILLISECONDS);
+    }
+
+    /** {@inheritDoc} */
+    @Override public boolean tryLock() {
+        try {
+            return delegate.lockAll(keys, -1);
+        }
+        catch (IgniteCheckedException e) {
+            throw new CacheException(e.getMessage(), e);
+        }
+    }
+
+    /** {@inheritDoc} */
+    @Override public boolean tryLock(long time, TimeUnit unit) {
+        if (time <= 0)
+            return tryLock();
+
+        IgniteFuture<Boolean> fut = delegate.lockAllAsync(keys, unit.toMillis(time));
+
+        curFut.set(fut);
+
+        return true;
+    }
+
+    /** {@inheritDoc} */
+    @Override public void unlock() {
+        try {
+            delegate.unlockAll(keys);
+        }
+        catch (IgniteCheckedException e) {
+            throw new CacheException(e.getMessage(), e);
+        }
+    }
+
+    /** {@inheritDoc} */
+    @NotNull @Override public Condition newCondition() {
+        throw new UnsupportedOperationException();
+    }
+
+    /** {@inheritDoc} */
+    @Override public CacheLock enableAsync() {
+        return this;
+    }
+
+    /** {@inheritDoc} */
+    @Override public boolean isAsync() {
+        return true;
+    }
+
+    /** {@inheritDoc} */
+    @Override public <R> IgniteFuture<R> future() {
+        IgniteFuture<?> fut = curFut.get();
+
+        if (fut == null)
+            throw new IllegalStateException("Asynchronous operation not started.");
+
+        curFut.set(null);
+
+        return (IgniteFuture<R>)fut;
+    }
+}

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/cbb74d61/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/CacheLockImpl.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/CacheLockImpl.java
b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/CacheLockImpl.java
index f60b157..e80c7f8 100644
--- a/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/CacheLockImpl.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/processors/cache/CacheLockImpl.java
@@ -39,6 +39,9 @@ class CacheLockImpl<K> implements CacheLock {
     /** */
     private final Collection<? extends K> keys;
 
+    /** */
+    private volatile CacheLockAsyncImpl<K> async;
+
     /**
      * @param delegate Delegate.
      * @param keys Keys.
@@ -69,16 +72,6 @@ class CacheLockImpl<K> implements CacheLock {
     }
 
     /** {@inheritDoc} */
-    @Override public IgniteFuture<Boolean> lockAsync() {
-        return delegate.lockAllAsync(keys, 0);
-    }
-
-    /** {@inheritDoc} */
-    @Override public IgniteFuture<Boolean> lockAsync(long timeout, TimeUnit unit) {
-        return delegate.lockAllAsync(keys, unit.toMillis(timeout));
-    }
-
-    /** {@inheritDoc} */
     @Override public void lock() {
         try {
             delegate.lockAll(keys, 0);
@@ -157,4 +150,27 @@ class CacheLockImpl<K> implements CacheLock {
     @NotNull @Override public Condition newCondition() {
         throw new UnsupportedOperationException();
     }
+
+    /** {@inheritDoc} */
+    @Override public CacheLock enableAsync() {
+        CacheLockAsyncImpl<K> async = this.async;
+
+        if (async == null) {
+            async = new CacheLockAsyncImpl<>(delegate, keys);
+
+            this.async = async;
+        }
+
+        return async;
+    }
+
+    /** {@inheritDoc} */
+    @Override public boolean isAsync() {
+        return false;
+    }
+
+    /** {@inheritDoc} */
+    @Override public <R> IgniteFuture<R> future() {
+        throw new IllegalStateException("Asynchronous mode is not enabled.");
+    }
 }

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/cbb74d61/modules/core/src/test/java/org/gridgain/grid/kernal/processors/cache/GridCacheAbstractFullApiSelfTest.java
----------------------------------------------------------------------
diff --git a/modules/core/src/test/java/org/gridgain/grid/kernal/processors/cache/GridCacheAbstractFullApiSelfTest.java
b/modules/core/src/test/java/org/gridgain/grid/kernal/processors/cache/GridCacheAbstractFullApiSelfTest.java
index 2fb802b..57f9c59 100644
--- a/modules/core/src/test/java/org/gridgain/grid/kernal/processors/cache/GridCacheAbstractFullApiSelfTest.java
+++ b/modules/core/src/test/java/org/gridgain/grid/kernal/processors/cache/GridCacheAbstractFullApiSelfTest.java
@@ -3346,23 +3346,28 @@ public abstract class GridCacheAbstractFullApiSelfTest extends GridCacheAbstract
     @SuppressWarnings("BusyWait")
     public void testLockAsync() throws Exception {
         if (lockingEnabled()) {
-            cache().put("key", 1);
+            IgniteCache<String, Integer> cache = jcache();
+
+            CacheLock lock = cache.lock("key");
+
+            cache.put("key", 1);
 
-            assert !cache().isLocked("key");
+            assert !lock.isLocked();
 
-            cache().lockAsync("key", 0).get();
+            lock.enableAsync().lock();
+            lock.enableAsync().future().get();
 
-            assert cache().isLocked("key");
+            assert lock.isLocked();
 
-            cache().unlock("key");
+            lock.unlock();
 
             for (int i = 0; i < 100; i++)
-                if (cache().isLocked("key"))
+                if (lock.isLocked())
                     Thread.sleep(10);
                 else
                     break;
 
-            assert !cache().isLocked("key");
+            assert !cache.isLocked("key");
         }
     }
 
@@ -3456,23 +3461,29 @@ public abstract class GridCacheAbstractFullApiSelfTest extends GridCacheAbstract
     @SuppressWarnings("BusyWait")
     public void testLockAsyncWithTimeout() throws Exception {
         if (lockingEnabled()) {
-            cache().put("key", 1);
+            final IgniteCache<String, Integer> cache = jcache();
 
-            assert !cache().isLocked("key");
+            cache.put("key", 1);
 
-            cache().lockAsync("key", 1000).get();
+            final CacheLock lock = cache.lock("key");
 
-            assert cache().isLocked("key");
-            assert cache().isLockedByThread("key");
+            assert !cache.isLocked("key");
+
+            lock.enableAsync().tryLock(1000, MILLISECONDS);
+            lock.enableAsync().future().get();
+
+            assert cache.isLocked("key");
+            assert cache.isLockedByThread("key");
 
             final CountDownLatch latch = new CountDownLatch(1);
 
             IgniteCompute comp = forLocal(dfltIgnite).enableAsync();
 
             comp.call(new Callable<Boolean>() {
-                @Override
-                public Boolean call() throws Exception {
-                    IgniteFuture<Boolean> f = cache().lockAsync("key", 1000);
+                @Override public Boolean call() throws Exception {
+                    lock.enableAsync().tryLock(1000, MILLISECONDS);
+
+                    IgniteFuture<Boolean> f = lock.enableAsync().future();
 
                     try {
                         f.get(100);
@@ -3487,7 +3498,7 @@ public abstract class GridCacheAbstractFullApiSelfTest extends GridCacheAbstract
                     try {
                         assert f.get();
                     } finally {
-                        cache().unlock("key");
+                        lock.unlock();
                     }
 
                     return true;
@@ -3499,21 +3510,21 @@ public abstract class GridCacheAbstractFullApiSelfTest extends GridCacheAbstract
                 // Let another thread start.
             latch.await();
 
-            assert cache().isLocked("key");
-            assert cache().isLockedByThread("key");
+            assert cache.isLocked("key");
+            assert cache.isLockedByThread("key");
 
-            cache().unlock("key");
+            lock.unlock();
 
             assert f.get();
 
             for (int i = 0; i < 100; i++)
-                if (cache().isLocked("key") || cache().isLockedByThread("key"))
+                if (cache.isLocked("key") || cache.isLockedByThread("key"))
                     Thread.sleep(10);
                 else
                     break;
 
-            assert !cache().isLocked("key");
-            assert !cache().isLockedByThread("key");
+            assert !cache.isLocked("key");
+            assert !cache.isLockedByThread("key");
         }
     }
 

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/cbb74d61/modules/core/src/test/java/org/gridgain/grid/kernal/processors/cache/distributed/GridCacheMultiNodeLockAbstractTest.java
----------------------------------------------------------------------
diff --git a/modules/core/src/test/java/org/gridgain/grid/kernal/processors/cache/distributed/GridCacheMultiNodeLockAbstractTest.java
b/modules/core/src/test/java/org/gridgain/grid/kernal/processors/cache/distributed/GridCacheMultiNodeLockAbstractTest.java
index 1374be2..257d260 100644
--- a/modules/core/src/test/java/org/gridgain/grid/kernal/processors/cache/distributed/GridCacheMultiNodeLockAbstractTest.java
+++ b/modules/core/src/test/java/org/gridgain/grid/kernal/processors/cache/distributed/GridCacheMultiNodeLockAbstractTest.java
@@ -17,6 +17,7 @@
 
 package org.gridgain.grid.kernal.processors.cache.distributed;
 
+import com.google.common.collect.*;
 import org.apache.ignite.*;
 import org.apache.ignite.configuration.*;
 import org.apache.ignite.events.*;
@@ -375,10 +376,15 @@ public abstract class GridCacheMultiNodeLockAbstractTest extends GridCommonAbstr
      * @throws Exception If test fails.
      */
     public void testMultiNodeLockAsync() throws Exception {
-        GridCache<Integer, String> cache1 = ignite1.cache(null);
-        GridCache<Integer, String> cache2 = ignite2.cache(null);
+        IgniteCache<Integer, String> cache1 = ignite1.jcache(null);
+        IgniteCache<Integer, String> cache2 = ignite2.jcache(null);
+
+        CacheLock lock1_1 = cache1.lock(1);
+        CacheLock lock2_1 = cache2.lock(1);
+
+        lock1_1.enableAsync().lock();
 
-        assert cache1.lockAsync(1, 0L).get();
+        assert lock1_1.enableAsync().<Boolean>future().get();
 
         try {
             assert cache1.isLocked(1);
@@ -387,15 +393,17 @@ public abstract class GridCacheMultiNodeLockAbstractTest extends GridCommonAbstr
             assert cache2.isLocked(1);
             assert !cache2.isLockedByThread(1);
 
-            assert !cache2.lockAsync(1, -1L).get();
+            lock2_1.enableAsync().tryLock(-1, TimeUnit.MILLISECONDS);
+
+            assert !lock2_1.enableAsync().<Boolean>future().get();
         }
         finally {
-            cache1.unlockAll(F.asList(1));
+            lock1_1.unlock();
         }
 
         checkUnlocked(cache1, 1);
 
-        assert cache2.lockAsync(1, 0L).get();
+        lock2_1.lock();
 
         CountDownLatch latch = new CountDownLatch(1);
 
@@ -408,10 +416,12 @@ public abstract class GridCacheMultiNodeLockAbstractTest extends GridCommonAbstr
             assert cache2.isLocked(1);
             assert cache2.isLockedByThread(1);
 
-            assert !cache1.lockAsync(1, -1L).get();
+            lock1_1.enableAsync().tryLock(-1, TimeUnit.MILLISECONDS);
+
+            assert !lock1_1.enableAsync().<Boolean>future().get();
         }
         finally {
-            cache2.unlockAll(F.asList(1));
+            lock2_1.unlock();
         }
 
         latch.await();
@@ -502,16 +512,18 @@ public abstract class GridCacheMultiNodeLockAbstractTest extends GridCommonAbstr
      * @throws Exception If test fails.
      */
     public void testMultiNodeLockAsyncWithKeyLists() throws Exception {
-        GridCache<Integer, String> cache1 = ignite1.cache(null);
-        GridCache<Integer, String> cache2 = ignite2.cache(null);
+        IgniteCache<Integer, String> cache1 = ignite1.jcache(null);
+        IgniteCache<Integer, String> cache2 = ignite2.jcache(null);
 
-        Collection<Integer> keys1 = new ArrayList<>();
-        Collection<Integer> keys2 = new ArrayList<>();
+        Collection<Integer> keys1 = Lists.newArrayList(1, 2, 3);
+        Collection<Integer> keys2 = Lists.newArrayList(2, 3, 4);
 
-        Collections.addAll(keys1, 1, 2, 3);
-        Collections.addAll(keys2, 2, 3, 4);
+        CacheLock lock1_1 = cache1.lockAll(keys1);
+        CacheLock lock2_2 = cache2.lockAll(keys2);
+
+        lock1_1.enableAsync().lock();
 
-        IgniteFuture<Boolean> f1 = cache1.lockAllAsync(keys1, 0);
+        IgniteFuture<Boolean> f1 = lock1_1.enableAsync().future();
 
         try {
             assert f1.get();
@@ -520,7 +532,9 @@ public abstract class GridCacheMultiNodeLockAbstractTest extends GridCommonAbstr
 
             checkRemoteLocked(cache2, keys1);
 
-            IgniteFuture<Boolean> f2 = cache2.lockAllAsync(keys2, -1);
+            lock2_2.tryLock(-1, TimeUnit.MILLISECONDS);
+
+            IgniteFuture<Boolean> f2 = lock2_2.future();
 
             assert !f2.get();
 
@@ -532,7 +546,7 @@ public abstract class GridCacheMultiNodeLockAbstractTest extends GridCommonAbstr
             checkRemoteLocked(cache2, keys1);
         }
         finally {
-            cache1.unlockAll(keys1);
+            lock1_1.unlock();
         }
 
         checkUnlocked(cache1, keys1);
@@ -541,7 +555,9 @@ public abstract class GridCacheMultiNodeLockAbstractTest extends GridCommonAbstr
 
         addListener(ignite1, new UnlockListener(latch, keys2));
 
-        IgniteFuture<Boolean> f2 = cache2.lockAllAsync(keys2, 0);
+        lock2_2.enableAsync().lock();
+
+        IgniteFuture<Boolean> f2 = lock2_2.enableAsync().future();
 
         try {
             assert f2.get();
@@ -552,9 +568,7 @@ public abstract class GridCacheMultiNodeLockAbstractTest extends GridCommonAbstr
 
             checkUnlocked(cache1, 1);
 
-            f1 = cache1.lockAllAsync(keys2, -1);
-
-            assert !f1.get();
+            assert !cache1.lockAll(keys2).tryLock();
 
             checkLocked(cache2, keys2);
 
@@ -564,7 +578,7 @@ public abstract class GridCacheMultiNodeLockAbstractTest extends GridCommonAbstr
             checkRemoteLocked(cache1, keys2);
         }
         finally {
-            cache2.unlockAll(keys2);
+            lock2_2.unlock();
         }
 
         latch.await();

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/cbb74d61/modules/core/src/test/java/org/gridgain/grid/kernal/processors/cache/distributed/dht/GridCacheColocatedDebugTest.java
----------------------------------------------------------------------
diff --git a/modules/core/src/test/java/org/gridgain/grid/kernal/processors/cache/distributed/dht/GridCacheColocatedDebugTest.java
b/modules/core/src/test/java/org/gridgain/grid/kernal/processors/cache/distributed/dht/GridCacheColocatedDebugTest.java
index acc565c..1b6209d 100644
--- a/modules/core/src/test/java/org/gridgain/grid/kernal/processors/cache/distributed/dht/GridCacheColocatedDebugTest.java
+++ b/modules/core/src/test/java/org/gridgain/grid/kernal/processors/cache/distributed/dht/GridCacheColocatedDebugTest.java
@@ -372,7 +372,9 @@ public class GridCacheColocatedDebugTest extends GridCommonAbstractTest
{
             IgniteFuture<?> unlockFut = multithreadedAsync(new Runnable() {
                 @Override public void run() {
                     try {
-                        assert g0.cache(null).lock(key, 0);
+                        CacheLock lock = g0.jcache(null).lock(key);
+
+                        lock.lock();
 
                         try {
                             lockLatch.countDown();
@@ -380,7 +382,7 @@ public class GridCacheColocatedDebugTest extends GridCommonAbstractTest
{
                             U.await(unlockLatch);
                         }
                         finally {
-                            g0.cache(null).unlock(key);
+                            lock.unlock();
                         }
                     }
                     catch (IgniteCheckedException e) {
@@ -392,10 +394,14 @@ public class GridCacheColocatedDebugTest extends GridCommonAbstractTest
{
 
             U.await(lockLatch);
 
-            assert g0.cache(null).isLocked(key);
-            assert !g0.cache(null).isLockedByThread(key) : "Key can not be locked by current
thread.";
+            assert g0.jcache(null).isLocked(key);
+            assert !g0.jcache(null).isLockedByThread(key) : "Key can not be locked by current
thread.";
+
+            CacheLock lock = g0.jcache(null).lock(key);
+
+            lock.enableAsync().lock();
 
-            IgniteFuture<Boolean> lockFut = g0.cache(null).lockAsync(key, 0);
+            IgniteFuture<Boolean> lockFut = lock.enableAsync().future();
 
             assert g0.cache(null).isLocked(key);
             assert !lockFut.isDone() : "Key can not be locked by current thread.";

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/cbb74d61/modules/core/src/test/java/org/gridgain/grid/kernal/processors/cache/distributed/near/GridCachePartitionedLockSelfTest.java
----------------------------------------------------------------------
diff --git a/modules/core/src/test/java/org/gridgain/grid/kernal/processors/cache/distributed/near/GridCachePartitionedLockSelfTest.java
b/modules/core/src/test/java/org/gridgain/grid/kernal/processors/cache/distributed/near/GridCachePartitionedLockSelfTest.java
index a0be693..3df071b 100644
--- a/modules/core/src/test/java/org/gridgain/grid/kernal/processors/cache/distributed/near/GridCachePartitionedLockSelfTest.java
+++ b/modules/core/src/test/java/org/gridgain/grid/kernal/processors/cache/distributed/near/GridCachePartitionedLockSelfTest.java
@@ -62,7 +62,7 @@ public class GridCachePartitionedLockSelfTest extends GridCacheLockAbstractTest
     /**
      * @throws IgniteCheckedException If failed.
      */
-    public void testLockAtomicCache() throws IgniteCheckedException {
+    public void testLockAtomicCache() throws Exception {
         IgniteConfiguration cfg = new IgniteConfiguration();
 
         cfg.setGridName(getTestGridName(0));
@@ -85,21 +85,16 @@ public class GridCachePartitionedLockSelfTest extends GridCacheLockAbstractTest
             }
         }, CacheException.class, "Locks are not supported");
 
-        final IgniteFuture<Boolean> lockFut1 = g0.cache(null).lockAsync(1, Long.MAX_VALUE);
+        CacheLock lock = g0.jcache(null).lock(1);
 
-        GridTestUtils.assertThrows(log, new Callable<Object>() {
-            @Override public Object call() throws Exception {
-                return lockFut1.get();
-            }
-        }, IgniteCheckedException.class, "Locks are not supported");
+        lock.enableAsync().tryLock(Long.MAX_VALUE, TimeUnit.MILLISECONDS);
 
-        final IgniteFuture<Boolean> lockFut2 = g0.cache(null).lockAllAsync(Arrays.asList(1),
Long.MAX_VALUE);
+        final IgniteFuture<Boolean> lockFut1 = lock.enableAsync().future();
 
         GridTestUtils.assertThrows(log, new Callable<Object>() {
             @Override public Object call() throws Exception {
-                return lockFut2.get();
+                return lockFut1.get();
             }
         }, IgniteCheckedException.class, "Locks are not supported");
-
     }
 }

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/cbb74d61/modules/core/src/test/java/org/gridgain/grid/kernal/processors/cache/local/GridCacheLocalMultithreadedSelfTest.java
----------------------------------------------------------------------
diff --git a/modules/core/src/test/java/org/gridgain/grid/kernal/processors/cache/local/GridCacheLocalMultithreadedSelfTest.java
b/modules/core/src/test/java/org/gridgain/grid/kernal/processors/cache/local/GridCacheLocalMultithreadedSelfTest.java
index 624c5be..cc79f38 100644
--- a/modules/core/src/test/java/org/gridgain/grid/kernal/processors/cache/local/GridCacheLocalMultithreadedSelfTest.java
+++ b/modules/core/src/test/java/org/gridgain/grid/kernal/processors/cache/local/GridCacheLocalMultithreadedSelfTest.java
@@ -346,6 +346,8 @@ public class GridCacheLocalMultithreadedSelfTest extends GridCommonAbstractTest
      * @throws Exception If test failed.
      */
     public void testLockOrder() throws Exception {
+        final IgniteCache<Object, Object> cache = grid().jcache(null);
+
         final CountDownLatch l1 = new CountDownLatch(1);
         final CountDownLatch l2 = new CountDownLatch(1);
         final CountDownLatch l3 = new CountDownLatch(1);
@@ -353,7 +355,7 @@ public class GridCacheLocalMultithreadedSelfTest extends GridCommonAbstractTest
         Thread t1 = new GridTestThread(new Callable<Object>() {
             /** {@inheritDoc} */
             @Override public Object call() throws Exception {
-                assert cache.lock(1, 0L);
+                cache.lock(1).lock();
 
                 l1.countDown();
 
@@ -362,7 +364,7 @@ public class GridCacheLocalMultithreadedSelfTest extends GridCommonAbstractTest
 
                 l2.await();
 
-                cache.unlock(1);
+                cache.lock(1).unlock();
 
                 l3.countDown();
 
@@ -378,7 +380,9 @@ public class GridCacheLocalMultithreadedSelfTest extends GridCommonAbstractTest
                 try {
                     l1.await();
 
-                    IgniteFuture<Boolean> f1 = cache.lockAsync(1, 0L);
+                    CacheLock lock1 = cache.enableAsync().lock(1);
+
+                    IgniteFuture<Boolean> f1 = cache.enableAsync().future();
 
                     try {
                         f1.get(100, TimeUnit.MILLISECONDS);
@@ -389,7 +393,11 @@ public class GridCacheLocalMultithreadedSelfTest extends GridCommonAbstractTest
                         info("Correctly received timeout exception: " + e);
                     }
 
-                    IgniteFuture<Boolean> f2 = cache.lockAsync(2, 0L);
+                    CacheLock lock2 = cache.lock(2);
+
+                    lock2.lock();
+
+                    IgniteFuture<Boolean> f2 = lock2.future();
 
                     try {
                         // Can't acquire f2 because f1 is held.
@@ -402,8 +410,8 @@ public class GridCacheLocalMultithreadedSelfTest extends GridCommonAbstractTest
                         info("Correctly received timeout exception: " + e);
                     }
 
-                    assert cache.isLocked(1);
-                    assert !cache.isLockedByThread(1);
+                    assert lock1.isLocked();
+                    assert !lock1.isLockedByThread();
 
                     // TODO uncomment after GG-3756 fix
                     //assert cache.isLocked(2);
@@ -423,8 +431,8 @@ public class GridCacheLocalMultithreadedSelfTest extends GridCommonAbstractTest
                     assert cache.isLocked(2);
                     assert cache.isLockedByThread(2);
 
-                    cache.unlock(1);
-                    cache.unlock(2);
+                    lock1.unlock();
+                    lock2.unlock();
 
                     assert !cache.isLocked(1);
                     assert !cache.isLockedByThread(1);


Mime
View raw message