Java Transaction.close方法代码示例

import org.apache.ignite.transactions.Transaction; //导入方法依赖的package包/类
/**
 * @param key Key.
 * @param txMode Non null tx mode if explicit transaction should be started.
 * @throws Exception If failed.
 */
private void checkVersion(String key, @Nullable TransactionConcurrency txMode) throws Exception {
    IgniteCache<String, Integer> cache = jcache(0);

    Transaction tx = null;

    if (txMode != null)
        tx = cache.unwrap(Ignite.class).transactions().txStart(txMode, REPEATABLE_READ);

    try {
        cache.put(key, 1);

        if (tx != null)
            tx.commit();
    }
    finally {
        if (tx != null)
            tx.close();
    }

    checkEntryVersion(key);
}
 

import org.apache.ignite.transactions.Transaction; //导入方法依赖的package包/类
/**
 * @param cache Cache.
 * @param key Key.
 * @param concurrency Transaction concurrency.
 * @param isolation Transaction isolation.
 * @throws Exception If failed.
 */
private void checkReadThrough(IgniteCache<Object, Object> cache,
    Object key,
    @Nullable TransactionConcurrency concurrency,
    @Nullable TransactionIsolation isolation) throws Exception {
    putDataInStore(Collections.singletonMap(key, key), cache.getName());

    Transaction tx = isolation != null ? cache.unwrap(Ignite.class).transactions().txStart(concurrency, isolation)
        : null;

    try {
        Object ret = cache.invoke(key, new TestEntryProcessor());

        assertEquals(key, ret);

        if (tx != null)
            tx.commit();
    }
    finally {
        if (tx != null)
            tx.close();
    }

    checkValue(cache.getName(), key, (Integer)key + 1);
}
 

import org.apache.ignite.transactions.Transaction; //导入方法依赖的package包/类
/**
 * @param cache Cache.
 * @param c Cache operation Closure.
 * @param concurrency Transaction concurrency.
 * @param isolation Transaction isolation.
 * @param expLoadCnt Expected number of store 'load' calls.
 * @throws Exception If failed.
 */
private void checkReadThrough(IgniteCache<Object, Object> cache,
    IgniteRunnable c,
    @Nullable TransactionConcurrency concurrency,
    @Nullable TransactionIsolation isolation,
    int expLoadCnt) throws Exception {
    TestStore.loadCnt.set(0);

    Transaction tx = isolation != null ? cache.unwrap(Ignite.class).transactions().txStart(concurrency, isolation)
        : null;

    try {
        c.run();

        if (tx != null)
            tx.commit();
    }
    finally {
        if (tx != null)
            tx.close();
    }

    assertEquals(expLoadCnt, TestStore.loadCnt.get());
}
 

import org.apache.ignite.transactions.Transaction; //导入方法依赖的package包/类
/**
 * Test for suspension on pessimistic transaction.
 *
 * @throws Exception If failed.
 */
public void testSuspendPessimisticTx() throws Exception {
    try (Ignite g = startGrid()) {
        IgniteCache<Integer, String> cache = jcache();

        IgniteTransactions txs = g.transactions();

        for (TransactionIsolation isolation : TransactionIsolation.values()) {
            final Transaction tx = txs.txStart(TransactionConcurrency.PESSIMISTIC, isolation);

            cache.put(1, "1");

            GridTestUtils.assertThrowsWithCause(new Callable<Object>() {
                @Override public Object call() throws Exception {
                    tx.suspend();

                    return null;
                }
            }, UnsupportedOperationException.class);

            tx.close();

            assertNull(cache.get(1));
        }
    }
}
 

import org.apache.ignite.transactions.Transaction; //导入方法依赖的package包/类
/**
 * @param concurrency Concurrency.
 * @throws Exception If failed.
 */
private void checkTransformAfterRemove(TransactionConcurrency concurrency) throws Exception {
    IgniteCache<String, Integer> cache = jcache();

    cache.put("key", 4);

    Transaction tx = txShouldBeUsed() ? ignite(0).transactions().txStart(concurrency, READ_COMMITTED) : null;

    try {
        cache.remove("key");

        cache.invoke("key", INCR_PROCESSOR);
        cache.invoke("key", INCR_PROCESSOR);
        cache.invoke("key", INCR_PROCESSOR);

        if (tx != null)
            tx.commit();
    }
    finally {
        if (tx != null)
            tx.close();
    }

    assertEquals((Integer)3, cache.get("key"));
}
 

import org.apache.ignite.transactions.Transaction; //导入方法依赖的package包/类
/**
 * @param id Transaction ID.
 * @return Transaction state.
 */
private int txClose(long id) {
    Transaction tx = tx(id);

    try {
        tx.close();

        return tx.state().ordinal();
    }
    finally {
        unregisterTx(id);
    }
}
 

import org.apache.ignite.transactions.Transaction; //导入方法依赖的package包/类
/**
 * @param concurrency Concurrency.
 * @throws Exception If failed.
 */
private void checkInvokeAfterRemove(TransactionConcurrency concurrency) throws Exception {
    IgniteCache<Object, Object> cache = jcache();

    Object key = key(1);

    cache.put(key, value(4));

    Transaction tx = txShouldBeUsed() ? ignite(0).transactions().txStart(concurrency, READ_COMMITTED) : null;

    try {
        cache.remove(key);

        cache.invoke(key, INCR_PROCESSOR, dataMode);
        cache.invoke(key, INCR_PROCESSOR, dataMode);
        cache.invoke(key, INCR_PROCESSOR, dataMode);

        if (tx != null)
            tx.commit();
    }
    finally {
        if (tx != null)
            tx.close();
    }

    assertEquals(value(3), cache.get(key));
}
 

import org.apache.ignite.transactions.Transaction; //导入方法依赖的package包/类
/**
 * @param put Whether to put value.
 * @param concurrency Concurrency.
 * @param isolation Isolation.
 * @throws Exception If failed.
 */
private void checkInvokeReturnValue(boolean put,
    TransactionConcurrency concurrency,
    TransactionIsolation isolation)
    throws Exception {
    IgniteCache<Object, Object> cache = jcache();

    Object key = key(1);
    Object val1 = value(1);
    Object val2 = value(2);

    if (!put)
        cache.put(key, val1);

    Transaction tx = txShouldBeUsed() ? ignite(0).transactions().txStart(concurrency, isolation) : null;

    try {
        if (put)
            cache.put(key, val1);

        cache.invoke(key, INCR_PROCESSOR, dataMode);

        assertEquals(val2, cache.get(key));

        if (tx != null) {
            // Second get inside tx. Make sure read value is not transformed twice.
            assertEquals(val2, cache.get(key));

            tx.commit();
        }
    }
    finally {
        if (tx != null)
            tx.close();
    }
}
 

import org.apache.ignite.transactions.Transaction; //导入方法依赖的package包/类
/**
 * Tests sequential value write and read inside transaction.
 * @param concurrency Transaction concurrency.
 * @param isolation Transaction isolation.
 * @throws IgniteCheckedException If failed
 */
protected void checkTransactionalRead(TransactionConcurrency concurrency, TransactionIsolation isolation)
    throws IgniteCheckedException {
    IgniteCache<String, Integer> cache = jcache(0);

    cache.clear();

    Transaction tx = grid(0).transactions().txStart(concurrency, isolation);

    try {
        cache.put("key", 1);

        assertEquals("Invalid value after put", 1, cache.get("key").intValue());

        tx.commit();
    }
    finally {
        tx.close();
    }

    assertEquals("Invalid cache size after put", 1, cache.size());

    try {
        tx = grid(0).transactions().txStart(concurrency, isolation);

        assertEquals("Invalid value inside transactional read", Integer.valueOf(1), cache.get("key"));

        tx.commit();
    }
    finally {
        tx.close();
    }
}
 

import org.apache.ignite.transactions.Transaction; //导入方法依赖的package包/类
/**
 * @param put Whether to put value.
 * @param concurrency Concurrency.
 * @param isolation Isolation.
 * @throws Exception If failed.
 */
private void checkTransformReturnValue(boolean put,
    TransactionConcurrency concurrency,
    TransactionIsolation isolation)
    throws Exception {
    IgniteCache<String, Integer> cache = jcache();

    if (!put)
        cache.put("key", 1);

    Transaction tx = txShouldBeUsed() ? ignite(0).transactions().txStart(concurrency, isolation) : null;

    try {
        if (put)
            cache.put("key", 1);

        cache.invoke("key", INCR_PROCESSOR);

        assertEquals((Integer)2, cache.get("key"));

        if (tx != null) {
            // Second get inside tx. Make sure read value is not transformed twice.
            assertEquals((Integer)2, cache.get("key"));

            tx.commit();
        }
    }
    finally {
        if (tx != null)
            tx.close();
    }
}
 

import org.apache.ignite.transactions.Transaction; //导入方法依赖的package包/类
/**
 * @param explicitTx Whether or not start implicit tx.
 * @param concurrency Tx concurrency.
 * @param isolation Tx isolation.
 * @throws Exception If failed.
 */
private void checkSinglePut(boolean explicitTx, TransactionConcurrency concurrency, TransactionIsolation isolation)
    throws Exception {
    startGrid();

    try {
        Transaction tx = explicitTx ? grid().transactions().txStart(concurrency, isolation) : null;

        try {
            IgniteCache<Object, Object> cache = jcache();

            cache.putAll(F.asMap(1, "Hello", 2, "World"));

            if (tx != null)
                tx.commit();

            System.out.println(cache.localMetrics());

            assertEquals("Hello", cache.get(1));
            assertEquals("World", cache.get(2));
            assertNull(cache.get(3));
        }
        finally {
            if (tx != null)
                tx.close();
        }
    }
    finally {
        stopAllGrids();
    }
}
 

import org.apache.ignite.transactions.Transaction; //导入方法依赖的package包/类
/**
 * @param concurrency Concurrency.
 * @param isolation Isolation.
 * @throws Exception If failed.
 */
private void checkIgniteTransform(TransactionConcurrency concurrency, TransactionIsolation isolation)
    throws Exception {
    IgniteCache<String, Integer> cache = jcache();

    cache.put("key2", 1);
    cache.put("key3", 3);

    Transaction tx = txShouldBeUsed() ? ignite(0).transactions().txStart(concurrency, isolation) : null;

    try {
        assertEquals("null", cache.invoke("key1", INCR_IGNITE_PROCESSOR));
        assertEquals("1", cache.invoke("key2", INCR_IGNITE_PROCESSOR));
        assertEquals("3", cache.invoke("key3", RMV_IGNITE_PROCESSOR));

        if (tx != null)
            tx.commit();
    }
    catch (Exception e) {
        e.printStackTrace();

        throw e;
    }
    finally {
        if (tx != null)
            tx.close();
    }

    assertEquals((Integer)1, cache.get("key1"));
    assertEquals((Integer)2, cache.get("key2"));
    assertNull(cache.get("key3"));

    for (int i = 0; i < gridCount(); i++)
        assertNull("Failed for cache: " + i, jcache(i).localPeek("key3", ONHEAP));

    cache.remove("key1");
    cache.put("key2", 1);
    cache.put("key3", 3);

    assertEquals("null", cache.invoke("key1", INCR_IGNITE_PROCESSOR));
    assertEquals("1", cache.invoke("key2", INCR_IGNITE_PROCESSOR));
    assertEquals("3", cache.invoke("key3", RMV_IGNITE_PROCESSOR));

    assertEquals((Integer)1, cache.get("key1"));
    assertEquals((Integer)2, cache.get("key2"));
    assertNull(cache.get("key3"));

    for (int i = 0; i < gridCount(); i++)
        assertNull(jcache(i).localPeek("key3", ONHEAP));
}
 

import org.apache.ignite.transactions.Transaction; //导入方法依赖的package包/类
/**
 * @param concurrency Transaction concurrency.
 * @param isolation Transaction isolation.
 * @param incrProcessor Increment processor.
 * @param rmvProseccor Remove processor.
 */
private void checkInvoke(TransactionConcurrency concurrency, TransactionIsolation isolation,
    EntryProcessor<Object, Object, Object> incrProcessor,
    EntryProcessor<Object, Object, Object> rmvProseccor) {
    IgniteCache cache = jcache();

    final Object key1 = key(1);
    final Object key2 = key(2);
    final Object key3 = key(3);

    final Object val1 = value(1);
    final Object val2 = value(2);
    final Object val3 = value(3);

    cache.put(key2, val1);
    cache.put(key3, val3);

    Transaction tx = txShouldBeUsed() ? ignite(0).transactions().txStart(concurrency, isolation) : null;

    try {
        assertNull(cache.invoke(key1, incrProcessor, dataMode));
        assertEquals(val1, cache.invoke(key2, incrProcessor, dataMode));
        assertEquals(val3, cache.invoke(key3, rmvProseccor));

        if (tx != null)
            tx.commit();
    }
    catch (Exception e) {
        e.printStackTrace();

        throw e;
    }
    finally {
        if (tx != null)
            tx.close();
    }

    assertEquals(val1, cache.get(key1));
    assertEquals(val2, cache.get(key2));
    assertNull(cache.get(key3));

    for (int i = 0; i < gridCount(); i++)
        assertNull("Failed for cache: " + i, jcache(i).localPeek(key3, ONHEAP));

    cache.remove(key1);
    cache.put(key2, val1);
    cache.put(key3, val3);

    assertNull(cache.invoke(key1, incrProcessor, dataMode));
    assertEquals(val1, cache.invoke(key2, incrProcessor, dataMode));
    assertEquals(val3, cache.invoke(key3, rmvProseccor));

    assertEquals(val1, cache.get(key1));
    assertEquals(val2, cache.get(key2));
    assertNull(cache.get(key3));

    for (int i = 0; i < gridCount(); i++)
        assertNull(jcache(i).localPeek(key3, ONHEAP));
}
 

import org.apache.ignite.transactions.Transaction; //导入方法依赖的package包/类
/**
 * @param startVal Whether to put value.
 * @param concurrency Concurrency.
 * @throws Exception If failed.
 */
private void checkInvokeSequential0(boolean startVal, TransactionConcurrency concurrency)
    throws Exception {
    final Object val1 = value(1);
    final Object val2 = value(2);
    final Object val3 = value(3);

    IgniteCache<Object, Object> cache = jcache();

    final Object key = primaryTestObjectKeysForCache(cache, 1).get(0);

    Transaction tx = txShouldBeUsed() ? ignite(0).transactions().txStart(concurrency, READ_COMMITTED) : null;

    try {
        if (startVal)
            cache.put(key, val2);
        else
            assertEquals(null, cache.get(key));

        Object expRes = startVal ? val2 : null;

        assertEquals(expRes, cache.invoke(key, INCR_PROCESSOR, dataMode));

        expRes = startVal ? val3 : val1;

        assertEquals(expRes, cache.invoke(key, INCR_PROCESSOR, dataMode));

        expRes = value(valueOf(expRes) + 1);

        assertEquals(expRes, cache.invoke(key, INCR_PROCESSOR, dataMode));

        if (tx != null)
            tx.commit();
    }
    finally {
        if (tx != null)
            tx.close();
    }

    Object exp = value((startVal ? 2 : 0) + 3);

    assertEquals(exp, cache.get(key));

    for (int i = 0; i < gridCount(); i++) {
        if (ignite(i).affinity(cacheName()).isPrimaryOrBackup(grid(i).localNode(), key))
            assertEquals(exp, jcache(i).localPeek(key));
    }
}
 

import org.apache.ignite.transactions.Transaction; //导入方法依赖的package包/类
/**
 * @throws Exception If failed.
 */
public void testGetAndPutIfAbsentAsyncOld() throws Exception {
    Transaction tx = txShouldBeUsed() ? transactions().txStart() : null;

    IgniteCache<String, Integer> cache = jcache();

    IgniteCache<String, Integer> cacheAsync = cache.withAsync();

    try {
        cacheAsync.getAndPutIfAbsent("key", 1);

        IgniteFuture<Integer> fut1 = cacheAsync.future();

        assertNull(fut1.get());
        assertEquals((Integer)1, cache.get("key"));

        cacheAsync.getAndPutIfAbsent("key", 2);

        IgniteFuture<Integer> fut2 = cacheAsync.future();

        assertEquals((Integer)1, fut2.get());
        assertEquals((Integer)1, cache.get("key"));

        if (tx != null)
            tx.commit();
    }
    finally {
        if (tx != null)
            tx.close();
    }

    if (!storeEnabled())
        return;

    // Check swap.
    cache.put("key2", 1);

    cache.localEvict(Collections.singleton("key2"));

    if (!isLoadPreviousValue())
        cache.get("key2");

    cacheAsync.getAndPutIfAbsent("key2", 3);

    assertEquals((Integer)1, cacheAsync.<Integer>future().get());

    // Check db.
    if (storeEnabled() && isLoadPreviousValue() && !isMultiJvm()) {
        putToStore("key3", 3);

        cacheAsync.getAndPutIfAbsent("key3", 4);

        assertEquals((Integer)3, cacheAsync.<Integer>future().get());
    }

    cache.localEvict(Collections.singleton("key2"));

    if (!isLoadPreviousValue())
        cache.get("key2");

    // Same checks inside tx.
    tx = txShouldBeUsed() ? transactions().txStart() : null;

    try {
        cacheAsync.getAndPutIfAbsent("key2", 3);

        assertEquals(1, cacheAsync.future().get());

        if (tx != null)
            tx.commit();

        assertEquals((Integer)1, cache.get("key2"));
    }
    finally {
        if (tx != null)
            tx.close();
    }
}