public static void main(String[] args) throws NoSuchProviderException, NoSuchAlgorithmException {
System.out.println("Starting rfid-reader2keyboard");
Security.insertProviderAt(new Smartcardio(), 1);
TerminalFactory.getInstance("PC/SC", null);
System.out.println("The following terminals were detected:");
System.out.println(Read.listTerminals());
System.out.println();
System.out.println(
"inventid RFID capturing is currently active. Close this dialog to deactivate.");
System.out.println(
"The most likely reason you see this is in order to resolve any issue you ay have found. Please follow"
+ " the instructions of inventid support and send these lines to the given email address");
executorService.scheduleAtFixedRate(errorLogger, 10, 30, TimeUnit.SECONDS);
executorService.scheduleAtFixedRate(detectorLoop, 10, 15, TimeUnit.SECONDS);
Read reader = new Read();
reader.startRunning();
Runtime.getRuntime()
.addShutdownHook(
new Thread() {
public void run() {
executorService.shutdownNow();
System.out.println(
"inventid RFID capturing is now inactive. You can close this dialog");
}
});
}
@Override
public void shutdown() {
RuntimeException exception = null;
try {
if (executor != null) {
executor.shutdownNow();
executor.awaitTermination(5, TimeUnit.SECONDS);
executor = null;
}
} catch (RuntimeException e) {
exception = e;
} catch (InterruptedException e) {
exception = new RuntimeException(e);
}
try {
if (scheduledExecutor != null) {
scheduledExecutor.shutdown();
scheduledExecutor.awaitTermination(5, TimeUnit.SECONDS);
scheduledExecutor = null;
}
} catch (RuntimeException e) {
exception = e;
} catch (InterruptedException e) {
exception = new RuntimeException(e);
}
if (exception != null) {
throw new RuntimeException("Unable to shut down job scheduler properly.", exception);
}
}
@Override
public void onApplicationStop() {
List<Class> jobs = Play.classloader.getAssignableClasses(Job.class);
for (final Class clazz : jobs) {
// @OnApplicationStop
if (clazz.isAnnotationPresent(OnApplicationStop.class)) {
try {
Job<?> job = ((Job<?>) clazz.newInstance());
scheduledJobs.add(job);
job.run();
if (job.wasError) {
if (job.lastException != null) {
throw job.lastException;
}
throw new RuntimeException("@OnApplicationStop Job has failed");
}
} catch (InstantiationException e) {
throw new UnexpectedException("Job could not be instantiated", e);
} catch (IllegalAccessException e) {
throw new UnexpectedException("Job could not be instantiated", e);
} catch (Throwable ex) {
if (ex instanceof PlayException) {
throw (PlayException) ex;
}
throw new UnexpectedException(ex);
}
}
}
executor.shutdownNow();
executor.getQueue().clear();
}
/**
* Creates a thread pool that can schedule commands to run after a given delay, or to execute
* periodically.
*
* @param corePoolSize Number of threads to keep in the pool, even if they are idle.
* @param threadName Part of thread name that would be used by thread factory.
* @return Newly created scheduled thread pool.
*/
private static ScheduledExecutorService newScheduledThreadPool(
int corePoolSize, final String threadName) {
ScheduledExecutorService srvc =
Executors.newScheduledThreadPool(
corePoolSize,
new ThreadFactory() {
@Override
public Thread newThread(Runnable r) {
Thread thread =
new Thread(r, String.format("%s-%d", threadName, THREAD_CNT.getAndIncrement()));
thread.setDaemon(true);
return thread;
}
});
ScheduledThreadPoolExecutor executor = (ScheduledThreadPoolExecutor) srvc;
// Setting up shutdown policy.
executor.setExecuteExistingDelayedTasksAfterShutdownPolicy(false);
executor.setContinueExistingPeriodicTasksAfterShutdownPolicy(false);
return srvc;
}
/**
* Implements the Token Bucket algorithm to provide a maximum number of invocations within each
* fixed time window. Useful for rate-limiting. If given a non-null executor, the scheduled
* runnables are passed to that executor for execution at the rate limit. If executor is null, a
* single-threaded executor is used
*
* @param executor the Executor which executes the Runnables. the executor is not called with the
* runnable until the rate limit has been fulfilled
* @param invocations number of queries allowed during each time window
* @param per the duration of each time window
*/
public RateLimiter(Executor executor, final int invocations, final Duration per) {
if (executor != null) {
this.executor = executor;
} else {
this.executor = Executors.newSingleThreadExecutor();
}
// This thread fills the TokenBucket with available requests every time window
ScheduledThreadPoolExecutor replenisher = new ScheduledThreadPoolExecutor(1);
replenisher.scheduleAtFixedRate(
new Runnable() {
public void run() {
int permitsToCreate = invocations - requestsAvailable.availablePermits();
if (permitsToCreate > 0) {
synchronized (requestsAvailable) {
// bring the number of requests up to the maximum size per time window
requestsAvailable.release(permitsToCreate);
}
}
}
},
0,
per.getMillis(),
TimeUnit.MILLISECONDS);
pump = new RunnablePump();
pump.start();
}
public void purge() {
_effectsScheduledThreadPool.purge();
_generalScheduledThreadPool.purge();
_aiScheduledThreadPool.purge();
_ioPacketsThreadPool.purge();
_generalPacketsThreadPool.purge();
_generalThreadPool.purge();
}
@Override
public synchronized void stop() {
for (Runnable runnable : executor.getQueue()) {
((RunnableFuture<?>) runnable).cancel(false);
}
executor.purge();
}
@Override
public SubmitterScheduler makeSubmitterScheduler(int poolSize, boolean prestartIfAvailable) {
ScheduledThreadPoolExecutor executor = new ScheduledThreadPoolExecutor(poolSize);
if (prestartIfAvailable) {
executor.prestartAllCoreThreads();
}
executors.add(executor);
return new ScheduledExecutorServiceWrapper(executor);
}
/**
* Creates a {@link ScheduledThreadPoolExecutor} with custom name for the threads.
*
* @param name the prefix to add to the thread name in ThreadFactory.
* @return The default thread pool for request timeout and client execution timeout features.
*/
public static ScheduledThreadPoolExecutor buildDefaultTimeoutThreadPool(final String name) {
ScheduledThreadPoolExecutor executor =
new ScheduledThreadPoolExecutor(5, getThreadFactory(name));
safeSetRemoveOnCancel(executor);
executor.setKeepAliveTime(5, TimeUnit.SECONDS);
executor.allowCoreThreadTimeOut(true);
return executor;
}
public static void main(String[] args) {
// Schedule a task using only Java ThreadExecutor
System.out.println("Main Thread started");
MyTask myTask = new MyTask();
int corePoolSize = 5;
ScheduledThreadPoolExecutor myExecutor = new ScheduledThreadPoolExecutor(corePoolSize);
// myExecutor.scheduleAtFixedRate(myTask, 1000, 2000, TimeUnit.MILLISECONDS);
myExecutor.scheduleAtFixedRate(myTask, 0, 1, TimeUnit.DAYS);
System.out.println("Main Thread ended");
}
@Modified
public void modified(Map<String, ?> properties) {
final Configuration conf = Configuration.create(properties);
m_conf = conf;
final int numberOfThreads = conf.numberOfThreads();
if (m_executor.getCorePoolSize() != numberOfThreads) {
m_executor.setCorePoolSize(numberOfThreads);
c_logger.info("Scheduler modified: numberOfThreads={}", numberOfThreads);
}
}
private String debug() {
_executor.purge(); // Remove cancelled tasks from the queue so we get a good queue size stat
return " Pool: "
+ _name
+ " Active: "
+ _executor.getActiveCount()
+ '/'
+ _executor.getPoolSize()
+ " Completed: "
+ _executor.getCompletedTaskCount()
+ " Queued: "
+ _executor.getQueue().size();
}
/* CONSTRUCTOR */
public ServiceSensorControl() {
// Register this object globally
GlobalContext.set(this);
// Create the executor service, keep two threads in the pool
executorService =
new ScheduledThreadPoolExecutor(SensorCollectionOptions.MAIN_EXECUTOR_CORE_POOL);
// If feature is available, enable core thread timeout with five seconds
if (Build.VERSION.SDK_INT >= 9) {
executorService.setKeepAliveTime(MAIN_EXECUTOR_CORE_TIMEOUT, TimeUnit.MILLISECONDS);
executorService.allowCoreThreadTimeOut(true);
}
}
public void deactivate() {
final ScheduledThreadPoolExecutor executor = m_executor;
executor.shutdown();
try {
executor.awaitTermination(m_conf.terminationWaitTimeInSeconds(), TimeUnit.SECONDS);
} catch (InterruptedException e) {
// Ignore
}
m_executor = null;
m_conf = null;
c_logger.info("Scheduler deactivated");
}
@Override
protected void serviceStop() throws Exception {
if (sched != null) {
sched.shutdown();
boolean terminated = false;
try {
terminated = sched.awaitTermination(10, SECONDS);
} catch (InterruptedException e) {
}
if (terminated != true) {
sched.shutdownNow();
}
}
super.serviceStop();
}
/**
* Submit the work for actual execution.
*
* @throws InvalidProtocolBufferException
*/
public void submitWork(SubmitWorkRequestProto request, String llapHost, int llapPort) {
// Register the pending events to be sent for this spec.
VertexOrBinary vob = request.getWorkSpec();
assert vob.hasVertexBinary() != vob.hasVertex();
SignableVertexSpec vertex = null;
try {
vertex =
vob.hasVertex() ? vob.getVertex() : SignableVertexSpec.parseFrom(vob.getVertexBinary());
} catch (InvalidProtocolBufferException e) {
throw new RuntimeException(e);
}
QueryIdentifierProto queryIdentifierProto = vertex.getQueryIdentifier();
TezTaskAttemptID attemptId =
Converters.createTaskAttemptId(
queryIdentifierProto,
vertex.getVertexIndex(),
request.getFragmentNumber(),
request.getAttemptNumber());
final String fragmentId = attemptId.toString();
pendingEvents.putIfAbsent(
fragmentId,
new PendingEventData(
new TaskHeartbeatInfo(fragmentId, llapHost, llapPort), Lists.<TezEvent>newArrayList()));
// Setup timer task to check for hearbeat timeouts
timer.scheduleAtFixedRate(
new HeartbeatCheckTask(), connectionTimeout, connectionTimeout, TimeUnit.MILLISECONDS);
// Send out the actual SubmitWorkRequest
communicator.sendSubmitWork(
request,
llapHost,
llapPort,
new LlapProtocolClientProxy.ExecuteRequestCallback<SubmitWorkResponseProto>() {
@Override
public void setResponse(SubmitWorkResponseProto response) {
if (response.hasSubmissionState()) {
if (response.getSubmissionState().equals(SubmissionStateProto.REJECTED)) {
String msg = "Fragment: " + fragmentId + " rejected. Server Busy.";
LOG.info(msg);
if (responder != null) {
Throwable err = new RuntimeException(msg);
responder.submissionFailed(fragmentId, err);
}
return;
}
}
}
@Override
public void indicateError(Throwable t) {
String msg = "Failed to submit: " + fragmentId;
LOG.error(msg, t);
Throwable err = new RuntimeException(msg, t);
responder.submissionFailed(fragmentId, err);
}
});
}
private void recover(RecoveredDeletionServiceState state) throws IOException {
List<DeletionServiceDeleteTaskProto> taskProtos = state.getTasks();
Map<Integer, DeletionTaskRecoveryInfo> idToInfoMap =
new HashMap<Integer, DeletionTaskRecoveryInfo>(taskProtos.size());
Set<Integer> successorTasks = new HashSet<Integer>();
for (DeletionServiceDeleteTaskProto proto : taskProtos) {
DeletionTaskRecoveryInfo info = parseTaskProto(proto);
idToInfoMap.put(info.task.taskId, info);
nextTaskId.set(Math.max(nextTaskId.get(), info.task.taskId));
successorTasks.addAll(info.successorTaskIds);
}
// restore the task dependencies and schedule the deletion tasks that
// have no predecessors
final long now = System.currentTimeMillis();
for (DeletionTaskRecoveryInfo info : idToInfoMap.values()) {
for (Integer successorId : info.successorTaskIds) {
DeletionTaskRecoveryInfo successor = idToInfoMap.get(successorId);
if (successor != null) {
info.task.addFileDeletionTaskDependency(successor.task);
} else {
LOG.error(
"Unable to locate dependency task for deletion task "
+ info.task.taskId
+ " at "
+ info.task.getSubDir());
}
}
if (!successorTasks.contains(info.task.taskId)) {
long msecTilDeletion = info.deletionTimestamp - now;
sched.schedule(info.task, msecTilDeletion, TimeUnit.MILLISECONDS);
}
}
}
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_child_on_bus);
viewHolder = new ViewHolder();
// Set on bus status
ParseCloudManager.getInstance().setStatusForSelfAndNotifyParents(TravelingData.ON_BUS);
// Initiate views
initiateViews();
// Get data from intent
travelingData = getIntent().getParcelableExtra("data");
// Set trip information from travelingData
viewHolder.busStopName.setText(travelingData.busStopName);
viewHolder.timeToStop.setText(travelingData.busArrivingAt);
// Check if next bus stop is yours, and if the bus have left the last one each 20s
poolExecutor = new ScheduledThreadPoolExecutor(1);
poolExecutor.scheduleWithFixedDelay(this, 0, 20, TimeUnit.SECONDS);
// Dummy buttons, pass forward
addButtonListener();
// Init service
Intent serviceIntent = new Intent(context, UpdateLocToParseService.class);
bindService(serviceIntent, this, 0);
}
/**
* Sends a Spine message. This is a wrapper round the Transmitter thread and registers the message
* with the retry mechanism if the contract properties require. It will also, for asynchronous
* messages, start the listener if it is not already running.
*
* @param s Concrete instance of Sendable, encapsulating the message to send.
* @param c SDS details of recipient
* @throws Exception if there was a Connection Manager boot exception, or if starting any required
* listener fails,
*/
public void send(Sendable s, SdsTransmissionDetails c) throws Exception {
// Note: check this here so getInstance() doesn't have to throw any
// exception - that means that we don't have to catch them in the
// Transmitter, which can just log if anything goes wrong with its
// own processing.
//
if (bootException != null) throw bootException;
if (!c.isSynchronous()) {
listen();
if ((s.getType() != Sendable.ACK) && (c.getDuplicateElimination().contentEquals("always"))) {
synchronized (LOGSOURCE) {
if (timer == null) {
timer = new ScheduledThreadPoolExecutor(TIMER_THREAD_POOL_SIZE);
RetryProcessor rp = new RetryProcessor();
timer.scheduleAtFixedRate(
rp, retryCheckPeriod, retryCheckPeriod, TimeUnit.MILLISECONDS);
}
}
if (!requests.containsKey(s.getMessageId())) {
requests.put(s.getMessageId(), s);
}
}
}
Transmitter t = new Transmitter(s);
t.start();
}
private void makeLod(
final LodGenerator.TriangleReductionMethod method, final float value, final int ll) {
exec.execute(
new Runnable() {
public void run() {
for (final Geometry geometry : listGeoms) {
LOG.info("make lod for " + geometry + ", value=" + value);
LodGenerator lODGenerator = new LodGenerator(geometry);
final VertexBuffer[] lods = lODGenerator.computeLods(method, value);
LOG.info("LOD levels: " + lods.length);
enqueue(
new Callable<Void>() {
public Void call() throws Exception {
geometry.getMesh().setLodLevels(lods);
lodLevel = 0;
if (geometry.getMesh().getNumLodLevels() > ll) {
lodLevel = ll;
}
geometry.setLodLevel(lodLevel);
hudText.setText(computeNbTri() + " tris");
return null;
}
});
}
}
});
}
@Override
public void start() {
super.start();
setRunning(true);
Log.d(TAG, "Starting Location sensor");
// Use any provider (LOCATION, Network or Passive)
addLocationListenerWithAllProviders();
IntentFilter intentFilter = new IntentFilter(LOCATION_UPDATE_ACTION);
getContext().registerReceiver(locationReceiver, intentFilter);
Log.d(TAG, "Starting Location sensor [done]");
Sensor.setSensorStatus(Sensor.SENSOR_LOCATION, Sensor.SENSOR_ON);
refreshStatus();
if (stpe == null) {
stpe = new ScheduledThreadPoolExecutor(1);
stpe.scheduleAtFixedRate(controller, 0, Utilities.LOCATION_CHECK_TIME, TimeUnit.MILLISECONDS);
/*stpe.scheduleAtFixedRate(controller, MAX_TIME_WITHOUT_NEW_LOCATION,
MAX_TIME_WITHOUT_NEW_LOCATION, TimeUnit.MILLISECONDS);*/
}
}
public SenderPool() {
this.saorl = new LinkedList<SenderAddedOrRemovedListener>();
this.statsListeners = new LinkedList<OverallSenderStatisticsUpdatedListener>();
analyzer = new OverallSenderStatisticAnalyzer();
this.stfe = new ScheduledThreadPoolExecutor(threadPoolSize);
stfe.scheduleAtFixedRate(analyzer, statsInterval, statsInterval, TimeUnit.MILLISECONDS);
}
public static ScheduledExecutorService getExecutor(
ThreadGroup group, String namePrefix, int threadCount, boolean preStart) {
if (threadCount == 0) {
threadCount = 1;
} else if (threadCount < 0) {
int numCpus = ManagementFactory.getOperatingSystemMXBean().getAvailableProcessors();
threadCount = Math.abs(threadCount) * numCpus;
}
ThreadFactory threadFactory = createThreadFactory(group, namePrefix);
ScheduledThreadPoolExecutor executor =
new ScheduledThreadPoolExecutor(threadCount, threadFactory);
if (preStart) {
executor.prestartAllCoreThreads();
}
return executor;
}
/** 从数据库获取待发送数据 */
private void startWatchData() {
watchDataThreadPool.scheduleAtFixedRate(
new Runnable() {
@Override
public void run() {
// 数据库查询出来并锁定的数据
List<SmQueue> temp = new ArrayList<SmQueue>();
int limit = smgFlowLimit - queue.size();
if (limit > 0) {
DatabaseTransaction trans = new DatabaseTransaction(true);
try {
temp = new DbService(trans).getMsgFromQueueAndLockMsg(channel.getId(), limit);
trans.commit();
} catch (Exception ex) {
ChannelLog.log(
Logger.getLogger(SubmitThread.class),
ex.getMessage(),
LevelUtils.getErrLevel(channel.getId()));
trans.rollback();
} finally {
trans.close();
}
if (temp.size() > 0) {
queue.addAll(temp);
}
}
}
},
1000,
1000,
TimeUnit.MILLISECONDS);
}
/** 改变标志位停止线程 */
public void stop_() {
synchronized (this) {
isContinue = false;
watchDataThreadPool.shutdown();
submitDataThreadPool.shutdown();
}
}
/** Schedules the notification updater task if it hasn't been scheduled yet. */
private void setupNotificationUpdater() {
if (AppConfig.DEBUG) Log.d(TAG, "Setting up notification updater");
if (notificationUpdater == null) {
notificationUpdater = new NotificationUpdater();
notificationUpdaterFuture =
schedExecutor.scheduleAtFixedRate(notificationUpdater, 5L, 5L, TimeUnit.SECONDS);
}
}
/** @param runFrequency implemented only for TimeUnit granularity - Seconds */
public static void schedule(Runnable runnable, Duration runFrequency, TimerType timerType) {
switch (timerType) {
case OneTimeRun:
long seconds = runFrequency.getSeconds();
if (seconds > 0) executor.schedule(runnable, seconds, TimeUnit.SECONDS);
else executor.schedule(runnable, runFrequency.toMillis(), TimeUnit.MILLISECONDS);
break;
case RepeatRun:
executor.scheduleWithFixedDelay(
runnable, runFrequency.getSeconds(), runFrequency.getSeconds(), TimeUnit.SECONDS);
break;
default:
throw new UnsupportedOperationException("Unsupported timer pattern.");
}
}
@Override
protected void afterExecute(Runnable r, Throwable t) {
super.afterExecute(r, t);
if (t != null) { // shoudn't happen, caught in RunnableEvent.run()
Log log = I2PAppContext.getGlobalContext().logManager().getLog(SimpleTimer2.class);
log.log(Log.CRIT, "wtf, event borked: " + r, t);
}
}
public void internalSchedule(TimerJobInstance timerJobInstance) {
Date date = timerJobInstance.getTrigger().hasNextFireTime();
Callable<Void> item = (Callable<Void>) timerJobInstance;
JDKJobHandle jobHandle = (JDKJobHandle) timerJobInstance.getJobHandle();
long then = date.getTime();
long now = System.currentTimeMillis();
ScheduledFuture<Void> future = null;
if (then >= now) {
future = scheduler.schedule(item, then - now, TimeUnit.MILLISECONDS);
} else {
future = scheduler.schedule(item, 0, TimeUnit.MILLISECONDS);
}
jobHandle.setFuture(future);
jobFactoryManager.addTimerJobInstance(timerJobInstance);
}
@Override
public void serviceStop() {
llapTaskUmbilicalServer.shutdownServer();
timer.shutdown();
if (this.communicator != null) {
this.communicator.stop();
}
}