001package com.pi4j.concurrent; 002 003/* 004 * #%L 005 * ********************************************************************** 006 * ORGANIZATION : Pi4J 007 * PROJECT : Pi4J :: Java Library (Core) 008 * FILENAME : DefaultExecutorServiceFactory.java 009 * 010 * This file is part of the Pi4J project. More information about 011 * this project can be found here: https://www.pi4j.com/ 012 * ********************************************************************** 013 * %% 014 * Copyright (C) 2012 - 2019 Pi4J 015 * %% 016 * This program is free software: you can redistribute it and/or modify 017 * it under the terms of the GNU Lesser General Public License as 018 * published by the Free Software Foundation, either version 3 of the 019 * License, or (at your option) any later version. 020 * 021 * This program is distributed in the hope that it will be useful, 022 * but WITHOUT ANY WARRANTY; without even the implied warranty of 023 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 024 * GNU General Lesser Public License for more details. 025 * 026 * You should have received a copy of the GNU General Lesser Public 027 * License along with this program. If not, see 028 * <http://www.gnu.org/licenses/lgpl-3.0.html>. 029 * #L% 030 */ 031 032 033import java.util.ArrayList; 034import java.util.List; 035import java.util.concurrent.ExecutorService; 036import java.util.concurrent.Executors; 037import java.util.concurrent.ScheduledExecutorService; 038import java.util.concurrent.ThreadFactory; 039import java.util.concurrent.atomic.AtomicLong; 040 041public class DefaultExecutorServiceFactory implements ExecutorServiceFactory { 042 043 private static int MAX_THREADS_IN_POOL = 25; 044 private static List<ExecutorService> singleThreadExecutorServices = new ArrayList<>(); 045 046 // this seemingly odd pattern is the recommended way to lazy-initialize static fields in effective java. 047 // The static "holder" class doesn't have it's static initializer called until it is accessed - and it's not accessed until the 048 // getInternalScheduledExecutor() method is called. 049 // 050 // (see effective java item 71:Use lazy initialization judiciously) 051 private static class ScheduledExecutorServiceHolder { 052 static final ScheduledExecutorService heldExecutor = Executors.newScheduledThreadPool(MAX_THREADS_IN_POOL, getThreadFactory("pi4j-scheduled-executor-%d")); 053 } 054 private static ScheduledExecutorService getInternalScheduledExecutorService() { 055 return ScheduledExecutorServiceHolder.heldExecutor; 056 } 057 private static class ScheduledExecutorServiceWrapperHolder { 058 static final ScheduledExecutorServiceWrapper heldWrapper = new ScheduledExecutorServiceWrapper(getInternalScheduledExecutorService()); 059 } 060 private static ScheduledExecutorServiceWrapper getScheduledExecutorServiceWrapper() { 061 return ScheduledExecutorServiceWrapperHolder.heldWrapper; 062 } 063 064 // follow a similar lazy initialization pattern for the gpio events 065 private static class GpioEventExecutorServiceHolder { 066 static final ExecutorService heldExecutor = Executors.newCachedThreadPool(getThreadFactory("pi4j-gpio-event-executor-%d")); 067 } 068 private static ExecutorService getInternalGpioExecutorService() { 069 return GpioEventExecutorServiceHolder.heldExecutor; 070 } 071 private static class GpioEventExecutorServiceWrapperHolder { 072 static final ExecutorService heldWrapper = new ShutdownDisabledExecutorWrapper(getInternalGpioExecutorService()); 073 } 074 private static ExecutorService getGpioEventExecutorServiceWrapper() { 075 return GpioEventExecutorServiceWrapperHolder.heldWrapper; 076 } 077 078 /** 079 * return an instance to the thread factory used to create new executor services 080 */ 081 private static ThreadFactory getThreadFactory(final String nameFormat) { 082 final ThreadFactory defaultThreadFactory = Executors.privilegedThreadFactory(); 083 return new ThreadFactory() { 084 final AtomicLong count = (nameFormat != null) ? new AtomicLong(0) : null; 085 086 @Override 087 public Thread newThread(Runnable runnable) { 088 Thread thread = defaultThreadFactory.newThread(runnable); 089 if (nameFormat != null) { 090 thread.setName(String.format(nameFormat, count.getAndIncrement())); 091 } 092 return thread; 093 } 094 }; 095 } 096 097 /** 098 * return an instance to the scheduled executor service (wrapper) 099 */ 100 public ScheduledExecutorService getScheduledExecutorService() { 101 // we return the protected wrapper to prevent any consumers from 102 // being able to shutdown the scheduled executor service 103 return getScheduledExecutorServiceWrapper(); 104 } 105 106 @Override 107 public ExecutorService getGpioEventExecutorService() { 108 // we return the protected wrapper to prevent any consumers from 109 // being able to shutdown the scheduled executor service 110 return getGpioEventExecutorServiceWrapper(); 111 } 112 113 /** 114 * return a new instance of a single thread executor service 115 * 116 * This method is deprecated in favor of the getGpioEventExecutorService - which provides better guarantees around resource 117 * management 118 */ 119 @Override 120 public ExecutorService newSingleThreadExecutorService() { 121 122 // create new single thread executor service 123 ExecutorService singleThreadExecutorService = Executors.newSingleThreadExecutor(getThreadFactory("pi4j-single-executor-%d")); 124 125 // add new instance to managed collection 126 singleThreadExecutorServices.add(singleThreadExecutorService); 127 128 // return new executor service 129 return singleThreadExecutorService; 130 } 131 132 /** 133 * shutdown executor threads 134 */ 135 public void shutdown() { 136 // shutdown each single thread executor in the managed collection 137 for (ExecutorService singleThreadExecutorService : singleThreadExecutorServices) { 138 shutdownExecutor(singleThreadExecutorService); 139 } 140 141 // shutdown scheduled executor instance 142 shutdownExecutor(getInternalScheduledExecutorService()); 143 shutdownExecutor(getInternalGpioExecutorService()); 144 145 } 146 147 private void shutdownExecutor(ExecutorService executor) { 148 if (executor != null) { 149 if (!executor.isShutdown()) { 150 // this is a forceful shutdown; 151 // don't wait for the scheduled tasks to complete 152 executor.shutdownNow(); 153 } 154 } 155 } 156}