JMS超时处理方案1

import java.io.IOException;
import java.io.InterruptedIOException;
import java.net.SocketTimeoutException;
import java.util.UUID;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.TimeUnit;
import javax.jms.Connection;
import javax.jms.JMSException;
import javax.jms.QueueConnection;
import javax.jms.QueueSession;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

/**
* JMS连接工具类
* JMS连接超时处理，通过线程控制JMS启动连接时failover不停重试的时间。
* @version [版本号,YYYY-MM-DD]
* @see [相关类/方法]
* @since [产品/模块版本]
*/
public class ConnUtils
{
   
    private ConnUtils()
    {
    }
   
    /**
     * get jms session
     * @param conn jms connection
     * @param timeout timeout
     * @param unit time unit
     * @param isTransaction isTransaction
     * @param ack ack
     * @return jms session
     * @throws LogCollectionException LogCollectionException
     * @throws IOException IOException
     */
    public static QueueSession connectWithTimeout(final QueueConnection conn,
            long timeout, TimeUnit unit, final Boolean isTransaction,
            final int ack) throws LogCollectionException, IOException
    {
        final BlockingQueue<Object> mailbox = new ArrayBlockingQueue<Object>(1);
        ExecutorService executor = Executors.newSingleThreadExecutor(new DaemonThreadFactory());
        executor.submit(new Runnable()
        {
            public void run()
            {
                try
                {
                    QueueSession session = conn.createQueueSession(isTransaction,
                            ack);
                    if (!mailbox.offer(session))
                    {
                        session = null;
                    }
                }
                catch (JMSException e)
                {
                    mailbox.offer(e);
                }
            }
        });
        Object result;
        try
        {
            result = mailbox.poll(timeout, unit);
            if (result == null)
            {
                if (!mailbox.offer("time out"))
                {
                    result = mailbox.take();
                }
            }
        }
        catch (InterruptedException e)
        {
            closeConn(conn);
            throw initCause(new InterruptedIOException(e.getMessage()), e);
        }
        finally
        {
            executor.shutdownNow();
        }
        if (result == null)
        {
            closeConn(conn);
            throw new SocketTimeoutException("Connect timed out");
        }
        if (result instanceof QueueSession)
        {
            return (QueueSession)result;
        }
        if (result instanceof JMSException)
        {
            closeConn(conn);
            throw new LogCollectionException("IO Execption",
                    (JMSException)result);
        }
        throw new IOException("Unknown reason!");
    }