#fixed code
                                public void dispatchEvent(ManagerEvent event)
    {
        // shouldn't happen
        if (event == null)
        {
            logger.error("Unable to dispatch null event. This should never happen. Please file a bug.");
            return;
        }

        logger.debug("Dispatching event:\n" + event.toString());

        // Some events need special treatment besides forwarding them to the
        // registered eventListeners (clients)
        // These events are handled here at first:
        
        // Dispatch ResponseEvents to the appropriate responseEventListener
        if (event instanceof ResponseEvent)
        {
            ResponseEvent responseEvent;
            String internalActionId;

            responseEvent = (ResponseEvent) event;
            internalActionId = responseEvent.getInternalActionId();
            if (internalActionId != null)
            {
                synchronized (responseEventListeners)
                {
                    ManagerEventListener listener;

                    listener = responseEventListeners.get(internalActionId);
                    if (listener != null)
                    {
                        try
                        {
                            listener.onManagerEvent(event);
                        }
                        catch (Exception e)
                        {
                            logger.warn("Unexpected exception in response event listener "
                                    + listener.getClass().getName(), e);
                        }
                    }
                }
            }
            else
            {
                // ResponseEvent without internalActionId:
                // this happens if the same event class is used as response event
                // and as an event that is not triggered by a Manager command
                // Example: QueueMemberStatusEvent.
                //logger.debug("ResponseEvent without "
                //        + "internalActionId:\n" + responseEvent);
            }
        }
        if (event instanceof DisconnectEvent)
        {
            // When we receive get disconnected while we are connected start
            // a new reconnect thread and set the state to RECONNECTING.
            if (state == CONNECTED)
            {
                state = RECONNECTING;
                // close socket if still open and remove reference to readerThread
                // After sending the DisconnectThread that thread will die anyway.
                cleanup();
                reconnectThread = new Thread(new Runnable()
                {
                    public void run()
                    {
                        reconnect();
                    }
                });
                reconnectThread.setName("ReconnectThread-" + reconnectThreadNum.getAndIncrement());
                reconnectThread.setDaemon(true);
                reconnectThread.start();
                // now the DisconnectEvent is dispatched to registered eventListeners
                // (clients) and after that the ManagerReaderThread is gone.
                // So effectively we replaced the reader thread by a ReconnectThread.
            }
            else
            {
                // when we receive a DisconnectEvent while not connected we
                // ignore it and do not send it to clients
                return;
            }
        }
        if (event instanceof ProtocolIdentifierReceivedEvent)
        {
            ProtocolIdentifierReceivedEvent protocolIdentifierReceivedEvent;
            String protocolIdentifier;

            protocolIdentifierReceivedEvent = (ProtocolIdentifierReceivedEvent) event;
            protocolIdentifier = protocolIdentifierReceivedEvent.getProtocolIdentifier();
            setProtocolIdentifier(protocolIdentifier);
            // no need to send this event to clients
            return;
        }

        fireEvent(event);
    }
#vulnerable code 
                                public void dispatchEvent(ManagerEvent event)
    {
        // shouldn't happen
        if (event == null)
        {
            logger.error("Unable to dispatch null event");
            return;
        }

        logger.debug("Dispatching event:\n" + event.toString());

        // dispatch ResponseEvents to the appropriate responseEventHandler
        if (event instanceof ResponseEvent)
        {
            ResponseEvent responseEvent;
            String internalActionId;

            responseEvent = (ResponseEvent) event;
            internalActionId = responseEvent.getInternalActionId();
            if (internalActionId != null)
            {
                synchronized (responseEventListeners)
                {
                    ManagerEventListener listener;

                    listener = responseEventListeners.get(internalActionId);
                    if (listener != null)
                    {
                        try
                        {
                            listener.onManagerEvent(event);
                        }
                        catch (RuntimeException e)
                        {
                            logger.warn("Unexpected exception in event listener "
                                    + listener.getClass().getName(), e);
                        }
                    }
                }
            }
            else
            {
                // ResponseEvent without internalActionId:
                // this happens if the same event class is used as response event
                // and as an event that is not triggered by a Manager command
                // example: QueueMemberStatusEvent.
                //logger.debug("ResponseEvent without "
                //        + "internalActionId:\n" + responseEvent);
            }
        }
        if (event instanceof DisconnectEvent)
        {
            if (state == CONNECTED)
            {
                state = RECONNECTING;
                cleanup();
                reconnectThread = new Thread(new Runnable()
                {
                    public void run()
                    {
                        reconnect();
                    }
                });
                reconnectThread.setName("ReconnectThread-" + reconnectThreadNum.getAndIncrement());
                reconnectThread.setDaemon(true);
                reconnectThread.start();
            }
        }
        if (event instanceof ProtocolIdentifierReceivedEvent)
        {
            ProtocolIdentifierReceivedEvent protocolIdentifierReceivedEvent;
            String protocolIdentifier;

            protocolIdentifierReceivedEvent = (ProtocolIdentifierReceivedEvent) event;
            protocolIdentifier = protocolIdentifierReceivedEvent.getProtocolIdentifier();
            setProtocolIdentifier(protocolIdentifier);
        }

        // dispatch to listeners registered by users
        synchronized (eventListeners)
        {
            for (ManagerEventListener listener : eventListeners)
            {
                try
                {
                    listener.onManagerEvent(event);
                }
                catch (RuntimeException e)
                {
                    logger.warn("Unexpected exception in eventHandler "
                            + listener.getClass().getName(), e);
                }
            }
        }
    } 
                            #location 66 
                            #vulnerability type THREAD_SAFETY_VIOLATION