private void startThread(ConcurrencyLayer currLayer) {

        Runnable updateRunner = new Runnable() {

            /**
             * The method update the map.
             * 
             * Note that the iUpdateMap and iUpdateSpinningLogo are volatile so
             * they will not be cached in the registers. So no need to
             * synchronize.
             * 
             * 1.0: While the thread is alive.
             * 
             * 2.0: While the map is visible and the map needs to be updated
             * 
             * 2.1: If the map needs to be updated, the map and the overlay
             * information will be updated. 2.2: If the map doesn't need to be
             * updated and the map is downloading tiles. We update the spinning
             * logo.
             * 
             * 3.1: If the any key is pressed or the update map event has been
             * triggered we wait DEFAULT_TIMEOUT and update the map again. 3.2:
             * If just the spinning logo needs to be updated we wait
             * SPIN_LOGO_TIMEOUT and update the spinning logo again.
             * 
             * 4.0: If no new event has happen we put the map update thread to
             * wait until the map needs to be updated again.
             * 
             * 5.0 Rewritten... TODO
             * 
             */
            public void run() {
                while (m_IsRunning) {

                    /* Put the thread to wait when no new event has happen. */
                    synchronized (UPDATE_MONITOR) {
                        try {
                            if (!m_NeedUpdate) {
                                UPDATE_MONITOR.wait();
                            }
                        } catch (InterruptedException e) {
                            if (LOG.isError()) {
                                LOG.error(
                                        "MapUpdaterThread.internalUpdateMap()",
                                        "e2= " + e);
                            }
                        }
                    }

                    if (m_Visible) {
                        if (!m_RenderManager.isMapLocked()) {
                            // Update the map
//                            LOG.debug("UpdateThread", "Run update" + ++m_updateCounter);
                            m_NeedUpdate = false;
                            if (m_RenderManager.updateMap()) {
                                m_MapCanvas.updateScreen(m_RenderManager,
                                        m_Camera);
                            }
                        }
                    }

                    /* Wait iTimeout ms between the map updates */
                    synchronized (WAIT_OBJECT) {
                        try {
                            WAIT_OBJECT.wait(DEFAULT_TIMEOUT);
                        } catch (Exception e) {
                            if (LOG.isError()) {
                                LOG.error(
                                        "MapUpdaterThread.internalUpdateMap()",
                                        e);
                            }
                        }
                    }
                }
            }
        };
        Thread t = currLayer.startNewDaemonThread(updateRunner, "TMUpdater");
        t.setPriority(Thread.MAX_PRIORITY);
    }