假设UDP服务器端和客户端都由自己实现，客户端接受来自服务器或者其它客户的数据报，数据报
消息分很多种类型，消息类型由我自己定义好了，现在需要接受数据报并根据不同类型处理，以下
是我的客户端方案：
while(true)
{
  try
  {
    byte[] dataBuf=new byte[512];
    DatagramPacket packet=new DatagramPacket(dataBuf,512);
    UDPClient.receive(packet);
    new disposePacketThread(packet).start();
  }
  catch(Exception e){}
}

//about disposePacketThread:
class disposePacketThread extends Thread
{
  DatagramPacket packet=null;
  public disposePacketThread(DatagramPacket p)
  {   
packet=p;
  }
  public void run()
  {
    //具体的数据报处理……
  }
}

请回答以下问题：
1,方案可行这个我已经测试过了，但不知道在数据报流入量特大的时候，这个方案效率怎么样？
2,如果你认为这个方案不是最好的，请给出你的方案的思路，谢谢

最简单的处理就是这样了，流量大时开的线程多，效率自然会下降。更好的方案我没做过，但我想应该是做一个线程池，这样可以避免反复开线程，对数据报估计要做一个队列，按顺序由线程池中线程处理。

合理性没什么问题!
不过最好再程序初始化的时候就开一定的线程,然后在程序运行期间反复调用,也就是所谓的"池技术"!
另外你也可以在收到信息后将信息存放到一个特殊的数据结构中去,然后再交由线程处理!比如可以开个数组里面放五条信息,然后将这个数组传给线程类处理,这样就起到了手工CACHE的作用,不过必须满足至少同时要能收到五条消息,不然效果只能适得其反!呵呵!祝你成功!

如果要自己做池，下面是我做的简单数据缓冲池，请斧正
import java.sql.Connection;

import java.util.Enumeration;
import java.util.Hashtable;
import java.util.Vector;


/**
 *  数据缓冲池。
 *
 *@author     iSee
 *@created    2002年4月3日
 *@version    1.0,10/16/2001
 */
public class DataBufferPool
{
    //~ Instance/static variables .............................................

    // 日历阴历数据池
    private static Hashtable _CalendarLunarPool = new Hashtable( 2, 0.90f );
    private static boolean _enabled = true;
    private static DataBufferPool _instance = new DataBufferPool();

    // 数据库连接缓冲池、DOM Document缓冲池
    private static Hashtable _pool = new Hashtable( 2, 0.90f );

    // 页面池
    private static Hashtable m_PagePool = new Hashtable( 2, 0.90f );
    private static Hashtable m_PoolAnalyticData = new Hashtable( 2, 0.90f );
    private static int m_maxIdleTime = 0;
    private static int m_maxPoolSize = 0;

    //~ Constructors ..........................................................

    /**
     *  Creates a new DataBufferPool object.
     */
    private DataBufferPool()
    {
    }

    //~ Methods ...............................................................

    /**
     *  返回该Singleton类的实例。
     *
     *@return             DataBufferPool - 取到的实例
     *@throws  Exception
     */
    public static synchronized DataBufferPool getInstance()
                                                   throws Exception
    {
        if ( _instance == null )
        {
            _instance = new DataBufferPool();
        }

        return _instance;
    }

    /**
     *  Gets the enabled attribute of the DataBufferPool object
     *
     *@return    The enabled value
     */
    public boolean isEnabled()
    {
        return this._enabled;
    }

    /**
     *  设置最大空闲时间（分）。 一个连接如果一直未被调用，超出最大空闲时间后将被清除。 设置为0时表示该连接池对连接时间无限制。缺省为0。
     *
     *@param  maxIdleTime  以分钟表示的最大空闲时间
     */
    public void setMaxIdleTime( int maxIdleTime )
    {
        this.m_maxIdleTime = maxIdleTime;
    }

    /**
     *  取得最大空闲时间。
     *
     *@return    The maxIdleTime value
     */
    public int getMaxIdleTime()
    {
        return m_maxIdleTime;
    }

    /**
     *  设置最大连接数。 设置为0时表示该连接池对连接数量无限制。缺省为0。
     *
     *@param  maxPoolSize  最大连接
     */
    public void setMaxPoolSize( int maxPoolSize )
    {
        this.m_maxPoolSize = maxPoolSize;
    }

    /**
     *  取得最大连接数。
     *
     *@return    The maxPoolSize value
     */
    public int getMaxPoolSize()
    {
        return m_maxPoolSize;
    }

    /**
     *  从池中取指定关键字的项目。
     *
     *@return    成功返回1，失败返回0
     */
    public Vector getPoolItemNames()
    {
        Vector result = new Vector();

        for ( Enumeration e = _pool.keys(); e.hasMoreElements(); )
        {
            result.addElement( e.nextElement() );
        }

        result.trimToSize();

        return result;
    }

    /**
     *  清除缓冲池。
     *
     *@return    成功返回1，失败返回0
     */
    public int clear()
    {
        for ( Enumeration e = _pool.keys(); e.hasMoreElements(); )
        {
            String key = e.nextElement().toString();
            this.remove( key );
        }

        _pool.clear();
        m_PagePool.clear();

        return 1;
    }

    /**
     *  暂时停用缓冲池（不清除）。
     */
    public void disablePool()
    {
        this._enabled = false;
    }

    /**
     *  The Pool can be Enabled and Disabled. Disabling the pool closes all the
     *  outstanding Unused connections and any new connections will be closed
     *  upon release.
     */
    public void enablePool()
    {
        this._enabled = true;
    }

    /**
     * 应用释放策略，释放无用连接。
     *  Start downsizeing the pool, this usally happens right after the pool has
     *  been marked as Inactive and we are removing connections that are not
     *  currently inuse.
     *
     */
    public void freeUnused()
    {
        if ( this.getMaxPoolSize() == 0 && ( getMaxIdleTime() == 0 ) )
        {
            return;
        }

        if ( _pool.size()  2 )
            {
                _CalendarLunarPool.clear();
            }

            _CalendarLunarPool.put( key, value );
        }
        else if ( key.substring( 0, 4 ).equals( "PAGE" ) )
        {
            if ( m_PagePool.size() > 10 )
            {
                m_PagePool.clear();
            }

            m_PagePool.put( key, value );
        }
        else
        {
            this.freeUnused();
            _pool.put( key, value );
        }

        return 1;
    }

    /**
     *  从池中移除关键字为指定值的项目。
     *
     *@param  key  缓冲池中关键字
     *@return      成功返回1，失败返回0
     */
    public int remove( String key )
    {
        try
        {
            if ( _pool.get( key ) instanceof Connection )
            {
                ( ( Connection ) _pool.get( key ) ).close();
            }
        }
        catch ( Exception ex )
        {
        }

        _pool.remove( key );

        return 1;
    }

    /**
     *  Description of the Method
     */
    private void realeaseByTime()
    {
    }

    //~ Inner classes .........................................................

    /**
     *  Description of the Class
     *
     *@author     Wang
     *@created    2002年4月11日
     */
    class PoolAnalyticData
    {
        //~ Instance/static variables .........................................

        // 创建时间

        /**
         *  Description of the Field
         */
        public long createTime = 0;

        // 最后访问时间

        /**
         *  Description of the Field
         */
        public long lastVisitTime;

        // 访问计数

        /**
         *  Description of the Field
         */
        public int visitCount;

        //~ Methods ...........................................................

        // 取得持续空闲时间  (分)

        /**
         *  Gets the idleTime attribute of the PoolAnalyticData object
         *
         *@return    The idleTime value
         */
        public int getIdleTime()
        {
            return 1;
        }
    }
}

数据报流量很大的话，只有用多线程处理，楼上那位所说的线程池我不大清楚，没这方面的经验
另外还有个问题
就是数据报的信息丢失问题
据我所知，数据报传输速度是很快，但是很容易丢失信息，如果要真正做到很完善的话，相信其中的处理也很复杂