Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * Copyright (C) 2009 The Guava Authors
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 
 package com.google.common.util.concurrent;
 
 
Base class for services that do not need a thread while "running" but may need one during startup and shutdown. Subclasses can implement startUp() and shutDown() methods, each which run in a executor which by default uses a separate thread for each method.

Author(s):
Chris Nokleberg
Since:
1.0
 
 public abstract class AbstractIdleService implements Service {
 
   /* use AbstractService for state management */
   private final Service delegate = new AbstractService() {
     @Override protected final void doStart() {
       executor(.).execute(new Runnable() {
         @Override public void run() {
           try {
             startUp();
             notifyStarted();
           } catch (Throwable t) {
             notifyFailed(t);
             throw Throwables.propagate(t);
           }
         }
       });
     }
 
     @Override protected final void doStop() {
       executor(.).execute(new Runnable() {
         @Override public void run() {
           try {
             shutDown();
             notifyStopped();
           } catch (Throwable t) {
             notifyFailed(t);
             throw Throwables.propagate(t);
           }
         }
       });
     }
   };

  
Start the service.
 
   protected abstract void startUp() throws Exception;

  
Stop the service.
 
   protected abstract void shutDown() throws Exception;

  
Returns the java.util.concurrent.Executor that will be used to run this service. Subclasses may override this method to use a custom java.util.concurrent.Executor, which may configure its worker thread with a specific name, thread group or priority. The returned executor's execute() method is called when this service is started and stopped, and should return promptly.

Parameters:
state Service.State.STARTING or Service.State.STOPPING, used by the default implementation for naming the thread
 
   protected Executor executor(final State state) {
     return new Executor() {
       @Override
       public void execute(Runnable command) {
         new Thread(commandgetServiceName() + " " + state).start();
       }
     };
   }
 
   @Override public String toString() {
     return getServiceName() + " [" + state() + "]";
   }
 
   // We override instead of using ForwardingService so that these can be final.
  @Override public final ListenableFuture<Statestart() {
    return .start();
  }
  @Override public final State startAndWait() {
    return .startAndWait();
  }
  @Override public final boolean isRunning() {
    return .isRunning();
  }
  @Override public final State state() {
    return .state();
  }
  @Override public final ListenableFuture<Statestop() {
    return .stop();
  }
  @Override public final State stopAndWait() {
    return .stopAndWait();
  }
  
  private String getServiceName() {
    return getClass().getSimpleName();
  }
New to GrepCode? Check out our FAQ X