A thread pool is a collection of threads, which you 
keep "alive" and use/reuse to process incoming "tasks". 
When a new tasks arrives (a typical example is a request to 
an HTTP server) you try to find a thread from the 
collection, which is idle, and handle the task to it. If no 
such thread exists you either wait for one to become 
available or add a new thread to the pool (usually there is 
an upper limit, though). After the thread has finished 
processing the task, it is not terminated, only marked as 
idle and ready to be reused for another task.

The main advantages of using a thread pool as opposed to 
creating a new thread to handle each new task are:

1) By reusing threads you save the thread 
creation/destruction overhead.

2) You have control over the maximum number of tasks that 
are being processed in parallel (= number of threads in the 
pool).

by multi threading

We can achieve this in java by using Interface conscept.

First of all, MultiProcessing is different from 
MultiThreading. In MultiThreading the same processor 
executes the different threads. However there is no 
parallel processing of any thread done because finally, one 
processor can handle only one task at a time. You feel the 
computer is doing many tasks together because of the very 
small amount of time between task switching but the 
processor is actually doing only a single task. But how 
fast the processor is completing all the queued tasks 
depends upon the major factor that is the clock speed and 
many others too. But when you employ more than one 
processor, as in Servers with Multiple CPUs or in the 
latest Core2Duo or Core2Quad machines, MultiProcessing 
(technically known as Parallel Computing) comes into 
picture, where each thread of the same process is assigned 
to different processors (or cores in case of the multi core 
architectures) using fork-and-join method. In this case two 
threads of the same process is parallely executed by two 
processors (in case of 2 processors). In C/C++ Parallel 
Processing (MultiProcessing ) can be achieved by using the 
OpenMP library which is shipped with the latest Visual 
Studio compilers and the other compilers like GNU v4.2 and 
above and IBM and Intel compilers. You have to write the 
programs using the appropriate #pragma statements to fork 
and join for loops and also compile the programs with 
special flags. Multiple processor or multicore cpus are 
useless unless the software you write utilizes them.
My answer does not tell you how to do the same in Java but 
you will definitely understand what to search for i.e. 
libraries supporting MultiProcessing in Java.