CS 580 Client-Server Spring Semester, 2004 Thread Pools
	Previous    Lecture Notes Index         © 2004, All Rights Reserved, SDSU & Roger Whitney San Diego State University -- This page last updated 08-Apr-04

Doc 24, Thread Pools Slide # 2

Concurrent Server With Threads

import java.net.Socket;
import java.net.ServerSocket;
import java.io.*;
import java.util.Date;
import java.util.logging.*;
import sdsu.util.ProgramProperties;
   
public class DateServer {
   private static Logger log = Logger.getLogger("dateLogger");
   
   public static void main (String args[]) throws IOException {
      ProgramProperties flags = new ProgramProperties( args);
      int port = flags.getInt( "port" , 8765);
         new DateServer().run(port);
   }
   
   public void run(int port) throws IOException {
      Thread.currentThread().setPriority(Thread.NORM_PRIORITY + 1);
      ServerSocket input = new ServerSocket( port );
      log.info("Server running on port " + input.getLocalPort());
      while (true) {
         Socket client = input.accept();
         log.info("Request from " + client.getInetAddress());
         DateHandler clientHandler = new DateHandler( 
            client.getInputStream(),
            client.getOutputStream());
         clientHandler.setPriority( Thread.NORM_PRIORITY);
         clientHandler.start();
      }
   }
}

Doc 24, Thread Pools Slide # 3

class DateHandler extends Thread {
   private InputStream in;
   private OutputStream out;
   
   public DateHandler(InputStream fromClient,OutputStream toClient) {
      in = fromClient;
      out = toClient;
   }
   
   public void run() {
      try {
         processRequest();
      }
      catch (IOException error) {
         // Log and handle error
      }
   }

Doc 24, Thread Pools Slide # 4

   void processRequest() throws IOException {
      try {
         BufferedReader parsedInput = 
            new BufferedReader(new InputStreamReader(in));
   
         boolean autoflushOn = true;
         PrintWriter parsedOutput = new PrintWriter(out,autoflushOn);
   
         String inputLine = parsedInput.readLine();
   
         if (inputLine.startsWith("date")) {
            Date now = new Date();
            parsedOutput.println(now.toString());
         }
      }
      finally {
         in.close();
         out.close();
      }
   }
}
Doc 24, Thread Pools Slide # 5

Smalltalk defineClass: #ConcurrentDateServer
   superclass: #{Core.Object}
   indexedType: #none
   private: false
   instanceVariableNames: 'serverSocket '
   classInstanceVariableNames: ''
   imports: ''
   category: 'cs580'

port: anInteger
   ^super new setPort: anInteger 
Doc 24, Thread Pools Slide # 6

   
processRequestOn: anReadAppendStream 
   | clientRequest |
   clientRequest := anReadAppendStream through: Character cr.
   (clientRequest startsWith: 'date') 
      ifTrue: [anReadAppendStream 
                     nextPutAll: Time dateAndTimeNow printString].
   anReadAppendStream close
   
run
   | childSocket clientIOStream |
   
   [childSocket := serverSocket accept.
   clientIOStream := childSocket readAppendStream.
   clientIOStream lineEndTransparent.
   [self processRequestOn: clientIOStream] forkAt: 45] 
         repeat
   
setPort: anInteger 
   serverSocket := SocketAccessor newTCPserverAtPort: anInteger.
   serverSocket
      listenFor: 4;
      soReuseaddr: true
   
shutdown
   serverSocket close
Doc 24, Thread Pools Slide # 7

Thread Pools

Iterative Server

while (true)
   {
   Socket client = serverSocket.accept();
   Sequential code to handle request
   }

Doc 24, Thread Pools Slide # 8

Basic Concurrent Server

while (true)
   {
   Socket client = serverSocket.accept();
   Create a new thread to handle request
   }

• Memory
• CPU cycles

• Threads it can productively support
• Sockets it can have open

Doc 24, Thread Pools Slide # 9

• Macintosh PowerBook with 1.25GHz PowerPC processor
• OS 10.3.3
• VW 7.2nc
• Java 1.4.2_03 with HotSpot Client

Doc 24, Thread Pools Slide # 10

Transcript clear.
#(100 1000 10000 100000) do: 
      [:n | 
      | x |
      ObjectMemory garbageCollect.
      time := Time millisecondsToRun: 
         [n timesRepeat: [[x := 3 + 4] fork]].
      Transcript
         print: n;
         tab;
         print: time;
         tab;
         print: x;
         cr;
         flush]

Doc 24, Thread Pools Slide # 11

import java.util.*;
import sdsu.util.Timer;
public class TimeTests {
   public static void main (String args[]) {
      Timer clock = new Timer();
      SampleThread x = new SampleThread();
   
      for (int n = 100; n < 200000; n = n * 10) {
         System.gc();
         clock.start();
         for (int k = 0; k < n; k++){
            x = new SampleThread();
            x.start();
         }
         long time = clock.stop();
         x.x();
         System.out.println("" +  n + "\t" + time);
         clock.reset();
      }
   }
}
   
class SampleThread extends Thread {
   int x;
   public void run() {
      x = 3 + 4;
   }
   
   public int x() {
      return x;
   }
}
Doc 24, Thread Pools Slide # 12

for (int k = 0; k < n; k++){
         }

for (int k = 0; k < n; k++){
            x = 3 + 4
         }

for (int k = 0; k < n; k++){
            x = new Vector();
         }

for (int k = 0; k < n; k++){
            x = new SampleThread();
         }

for (int k = 0; k < n; k++){
            x = new SampleThread();
            x.start();
         }

Doc 24, Thread Pools Slide # 13

• Hard to do well
• Misleading

Doc 24, Thread Pools Slide # 14

Concurrent Server With Thread Pool

Create N worker threads
while (true)
   {
   Socket client = serverSocket.accept();
   Use an existing worker thread to handle request
   }

Doc 24, Thread Pools Slide # 15

Concurrent Server With Thread Pool & Thread Creation

Create N worker threads
while (true)
   {
   Socket client = serverSocket.accept();
   if worker thread is idle
      Use an existing worker thread to handle request
   else
      create new worker thread to handle the request 
   }

Doc 24, Thread Pools Slide # 16

Doc 24, Thread Pools Slide # 17

• Memory
• Memory Cache
• Disk Cache
• Disk

Doc 24, Thread Pools Slide # 18

• Application
• Implementation
• Hardware
• Performance requirements

Doc 24, Thread Pools Slide # 19

How to reuse a Thread?

• Read request from queue
• Process request

• Block on read if queue is empty
• Signals waiting threads when data is added

Doc 24, Thread Pools Slide # 20

VisualWorks Example

Smalltalk defineClass: #ThreadedDateServer
   superclass: #{Core.Object}
   indexedType: #none
   private: false
   instanceVariableNames: 'serverSocket workers workQueue '
   classInstanceVariableNames: ''
   imports: ''
   category: 'SimpleServer'

port: anInteger
   ^super new setPort: anInteger 

setPort: anInteger 
   serverSocket := SocketAccessor newTCPserverAtPort: anInteger.
   serverSocket
      listenFor: 4;
      soReuseaddr: true.
   workQueue := SharedQueue new.
   workers := OrderedCollection new.
   5 timesRepeat: [workers add: self createWorker]

createWorker
   ^[[self processRequestOn: workQueue next] repeat] fork

Doc 24, Thread Pools Slide # 21

processRequestOn: aSocket 
   | clientRequest clientIOStream |
   
   [(aSocket readWaitWithTimeoutMs: 10000) ifTrue: [^nil].
   clientIOStream := aSocket readAppendStream.
   clientIOStream lineEndTransparent.
   clientRequest := clientIOStream through: Character cr.
   (clientRequest startsWith: 'date') 
      ifTrue: 
         [clientIOStream
            nextPutAll: Time dateAndTimeNow printString;
            cr;
            nextPut: Character lf;
            commit].
   clientIOStream close] 
         ensure: [aSocket close] 

start
   [serverSocket isActive] whileTrue: 
         [workQueue nextPut: serverSocket accept.
         workQueue size > 2 ifTrue: [workers add: self createWorker]] 
shutdown
   serverSocket close 

Doc 24, Thread Pools Slide # 22

Doc 24, Thread Pools Slide # 23

Java Example

import java.util.ArrayList;
public class SharedQueue 
   {
   ArrayList elements = new ArrayList(); 
      
   public synchronized void append( Object item ) 
      {
      elements.add( item);
      notify();
      }
      
   public synchronized Object get( ) 
      {
      try 
         {
         while ( elements.isEmpty() )
            wait();
         }
      catch (InterruptedException threadIsDone ) 
         {
         return null;
         }
      return elements.remove( 0);
      }
   
   public int size()
      {
      return elements.size();
      }
   }

Doc 24, Thread Pools Slide # 24

import java.net.*;
import java.io.*;
import java.util.Date;
public class DateHandler extends Thread 
   {
   SharedQueue workQueue;
   
   public DateHandler(SharedQueue workSource )
      {
      workQueue = workSource;
      }
   
   public void run()
      {
      while (!isInterrupted() )
         try
            {
            Socket client = (Socket) workQueue.get();
            processRequest(client);
            }
         catch (Exception error )
            {
            /* log error*/
            }
      }

Doc 24, Thread Pools Slide # 25

   void processRequest(Socket client) throws IOException
      {
      try
         {
         client.setSoTimeout( 10 * 1000 );
         processRequest(
            client.getInputStream(),
            client.getOutputStream());
         }
      finally
         {
         client.close();
         }
      }
      
   void processRequest(InputStream in, OutputStream out) 
         throws IOException
      {
      BufferedReader parsedInput = 
            new BufferedReader(new InputStreamReader(in));
      PrintWriter parsedOutput = new PrintWriter(out,true);
      String inputLine = parsedInput.readLine();
      if (inputLine.startsWith("date")) 
         {
         Date now = new Date();
         parsedOutput.println(now.toString());
         }
      }
   }

Doc 24, Thread Pools Slide # 26

import java.util.*;
import java.net.*;
import java.io.*;
public class DateServer
   {
   SharedQueue workQueue;
   ServerSocket listeningSocket;
   ArrayList workers = new ArrayList();
   public static void main( String[] args )
      {
      System.out.println( "Starting");
      new DateServer( 33333).run();
      }

Doc 24, Thread Pools Slide # 27

   public DateServer( int port )
      {
      try
         {
         listeningSocket = new ServerSocket(port);
         workQueue = new SharedQueue();
         for (int k = 0; k < 5; k++)
            {
            Thread worker = new DateHandler( workQueue);
            worker.start();
            workers.add( worker);
            }
         }
      catch (IOException socketCreateError)
         {
         //log and exit here
         }
      }

Doc 24, Thread Pools Slide # 28

   public void run()
      {
      Socket client = null;
      while (true)
         {
         try
            {
            client = listeningSocket.accept();
            workQueue.append( client);
            }
         catch (IOException acceptError)
            {
            // need to log error and make sure client is closed
            }
         }
      }
   }

Doc 24, Thread Pools Slide # 29

Previous    visitors since 08-Apr-04