private Lock getUniquenessLock(final TitanVertex start, final TitanType type, final Object end) { if (config.isSingleThreaded()) return FakeLock.INSTANCE; if (uniqueLocks == UNINITIALIZED_LOCKS) { Preconditions.checkArgument(!config.isSingleThreaded()); synchronized (this) { if (uniqueLocks == UNINITIALIZED_LOCKS) uniqueLocks = new ConcurrentHashMap<UniqueLockApplication, Lock>(); } } UniqueLockApplication la = new UniqueLockApplication(start, type, end); Lock lock = new ReentrantLock(); Lock existingLock = uniqueLocks.putIfAbsent(la, lock); if (existingLock == null) return lock; else return existingLock; }
public void removeRelation(InternalRelation relation) { Preconditions.checkArgument(!relation.isRemoved()); relation = relation.it(); // Delete from Vertex for (int i = 0; i < relation.getLen(); i++) { relation.getVertex(i).removeRelation(relation); } // Update transaction data structures if (relation.isNew()) { addedRelations.remove(relation); if (isVertexIndexProperty(relation)) newVertexIndexEntries.remove((TitanProperty) relation); } else { Preconditions.checkArgument(relation.isLoaded()); if (deletedRelations == EMPTY_DELETED_RELATIONS) { if (config.isSingleThreaded()) { deletedRelations = new HashMap<Long, InternalRelation>(); } else { synchronized (this) { if (deletedRelations == EMPTY_DELETED_RELATIONS) deletedRelations = new ConcurrentHashMap<Long, InternalRelation>(); } } } deletedRelations.put(Long.valueOf(relation.getID()), relation); } }
public StandardTitanTx( StandardTitanGraph graph, TransactionConfig config, BackendTransaction txHandle) { Preconditions.checkNotNull(graph); Preconditions.checkArgument(graph.isOpen()); Preconditions.checkNotNull(config); Preconditions.checkNotNull(txHandle); this.graph = graph; this.config = config; this.idInspector = graph.getIDInspector(); this.txHandle = txHandle; temporaryID = new AtomicLong(-1); Cache<StandardElementQuery, List<Object>> indexCacheBuilder = CacheBuilder.newBuilder() .weigher( new Weigher<StandardElementQuery, List<Object>>() { @Override public int weigh(StandardElementQuery q, List<Object> r) { return 2 + r.size(); } }) .maximumWeight(DEFAULT_CACHE_SIZE) .build(); int concurrencyLevel; if (config.isSingleThreaded()) { vertexCache = new SimpleVertexCache(); addedRelations = new SimpleBufferAddedRelations(); concurrencyLevel = 1; typeCache = new HashMap<String, TitanType>(); newVertexIndexEntries = new SimpleIndexCache(); } else { vertexCache = new ConcurrentVertexCache(); addedRelations = new ConcurrentBufferAddedRelations(); concurrencyLevel = 4; typeCache = new ConcurrentHashMap<String, TitanType>(); newVertexIndexEntries = new ConcurrentIndexCache(); } for (SystemType st : SystemKey.values()) typeCache.put(st.getName(), st); indexCache = CacheBuilder.newBuilder() .weigher( new Weigher<StandardElementQuery, List<Object>>() { @Override public int weigh(StandardElementQuery q, List<Object> r) { return 2 + r.size(); } }) .concurrencyLevel(concurrencyLevel) .maximumWeight(DEFAULT_CACHE_SIZE) .build(); uniqueLocks = UNINITIALIZED_LOCKS; deletedRelations = EMPTY_DELETED_RELATIONS; this.isOpen = true; }