/// <summary>Constructor.</summary> /// <param name="numThreads"> /// -- if less than or equal to 0, then automatically determine the number /// of threads. Otherwise, the size of the underlying threadpool. /// </param> /// <param name="processor"/> /// <param name="orderResults"> /// -- If true, return results in the order submitted. Otherwise, return results /// as they become available. /// </param> public MulticoreWrapper(int numThreads, IThreadsafeProcessor <I, O> processor, bool orderResults) { // Which id was the last id returned. Only meaningful in the case // of a queue where output order matters. // private final ExecutorCompletionService<Integer> queue; nThreads = numThreads <= 0 ? Runtime.GetRuntime().AvailableProcessors() : numThreads; this.orderResults = orderResults; outputQueue = new ConcurrentHashMap <int, O>(2 * nThreads); threadPool = BuildThreadPool(nThreads); // queue = new ExecutorCompletionService<Integer>(threadPool); idleProcessors = new ArrayBlockingQueue <int>(nThreads, false); callback = null; // Sanity check: Fixed thread pool so prevent timeouts. // Default should be false threadPool.AllowCoreThreadTimeOut(false); threadPool.PrestartAllCoreThreads(); // Setup the processors, one per thread IList <IThreadsafeProcessor <I, O> > procList = new List <IThreadsafeProcessor <I, O> >(nThreads); procList.Add(processor); idleProcessors.Add(0); for (int i = 1; i < nThreads; ++i) { procList.Add(processor.NewInstance()); idleProcessors.Add(i); } processorList = Java.Util.Collections.UnmodifiableList(procList); }
/// <summary> /// Create a AsyncDiskServices with a set of volumes (specified by their /// root directories). /// </summary> /// <remarks> /// Create a AsyncDiskServices with a set of volumes (specified by their /// root directories). /// The AsyncDiskServices uses one ThreadPool per volume to do the async /// disk operations. /// </remarks> /// <param name="volumes">The roots of the file system volumes.</param> public AsyncDiskService(string[] volumes) { /* * This class is a container of multiple thread pools, each for a volume, * so that we can schedule async disk operations easily. * * Examples of async disk operations are deletion of files. * We can move the files to a "TO_BE_DELETED" folder before asychronously * deleting it, to make sure the caller can run it faster. */ // ThreadPool core pool size // ThreadPool maximum pool size // ThreadPool keep-alive time for threads over core pool size threadFactory = new _ThreadFactory_73(this); // Create one ThreadPool per volume for (int v = 0; v < volumes.Length; v++) { ThreadPoolExecutor executor = new ThreadPoolExecutor(CoreThreadsPerVolume, MaximumThreadsPerVolume , ThreadsKeepAliveSeconds, TimeUnit.Seconds, new LinkedBlockingQueue <Runnable>() , threadFactory); // This can reduce the number of running threads executor.AllowCoreThreadTimeOut(true); executors[volumes[v]] = executor; } }
private void AddExecutorForVolume(FilePath volume) { ThreadFactory threadFactory = new _ThreadFactory_71(this, volume); ThreadPoolExecutor executor = new ThreadPoolExecutor(CoreThreadsPerVolume, MaximumThreadsPerVolume , ThreadsKeepAliveSeconds, TimeUnit.Seconds, new LinkedBlockingQueue <Runnable>() , threadFactory); // This can reduce the number of running threads executor.AllowCoreThreadTimeOut(true); executors[volume] = executor; }
public AsyncDataService() { // ThreadPool core pool size // ThreadPool maximum pool size // ThreadPool keep-alive time for threads over core pool size threadFactory = new _ThreadFactory_47(this); executor = new ThreadPoolExecutor(CoreThreadsPerVolume, MaximumThreadsPerVolume, ThreadsKeepAliveSeconds, TimeUnit.Seconds, new LinkedBlockingQueue <Runnable>(), threadFactory); // This can reduce the number of running threads executor.AllowCoreThreadTimeOut(true); }
protected internal virtual ThreadPoolExecutor InitializeCacheExecutor(FilePath parent ) { if (storageType.IsTransient()) { return(null); } if (dataset.datanode == null) { // FsVolumeImpl is used in test. return(null); } int maxNumThreads = dataset.datanode.GetConf().GetInt(DFSConfigKeys.DfsDatanodeFsdatasetcacheMaxThreadsPerVolumeKey , DFSConfigKeys.DfsDatanodeFsdatasetcacheMaxThreadsPerVolumeDefault); ThreadFactory workerFactory = new ThreadFactoryBuilder().SetDaemon(true).SetNameFormat ("FsVolumeImplWorker-" + parent.ToString() + "-%d").Build(); ThreadPoolExecutor executor = new ThreadPoolExecutor(1, maxNumThreads, 60, TimeUnit .Seconds, new LinkedBlockingQueue <Runnable>(), workerFactory); executor.AllowCoreThreadTimeOut(true); return(executor); }