1. 
  2. import java.io.BufferedOutputStream;
  3. import java.io.BufferedReader;
  4. import java.io.IOException;
  5. import java.io.InputStreamReader;
  6. import java.io.PrintWriter;
  7. import java.net.InetAddress;
  8. import java.net.Socket;
  9. import java.net.UnknownHostException;
 10. import java.util.LinkedList;
 11. import java.util.List;
 12. 
 13. public final class SocketTest implements Runnable
 14. {
 15.     private final InetAddress address;
 16.     private final short port;
 17. 
 18.     private Socket socket;
 19.     private BufferedReader in;
 20.     private PrintWriter out;
 21. 
 22.     private Thread runner;
 23.     private List list;
 24. 
 25.     private SocketTest(final List list, final String host, final String port) throws UnknownHostException
 26.     {
 27.         System.out.println("[DEBUG] new SocketTest");
 28. 
 29.         this.address = InetAddress.getByName(host);
 30.         this.port = Short.parseShort(port);
 31.         this.list = list;
 32.     }
 33. 
 34.     public void feed() throws IOException
 35.     {
 36.         System.out.println("[DEBUG] feed");
 37. 
 38.         socket = new Socket(this.address, this.port);
 39.         in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
 40.         out = new PrintWriter(new BufferedOutputStream(socket.getOutputStream()), true);
 41. 
 42.         runner = new Thread(this);
 43.         runner.setName("SocketTestThread");
 44.         runner.start();
 45.     }
 46. 
 47.     public void stop()
 48.     {
 49.         if (runner != null)
 50.         {
 51.             System.out.println("[DEBUG] stop");
 52. 
 53.             runner = null;
 54. 
 55.             try
 56.             {
 57.                 socket.close();
 58.             }
 59.             catch (final IOException e)
 60.             {
 61.                 e.printStackTrace();
 62.             }
 63.         }
 64.     }
 65. 
 66.     /**
 67.      * @see java.lang.Runnable#run()
 68.      */
 69.     public void run()
 70.     {
 71.         System.out.println("[DEBUG] run");
 72. 
 73.         out.println("GET");
 74.         String line;
 75. 
 76.         try
 77.         {
 78.             while (runner != null && (line = in.readLine()) != null)
 79.             {
 80.                 System.out.println("[DEBUG] Got line: " + line);
 81. 
 82.                 synchronized (list)
 83.                 {
 84.                     list.add(line.substring(3, 5));
 85.                     list.notifyAll();
 86.                 }
 87.             }
 88.         }
 89.         catch (final IOException e)
 90.         {
 91.             e.printStackTrace();
 92.         }
 93.         finally
 94.         {
 95.             stop();
 96.         }
 97.     }
 98. 
 99.     public static void main(String[] args) throws IOException, InterruptedException
100.     {
101.         if (args.length < 2)
102.         {
103.             printUsage();
104.             System.exit(1);
105.         }
106. 
107.         final List list = new LinkedList();
108. 
109.         new SocketTest(list, args[0], args[1]).feed();
110. 
111.         while (true)
112.         {
113.             String line;
114. 
115.             synchronized (list)
116.             {
117.                 while (list.isEmpty())
118.                 {
119.                     list.wait();
120.                 }
121. 
122.                 line = (String) list.remove(0);
123.             }
124. 
125.             if (line != null)
126.             {
127.                 process(line);
128.             }
129.         }
130.     }
131. 
132.     private static void printUsage()
133.     {
134.         System.out.println("Usage: SocketTest <host> <port>");
135.     }
136. 
137.     private static void process(final String line)
138.     {
139.         System.out.println("[DEBUG] Processing line: " + line);
140. 
141.         // enter yoru code here
142.     }
143. }