/** * Method invoked prior to executing the given Runnable in the * given thread. This method is invoked by thread <tt>t</tt> that * will execute task <tt>r</tt>, and may be used to re-initialize * ThreadLocals, or to perform logging. * * <p>This implementation does nothing, but may be customized in * subclasses. Note: To properly nest multiple overridings, subclasses * should generally invoke <tt>super.beforeExecute</tt> at the end of * this method. * * @param worker the {@link Worker}, running the the thread t * @param t the thread that will run task r. * @param r the task that will be executed. */ protected void beforeExecute(final Worker worker, final Thread t, final Runnable r) { if (delayedQueue != null) { worker.transactionExpirationTime = System.currentTimeMillis() + transactionTimeoutMillis; } final ClassLoader initial = config.getInitialClassLoader(); if (initial != null) { t.setContextClassLoader(initial); } }
/** * Method invoked prior to executing the given Runnable in the * given thread. This method is invoked by thread <tt>t</tt> that * will execute task <tt>r</tt>, and may be used to re-initialize * ThreadLocals, or to perform logging. * * <p>This implementation does nothing, but may be customized in * subclasses. Note: To properly nest multiple overridings, subclasses * should generally invoke <tt>super.beforeExecute</tt> at the end of * this method. * * @param worker the {@link Worker}, running the the thread t * @param t the thread that will run task r. * @param r the task that will be executed. */ protected void beforeExecute(final Worker worker, final Thread t, final Runnable r) { if (delayedQueue != null) { worker.transactionExpirationTime = System.currentTimeMillis() + transactionTimeoutMillis; } final ClassLoader initial = config.getInitialClassLoader(); if (initial != null) { t.setContextClassLoader(initial); } }
/** * Method invoked prior to executing the given Runnable in the * given thread. This method is invoked by thread <tt>t</tt> that * will execute task <tt>r</tt>, and may be used to re-initialize * ThreadLocals, or to perform logging. * * <p>This implementation does nothing, but may be customized in * subclasses. Note: To properly nest multiple overridings, subclasses * should generally invoke <tt>super.beforeExecute</tt> at the end of * this method. * * @param worker the {@link Worker}, running the the thread t * @param t the thread that will run task r. * @param r the task that will be executed. */ protected void beforeExecute(final Worker worker, final Thread t, final Runnable r) { if (delayedQueue != null) { worker.transactionExpirationTime = System.currentTimeMillis() + transactionTimeoutMillis; } final ClassLoader initial = config.getInitialClassLoader(); if (initial != null) { t.setContextClassLoader(initial); } }
/** * Method invoked prior to executing the given Runnable in the * given thread. This method is invoked by thread <tt>t</tt> that * will execute task <tt>r</tt>, and may be used to re-initialize * ThreadLocals, or to perform logging. * * <p>This implementation does nothing, but may be customized in * subclasses. Note: To properly nest multiple overridings, subclasses * should generally invoke <tt>super.beforeExecute</tt> at the end of * this method. * * @param worker the {@link Worker}, running the the thread t * @param t the thread that will run task r. * @param r the task that will be executed. */ protected void beforeExecute(final Worker worker, final Thread t, final Runnable r) { if (delayedQueue != null) { worker.transactionExpirationTime = System.currentTimeMillis() + transactionTimeoutMillis; } final ClassLoader initial = config.getInitialClassLoader(); if (initial != null) { t.setContextClassLoader(initial); } }
/** * Method invoked prior to executing the given Runnable in the * given thread. This method is invoked by thread <tt>t</tt> that * will execute task <tt>r</tt>, and may be used to re-initialize * ThreadLocals, or to perform logging. * * <p>This implementation does nothing, but may be customized in * subclasses. Note: To properly nest multiple overridings, subclasses * should generally invoke <tt>super.beforeExecute</tt> at the end of * this method. * * @param worker the {@link Worker}, running the the thread t * @param t the thread that will run task r. * @param r the task that will be executed. */ protected void beforeExecute(final Worker worker, final Thread t, final Runnable r) { if (delayedQueue != null) { worker.transactionExpirationTime = System.currentTimeMillis() + transactionTimeoutMillis; } final ClassLoader initial = config.getInitialClassLoader(); if (initial != null) { t.setContextClassLoader(initial); } }
/** * Method invoked prior to executing the given Runnable in the * given thread. This method is invoked by thread <tt>t</tt> that * will execute task <tt>r</tt>, and may be used to re-initialize * ThreadLocals, or to perform logging. * * <p>This implementation does nothing, but may be customized in * subclasses. Note: To properly nest multiple overridings, subclasses * should generally invoke <tt>super.beforeExecute</tt> at the end of * this method. * * @param worker the {@link Worker}, running the the thread t * @param t the thread that will run task r. * @param r the task that will be executed. */ protected void beforeExecute(final Worker worker, final Thread t, final Runnable r) { if (delayedQueue != null) { worker.transactionExpirationTime = System.currentTimeMillis() + transactionTimeoutMillis; } final ClassLoader initial = config.getInitialClassLoader(); if (initial != null) { t.setContextClassLoader(initial); } }
/** * Method invoked prior to executing the given Runnable in the * given thread. This method is invoked by thread <tt>t</tt> that * will execute task <tt>r</tt>, and may be used to re-initialize * ThreadLocals, or to perform logging. * * <p>This implementation does nothing, but may be customized in * subclasses. Note: To properly nest multiple overridings, subclasses * should generally invoke <tt>super.beforeExecute</tt> at the end of * this method. * * @param worker the {@link Worker}, running the the thread t * @param t the thread that will run task r. * @param r the task that will be executed. */ protected void beforeExecute(final Worker worker, final Thread t, final Runnable r) { if (delayedQueue != null) { worker.transactionExpirationTime = System.currentTimeMillis() + transactionTimeoutMillis; } final ClassLoader initial = config.getInitialClassLoader(); if (initial != null) { t.setContextClassLoader(initial); } }
/** * Method invoked prior to executing the given Runnable in the * given thread. This method is invoked by thread <tt>t</tt> that * will execute task <tt>r</tt>, and may be used to re-initialize * ThreadLocals, or to perform logging. * * <p>This implementation does nothing, but may be customized in * subclasses. Note: To properly nest multiple overridings, subclasses * should generally invoke <tt>super.beforeExecute</tt> at the end of * this method. * * @param worker the {@link Worker}, running the the thread t * @param t the thread that will run task r. * @param r the task that will be executed. */ protected void beforeExecute(final Worker worker, final Thread t, final Runnable r) { if (delayedQueue != null) { worker.transactionExpirationTime = System.currentTimeMillis() + transactionTimeoutMillis; } final ClassLoader initial = config.getInitialClassLoader(); if (initial != null) { t.setContextClassLoader(initial); } }
/** * Method invoked prior to executing the given Runnable in the * given thread. This method is invoked by thread <tt>t</tt> that * will execute task <tt>r</tt>, and may be used to re-initialize * ThreadLocals, or to perform logging. * * <p>This implementation does nothing, but may be customized in * subclasses. Note: To properly nest multiple overridings, subclasses * should generally invoke <tt>super.beforeExecute</tt> at the end of * this method. * * @param worker the {@link Worker}, running the the thread t * @param t the thread that will run task r. * @param r the task that will be executed. */ protected void beforeExecute(final Worker worker, final Thread t, final Runnable r) { if (delayedQueue != null) { worker.transactionExpirationTime = System.currentTimeMillis() + transactionTimeoutMillis; } final ClassLoader initial = config.getInitialClassLoader(); if (initial != null) { t.setContextClassLoader(initial); } }
/** * Method invoked prior to executing the given Runnable in the * given thread. This method is invoked by thread <tt>t</tt> that * will execute task <tt>r</tt>, and may be used to re-initialize * ThreadLocals, or to perform logging. * * <p>This implementation does nothing, but may be customized in * subclasses. Note: To properly nest multiple overridings, subclasses * should generally invoke <tt>super.beforeExecute</tt> at the end of * this method. * * @param worker the {@link Worker}, running the the thread t * @param t the thread that will run task r. * @param r the task that will be executed. */ protected void beforeExecute(final Worker worker, final Thread t, final Runnable r) { if (delayedQueue != null) { worker.transactionExpirationTime = System.currentTimeMillis() + transactionTimeoutMillis; } final ClassLoader initial = config.getInitialClassLoader(); if (initial != null) { t.setContextClassLoader(initial); } }
/** * Method invoked prior to executing the given Runnable in the * given thread. This method is invoked by thread <tt>t</tt> that * will execute task <tt>r</tt>, and may be used to re-initialize * ThreadLocals, or to perform logging. * * <p>This implementation does nothing, but may be customized in * subclasses. Note: To properly nest multiple overridings, subclasses * should generally invoke <tt>super.beforeExecute</tt> at the end of * this method. * * @param worker the {@link Worker}, running the the thread t * @param t the thread that will run task r. * @param r the task that will be executed. */ protected void beforeExecute(final Worker worker, final Thread t, final Runnable r) { if (delayedQueue != null) { worker.transactionExpirationTime = System.currentTimeMillis() + transactionTimeoutMillis; } final ClassLoader initial = config.getInitialClassLoader(); if (initial != null) { t.setContextClassLoader(initial); } }
/** * Method invoked prior to executing the given Runnable in the * given thread. This method is invoked by thread <tt>t</tt> that * will execute task <tt>r</tt>, and may be used to re-initialize * ThreadLocals, or to perform logging. * * <p>This implementation does nothing, but may be customized in * subclasses. Note: To properly nest multiple overridings, subclasses * should generally invoke <tt>super.beforeExecute</tt> at the end of * this method. * * @param worker the {@link Worker}, running the the thread t * @param t the thread that will run task r. * @param r the task that will be executed. */ protected void beforeExecute(final Worker worker, final Thread t, final Runnable r) { if (delayedQueue != null) { worker.transactionExpirationTime = System.currentTimeMillis() + transactionTimeoutMillis; } final ClassLoader initial = config.getInitialClassLoader(); if (initial != null) { t.setContextClassLoader(initial); } }