//JAVA TO C# CONVERTER WARNING: 'final' parameters are ignored unless the option to convert to C# 7.2 'in' parameters is selected: //ORIGINAL LINE: public void generateEvent(final org.neo4j.graphdb.event.ErrorState error, final Throwable cause) public virtual void GenerateEvent(ErrorState error, Exception cause) { ExecutorService executor = Executors.newSingleThreadExecutor(); executor.execute(() => _kernelEventHandlers.kernelPanic(error, cause)); executor.shutdown(); }
/// <seealso cref= InvokeFuture#tryAsyncExecuteInvokeCallbackAbnormally() </seealso> public virtual void tryAsyncExecuteInvokeCallbackAbnormally() { try { Protocol protocol = ProtocolManager.getProtocol(Remoting.ProtocolCode.fromBytes(this.protocol)); if (null != protocol) { CommandHandler commandHandler = protocol.CommandHandler; if (null != commandHandler) { ExecutorService executor = commandHandler.DefaultExecutor; if (null != executor) { executor.execute(new TempRunnable(this)); } } else { logger.LogError("Executor null in commandHandler of protocolCode [{}].", this.protocol); } } else { logger.LogError("protocolCode [{}] not registered!", this.protocol); } } catch (System.Exception e) { logger.LogError("Exception caught when executing invoke callback abnormally.", e); } }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET: //ORIGINAL LINE: private void runSetup(java.util.concurrent.ExecutorService executorService) throws InterruptedException private void runSetup(ExecutorService executorService) { System.Threading.CountdownEvent sync = new System.Threading.CountdownEvent(configuration.SetupTasks.Length); Console.Write("Running setup ... "); foreach (ThreadStart r in configuration.SetupTasks) { executorService.execute(wrap(r, sync)); } sync.await(); if (configuration.Color) { Console.Write(ANSI_GREEN); } Console.WriteLine("Done"); if (configuration.Color) { Console.Write(ANSI_RESET); } }
/// <summary> /// Executes an audio track with the given player and volume. </summary> /// <param name="listener"> A listener for track state events </param> /// <param name="track"> The audio track to execute </param> /// <param name="configuration"> The audio configuration to use for executing </param> /// <param name="volumeLevel"> The mutable volume level to use </param> //JAVA TO C# CONVERTER WARNING: 'final' parameters are not available in .NET: //ORIGINAL LINE: public void executeTrack(final TrackStateListener listener, InternalAudioTrack track, AudioConfiguration configuration, AtomicInteger volumeLevel) public virtual void executeTrack(TrackStateListener listener, InternalAudioTrack track, AudioConfiguration configuration, AtomicInteger volumeLevel) { //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final AudioTrackExecutor executor = createExecutorForTrack(track, configuration, volumeLevel); AudioTrackExecutor executor = createExecutorForTrack(track, configuration, volumeLevel); track.assignExecutor(executor, true); trackPlaybackExecutorService.execute(() => executor.execute(listener)); }
/// <summary> /// Process event. /// </summary> /// <param name="runnable"> Runnable </param> public virtual void onEvent(Runnable runnable) { try { executor.execute(runnable); } catch (java.lang.Exception t) { logger.LogError("Exception caught when execute connection event!", t); } }
public override void Execute(ThreadStart command) { if (_executor != null) { _executor.execute(command); } else { command.run(); } }
/// <summary> /// Process the remoting command with its own executor or with the defaultExecutor if its own if null. /// </summary> /// <param name="ctx"> RemotingContext </param> /// <param name="msg"> T </param> /// <param name="defaultExecutor"> ExecutorService, default executor </param> public virtual void process(RemotingContext ctx, RemotingCommand msg, ExecutorService defaultExecutor) { ProcessTask task = new ProcessTask(this, ctx, msg); if (Executor != null) { Executor.execute(task); } else { defaultExecutor.execute(task); } }
public int computeItemSimilarities(int degreeOfParallelism, int maxDurationInHours, SimilarItemsWriter writer) { ExecutorService executorService = Executors.newFixedThreadPool(degreeOfParallelism + 1); Output output = null; try { writer.open(); DataModel dataModel = getRecommender().getDataModel(); BlockingQueue<long[]> itemsIDsInBatches = queueItemIDsInBatches(dataModel, batchSize); BlockingQueue<List<SimilarItems>> results = new LinkedBlockingQueue<List<SimilarItems>>(); AtomicInteger numActiveWorkers = new AtomicInteger(degreeOfParallelism); for (int n = 0; n < degreeOfParallelism; n++) { executorService.execute(new SimilarItemsWorker(n, itemsIDsInBatches, results, numActiveWorkers)); } output = new Output(results, writer, numActiveWorkers); executorService.execute(output); } catch (Exception e) { throw new IOException(e); } finally { executorService.shutdown(); try { bool succeeded = executorService.awaitTermination(maxDurationInHours, TimeUnit.HOURS); if (!succeeded) { throw new RuntimeException("Unable to complete the computation in " + maxDurationInHours + " hours!"); } } catch (InterruptedException e) { throw new RuntimeException(e); } Closeables.close(writer, false); } return output.getNumSimilaritiesProcessed(); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void restartWhileDoingTransactions() throws Exception //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: public virtual void RestartWhileDoingTransactions() { // given //JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET: //ORIGINAL LINE: org.neo4j.causalclustering.discovery.Cluster<?> cluster = clusterRule.startCluster(); Cluster <object> cluster = ClusterRule.startCluster(); // when //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final org.neo4j.graphdb.GraphDatabaseService coreDB = cluster.getCoreMemberById(0).database(); GraphDatabaseService coreDB = cluster.GetCoreMemberById(0).database(); ExecutorService executor = Executors.newCachedThreadPool(); //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final java.util.concurrent.atomic.AtomicBoolean done = new java.util.concurrent.atomic.AtomicBoolean(false); AtomicBoolean done = new AtomicBoolean(false); executor.execute(() => { while (!done.get()) { try { using (Transaction tx = coreDB.BeginTx()) { Node node = coreDB.CreateNode(label("boo")); node.setProperty("foobar", "baz_bat"); tx.success(); } } catch (Exception e) when(e is AcquireLockTimeoutException || e is WriteOperationsNotAllowedException) { // expected sometimes } } }); Thread.Sleep(500); cluster.RemoveCoreMemberWithServerId(1); cluster.AddCoreMemberWithId(1).start(); Thread.Sleep(500); // then done.set(true); executor.shutdown(); }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET: //ORIGINAL LINE: private void runWorkers(java.util.concurrent.ExecutorService executorService) throws InterruptedException private void runWorkers(ExecutorService executorService) { //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final int numberOfIterations = configuration.getNumberOfIterations(); int numberOfIterations = configuration.NumberOfIterations; //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final int taskCount = numberOfIterations * configuration.getWorkerTasks().length; int taskCount = numberOfIterations * configuration.WorkerTasks.Length; //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final java.util.concurrent.CountDownLatch sync = new java.util.concurrent.CountDownLatch(taskCount); System.Threading.CountdownEvent sync = new System.Threading.CountdownEvent(taskCount); //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final java.util.Timer timer = new java.util.Timer(); Timer timer = new Timer(); timer.scheduleAtFixedRate(new ProgressReporter(taskCount, sync, configuration.Color), 2000, 2000); Console.WriteLine("Generating load. Total tasks: " + taskCount + "... "); for (int i = 1; i <= numberOfIterations; i++) { foreach (ThreadStart runnable in configuration.WorkerTasks) { executorService.execute(wrap(runnable, sync)); } } sync.await(); timer.cancel(); if (configuration.Color) { Console.Write(CLEAR_LINE + ANSI_GREEN); } Console.WriteLine("Finished generating load."); if (configuration.Color) { Console.Write(ANSI_RESET); } executorService.shutdown(); }
/* * In case if writer thread can't grab write lock now, it should be added to * into a waiting list, wait till resource will be free and grab it. */ //JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test(timeout = TEST_TIMEOUT_MILLIS) public void testWaitingWriterLock() throws InterruptedException //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: public virtual void TestWaitingWriterLock() { RagManager ragManager = new RagManager(); LockResource resource = new LockResource(ResourceTypes.NODE, 1L); //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final RWLock lock = createRWLock(ragManager, resource); RWLock @lock = CreateRWLock(ragManager, resource); //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final LockTransaction lockTransaction = new LockTransaction(); LockTransaction lockTransaction = new LockTransaction(); //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final LockTransaction anotherTransaction = new LockTransaction(); LockTransaction anotherTransaction = new LockTransaction(); @lock.Mark(); @lock.AcquireReadLock(LockTracer.NONE, lockTransaction); @lock.Mark(); @lock.AcquireReadLock(LockTracer.NONE, anotherTransaction); //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final java.util.concurrent.CountDownLatch writerCompletedLatch = new java.util.concurrent.CountDownLatch(1); System.Threading.CountdownEvent writerCompletedLatch = new System.Threading.CountdownEvent(1); ThreadStart writer = CreateWriter(@lock, lockTransaction, writerCompletedLatch); // start writer that will be placed in a wait list _executor.execute(writer); // wait till writer will be added into a list of waiters WaitWaitingThreads(@lock, 1); assertEquals("No writers for now.", 0, @lock.WriteCount); assertEquals(2, @lock.ReadCount); // releasing read locks that will allow writer to grab the lock @lock.ReleaseReadLock(lockTransaction); @lock.ReleaseReadLock(anotherTransaction); // wait till writer will have write lock writerCompletedLatch.await(); assertEquals(1, @lock.WriteCount); assertEquals(0, @lock.ReadCount); // now releasing write lock @lock.ReleaseWriteLock(lockTransaction); assertEquals("Lock should not have any writers left.", 0, @lock.WriteCount); assertEquals("No waiting threads left.", 0, @lock.WaitingThreadsCount); assertEquals("No lock elements left.", 0, @lock.TxLockElementCount); }
public virtual void TestConcurrentHashMap() { // don't make threadCount and keyCount random, otherwise easily OOMs or fails otherwise: const int threadCount = 8, keyCount = 1024; ExecutorService exec = Executors.newFixedThreadPool(threadCount, new NamedThreadFactory("testConcurrentHashMap")); WeakIdentityMap <object, int?> map = WeakIdentityMap <object, int?> .NewConcurrentHashMap(Random().NextBoolean()); // we keep strong references to the keys, // so WeakIdentityMap will not forget about them: AtomicReferenceArray <object> keys = new AtomicReferenceArray <object>(keyCount); for (int j = 0; j < keyCount; j++) { keys.Set(j, new object()); } try { for (int t = 0; t < threadCount; t++) { Random rnd = new Random(Random().Next()); exec.execute(new RunnableAnonymousInnerClassHelper(this, keyCount, map, keys, rnd)); } } finally { exec.shutdown(); while (!exec.awaitTermination(1000L, TimeUnit.MILLISECONDS)) { ; } } // clear strong refs for (int j = 0; j < keyCount; j++) { keys.Set(j, null); } // check that GC does not cause problems in reap() method: int size = map.Size(); for (int i = 0; size > 0 && i < 10; i++) { try { System.runFinalization(); System.gc(); int newSize = map.Size(); Assert.IsTrue(size >= newSize, "previousSize(" + size + ")>=newSize(" + newSize + ")"); size = newSize; Thread.Sleep(new TimeSpan(100L)); int c = 0; for (IEnumerator <object> it = map.Keys.GetEnumerator(); it.MoveNext();) { Assert.IsNotNull(it.Current); c++; } newSize = map.Size(); Assert.IsTrue(size >= c, "previousSize(" + size + ")>=iteratorSize(" + c + ")"); Assert.IsTrue(c >= newSize, "iteratorSize(" + c + ")>=newSize(" + newSize + ")"); size = newSize; } catch (ThreadInterruptedException ie) { } } }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: //ORIGINAL LINE: private void shouldShutdownEvenThoughWaitingForLock0(org.neo4j.causalclustering.discovery.Cluster<?> cluster, int victimId, java.util.Collection<int> shutdownOrder) throws Exception private void ShouldShutdownEvenThoughWaitingForLock0 <T1>(Cluster <T1> cluster, int victimId, ICollection <int> shutdownOrder) { const int longTime = 60_000; const int numberOfLockAcquirers = 2; //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final java.util.concurrent.ExecutorService txExecutor = java.util.concurrent.Executors.newCachedThreadPool(); ExecutorService txExecutor = Executors.newCachedThreadPool(); // Blocking transactions are executed in // parallel, not on the main thread. //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final java.util.concurrent.ExecutorService shutdownExecutor = java.util.concurrent.Executors.newFixedThreadPool(1); ExecutorService shutdownExecutor = Executors.newFixedThreadPool(1); // Shutdowns are executed // serially, not on the main thread. //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final java.util.concurrent.CountDownLatch acquiredLocksCountdown = new java.util.concurrent.CountDownLatch(NUMBER_OF_LOCK_ACQUIRERS); System.Threading.CountdownEvent acquiredLocksCountdown = new System.Threading.CountdownEvent(numberOfLockAcquirers); //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final java.util.concurrent.CountDownLatch locksHolder = new java.util.concurrent.CountDownLatch(1); System.Threading.CountdownEvent locksHolder = new System.Threading.CountdownEvent(1); //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final java.util.concurrent.atomic.AtomicReference<org.neo4j.graphdb.Node> node = new java.util.concurrent.atomic.AtomicReference<>(); AtomicReference <Node> node = new AtomicReference <Node>(); CompletableFuture <Void> preShutdown = new CompletableFuture <Void>(); // set shutdown order CompletableFuture <Void> afterShutdown = preShutdown; foreach (int?id in shutdownOrder) { afterShutdown = afterShutdown.thenRunAsync(() => cluster.GetCoreMemberById(id.Value).shutdown(), shutdownExecutor); } CreateANode(node); try { // when - blocking on lock acquiring //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final org.neo4j.graphdb.GraphDatabaseService leader = cluster.getCoreMemberById(victimId).database(); GraphDatabaseService leader = cluster.GetCoreMemberById(victimId).database(); for (int i = 0; i < numberOfLockAcquirers; i++) { txExecutor.execute(() => { try { using (Transaction tx = leader.BeginTx()) { acquiredLocksCountdown.Signal(); tx.acquireWriteLock(node.get()); locksHolder.await(); tx.success(); } } catch (Exception) { /* Since we are shutting down, a plethora of possible exceptions are expected. */ } }); } // await locks if (!acquiredLocksCountdown.await(longTime, MILLISECONDS)) { throw new System.InvalidOperationException("Failed to acquire locks"); } // then shutdown in given order works preShutdown.complete(null); afterShutdown.get(longTime, MILLISECONDS); } finally { afterShutdown.cancel(true); locksHolder.Signal(); txExecutor.shutdownNow(); shutdownExecutor.shutdownNow(); } }