diff --git a/lib/java/src/server/TServer.java b/lib/java/src/server/TServer.java
index 38ef81f..702ba69 100644
--- a/lib/java/src/server/TServer.java
+++ b/lib/java/src/server/TServer.java
@@ -24,6 +24,13 @@
   protected Options options_;
 
   /**
+   * Default options constructor
+   */
+  protected TServer(TProcessor processor) {
+    this(processor, new Options());
+  }
+
+  /**
    * Default constructor, all servers take a processor and some options.
    */
   protected TServer(TProcessor processor, Options options) {
diff --git a/lib/java/src/server/TSimpleServer.java b/lib/java/src/server/TSimpleServer.java
index 352a6de..94b739e 100644
--- a/lib/java/src/server/TSimpleServer.java
+++ b/lib/java/src/server/TSimpleServer.java
@@ -16,6 +16,12 @@
   private TServerTransport serverTransport_;
 
   public TSimpleServer(TProcessor processor,
+                       TServerTransport serverTransport) {
+    this(processor, new TServer.Options(), serverTransport);
+  }
+
+
+  public TSimpleServer(TProcessor processor,
                        TServer.Options options,
                        TServerTransport serverTransport) {
     super(processor, options);
diff --git a/lib/java/src/server/TThreadPoolServer.java b/lib/java/src/server/TThreadPoolServer.java
new file mode 100644
index 0000000..d19275e
--- /dev/null
+++ b/lib/java/src/server/TThreadPoolServer.java
@@ -0,0 +1,106 @@
+package com.facebook.thrift.server;
+
+import com.facebook.thrift.TException;
+import com.facebook.thrift.TProcessor;
+import com.facebook.thrift.transport.TServerTransport;
+import com.facebook.thrift.transport.TTransport;
+import com.facebook.thrift.transport.TTransportException;
+
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.LinkedBlockingQueue;
+import java.util.concurrent.ThreadPoolExecutor;
+import java.util.concurrent.TimeUnit;
+
+
+/**
+ * Server which uses Java's built in ThreadPool management to spawn off
+ * a worker pool that 
+ *
+ * @author Mark Slee <mcslee@facebook.com>
+ */
+public class TThreadPoolServer extends TServer {
+
+  // Server transport
+  private TServerTransport serverTransport_;
+
+  // Executor service for handling client connections
+  private ExecutorService executorService_;
+
+  // Customizable server options
+  public static class Options extends TServer.Options {
+    public int port = 9190;
+    public int minWorkerThreads = 5;
+    public int maxWorkerThreads = Integer.MAX_VALUE;
+  }
+
+  public TThreadPoolServer(TProcessor processor,
+                           TServerTransport serverTransport) {
+    this(processor, new Options(), serverTransport);
+  }
+
+  public TThreadPoolServer(TProcessor processor,
+                           Options options,
+                           TServerTransport serverTransport) {
+    super(processor, options);
+    serverTransport_ = serverTransport;
+    executorService_ = null;
+
+    LinkedBlockingQueue<Runnable> executorQueue =
+      new LinkedBlockingQueue<Runnable>();
+
+    executorService_ = new ThreadPoolExecutor(options.minWorkerThreads,
+                                              options.maxWorkerThreads,
+                                              60,
+                                              TimeUnit.SECONDS,
+                                              executorQueue);
+  }
+
+
+  public void run() {
+    try {
+      serverTransport_.listen();
+    } catch (TTransportException ttx) {
+      ttx.printStackTrace();
+      return;
+    }
+
+    while (true) {
+      try {
+        TTransport client = serverTransport_.accept();
+        WorkerProcess wp = new WorkerProcess(client);
+        executorService_.execute(wp);
+      } catch (TTransportException ttx) {
+        ttx.printStackTrace();
+      }
+    }
+  }
+
+  private class WorkerProcess implements Runnable {
+
+    /**
+     * Client that this services.
+     */
+    private TTransport client_;
+
+    /**
+     * Default constructor.
+     *
+     * @param client Transport to process
+     */
+    private WorkerProcess(TTransport client) {
+      client_ = client;
+    }
+
+    /**
+     * Loops on processing a client forever
+     */
+    public void run() {
+      try {
+        while (processor_.process(client_, client_)) {}
+      } catch (TException tx) {
+        tx.printStackTrace();
+      }
+      client_.close();
+    }
+  }
+}
diff --git a/lib/java/src/transport/TServerSocket.java b/lib/java/src/transport/TServerSocket.java
index a885fa1..8a8421d 100644
--- a/lib/java/src/transport/TServerSocket.java
+++ b/lib/java/src/transport/TServerSocket.java
@@ -1,6 +1,7 @@
 package com.facebook.thrift.transport;
 
 import java.io.IOException;
+import java.net.InetSocketAddress;
 import java.net.ServerSocket;
 import java.net.Socket;
 
@@ -11,12 +12,26 @@
  */
 public class TServerSocket extends TServerTransport {
   
-  private ServerSocket serverSocket_;
-  
+  private ServerSocket serverSocket_ = null;
+  private int port_ = 0;
+
   public TServerSocket(ServerSocket serverSocket) {
     serverSocket_ = serverSocket;
   }
 
+  public TServerSocket(int port) throws TTransportException {
+    port_ = port;
+    try {
+      serverSocket_ = new ServerSocket();
+      serverSocket_.setReuseAddress(true);
+      serverSocket_.setSoTimeout(0);
+      serverSocket_.bind(new InetSocketAddress(port_));
+    } catch (IOException ioe) {
+      serverSocket_ = null;
+      throw new TTransportException("Could not create ServerSocket on port " + port + ".");
+    }
+  }
+
   public void listen() throws TTransportException {}
   
   protected TSocket acceptImpl() throws TTransportException {