diff --git a/language/duchain/duchainlock.cpp b/language/duchain/duchainlock.cpp
index f86ac900a..1f322229b 100644
--- a/language/duchain/duchainlock.cpp
+++ b/language/duchain/duchainlock.cpp
@@ -1,268 +1,296 @@
 /* This file is part of KDevelop
     Copyright 2007 Kris Wong <kris.p.wong@gmail.com>
     Copyright 2007 Hamish Rodda <rodda@kde.org>
    Copyright 2007-2009 David Nolden <david.nolden.kdevelop@art-master.de>
    Copyright 2013 Milian Wolff <mail@milianw.de>
 
    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library General Public
    License version 2 as published by the Free Software Foundation.
 
    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Library General Public License for more details.
 
    You should have received a copy of the GNU Library General Public License
    along with this library; see the file COPYING.LIB.  If not, write to
    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
    Boston, MA 02110-1301, USA.
 */
 
 #include "duchainlock.h"
 #include "duchain.h"
 
 #include <QThread>
 #include <QThreadStorage>
 #include <QElapsedTimer>
 
 
 ///@todo Always prefer exactly that lock that is requested by the thread that has the foreground mutex,
 ///           to reduce the amount of UI blocking.
 
 namespace KDevelop
 {
 
 class DUChainLockPrivate
 {
 public:
   DUChainLockPrivate()
     : m_writer(0)
     , m_writerRecursion(0)
     , m_totalReaderRecursion(0)
   { }
 
   int ownReaderRecursion() const
   {
     return m_readerRecursion.localData();
   }
 
   void changeOwnReaderRecursion(int difference)
   {
     m_readerRecursion.localData() += difference;
     Q_ASSERT(m_readerRecursion.localData() >= 0);
     m_totalReaderRecursion.fetchAndAddOrdered(difference);
   }
 
   ///Holds the writer that currently has the write-lock, or zero. Is protected by m_writerRecursion.
   QAtomicPointer<QThread> m_writer;
 
   ///How often is the chain write-locked by the writer? This value protects m_writer,
   ///m_writer may only be changed by the thread that successfully increases this value from 0 to 1
   QAtomicInt m_writerRecursion;
   ///How often is the chain read-locked recursively by all readers? Should be sum of all m_readerRecursion values
   QAtomicInt m_totalReaderRecursion;
+  ///Nonzero if there is a thread waiting for a timed read lock.
+  QAtomicInt m_timeCriticalWaiters;
 
   QThreadStorage<int> m_readerRecursion;
 };
 
 DUChainLock::DUChainLock()
   : d(new DUChainLockPrivate)
 {
 }
 
 DUChainLock::~DUChainLock()
 {
   delete d;
 }
 
 bool DUChainLock::lockForRead(unsigned int timeout)
 {
+  auto currentThread = QThread::currentThread();
+  if (timeout) {
+    d->m_timeCriticalWaiters.fetchAndAddRelaxed(1);
+  }
+
   ///Step 1: Increase the own reader-recursion. This will make sure no further write-locks will succeed
   d->changeOwnReaderRecursion(1);
 
   QThread* w = d->m_writer.loadAcquire();
-  if (w == 0 || w == QThread::currentThread()) {
+  if (w == 0 || w == currentThread) {
     //Successful lock: Either there is no writer, or we hold the write-lock by ourselves
   } else {
     ///Step 2: Start spinning until there is no writer any more
 
     QElapsedTimer t;
     if (timeout) {
       t.start();
     }
 
     while (d->m_writer.loadAcquire()) {
-      if (!timeout || t.elapsed() < timeout) {
+      if (!timeout) {
+        // no timeout, just wait by yielding
         QThread::yieldCurrentThread();
+      }
+      else if (t.elapsed() < timeout) {
+        // there is a timeout, do not yield to the scheduler but just wait
+        QThread::usleep(50);
       } else {
         //Fail!
         d->changeOwnReaderRecursion(-1);
+        if (timeout) {
+          qWarning() << "timed read lock failed:" << currentThread << "timeout" << timeout;
+          d->m_timeCriticalWaiters.fetchAndAddRelaxed(-1);
+        }
         return false;
       }
     }
   }
 
+  if (timeout) {
+    d->m_timeCriticalWaiters.fetchAndAddRelaxed(-1);
+  }
   return true;
 }
 
 void DUChainLock::releaseReadLock()
 {
   d->changeOwnReaderRecursion(-1);
 }
 
 bool DUChainLock::currentThreadHasReadLock()
 {
   return (bool)d->ownReaderRecursion();
 }
 
 bool DUChainLock::lockForWrite(uint timeout)
 {
-  //It is not allowed to acquire a write-lock while holding read-lock
+  auto currentThread = QThread::currentThread();
 
+  //It is not allowed to acquire a write-lock while holding read-lock
   Q_ASSERT(d->ownReaderRecursion() == 0);
 
-  if (d->m_writer.load() == QThread::currentThread()) {
+  if (d->m_writer.load() == currentThread) {
     //We already hold the write lock, just increase the recursion count and return
     d->m_writerRecursion.fetchAndAddRelaxed(1);
     return true;
   }
 
   QElapsedTimer t;
   if (timeout) {
     t.start();
   }
 
+  while (d->m_timeCriticalWaiters > 0) {
+    //While there is somebody waiting for a timed read lock, do not acquire a write lock at all.
+    QThread::yieldCurrentThread();
+    if (timeout && t.elapsed() >= timeout) {
+      return false;
+    }
+  }
+
   while (1) {
     //Try acquiring the write-lcok
     if (d->m_totalReaderRecursion.load() == 0 && d->m_writerRecursion.testAndSetOrdered(0, 1)) {
       //Now we can be sure that there is no other writer, as we have increased m_writerRecursion from 0 to 1
       d->m_writer = QThread::currentThread();
       if (d->m_totalReaderRecursion.load() == 0) {
         //There is still no readers, we have successfully acquired a write-lock
         return true;
       } else {
         //There may be readers.. we have to continue spinning
         d->m_writer = 0;
         d->m_writerRecursion = 0;
       }
     }
 
     if (!timeout || t.elapsed() < timeout) {
       QThread::yieldCurrentThread();
     } else {
       //Fail!
       return false;
     }
   }
 
   return false;
 }
 
 void DUChainLock::releaseWriteLock()
 {
   Q_ASSERT(currentThreadHasWriteLock());
 
   //The order is important here, m_writerRecursion protects m_writer
 
   //TODO: could testAndSet here
   if (d->m_writerRecursion.load() == 1) {
     d->m_writer = 0;
     d->m_writerRecursion = 0;
   } else {
     d->m_writerRecursion.fetchAndAddOrdered(-1);
   }
 }
 
 bool DUChainLock::currentThreadHasWriteLock()
 {
   return d->m_writer.load() == QThread::currentThread();
 }
 
 DUChainReadLocker::DUChainReadLocker(DUChainLock* duChainLock, uint timeout)
   : m_lock(duChainLock ? duChainLock : DUChain::lock())
   , m_locked(false)
   , m_timeout(timeout)
 {
   lock();
 }
 
 DUChainReadLocker::~DUChainReadLocker()
 {
   unlock();
 }
 
 bool DUChainReadLocker::locked() const
 {
   return m_locked;
 }
 
 bool DUChainReadLocker::lock()
 {
   if (m_locked) {
     return true;
   }
 
   bool l = false;
   if (m_lock) {
     l = m_lock->lockForRead(m_timeout);
     Q_ASSERT(m_timeout || l);
   };
 
   m_locked = l;
 
   return l;
 }
 
 void DUChainReadLocker::unlock()
 {
   if (m_locked && m_lock) {
     m_lock->releaseReadLock();
     m_locked = false;
   }
 }
 
 DUChainWriteLocker::DUChainWriteLocker(DUChainLock* duChainLock, uint timeout)
   : m_lock(duChainLock ? duChainLock : DUChain::lock())
   , m_locked(false)
   , m_timeout(timeout)
 {
   lock();
 }
 
 DUChainWriteLocker::~DUChainWriteLocker()
 {
   unlock();
 }
 
 bool DUChainWriteLocker::lock()
 {
   if (m_locked) {
     return true;
   }
 
   bool l = false;
   if (m_lock) {
     l = m_lock->lockForWrite(m_timeout);
     Q_ASSERT(m_timeout || l);
   };
 
   m_locked = l;
 
   return l;
 }
 
 bool DUChainWriteLocker::locked() const
 {
   return m_locked;
 }
 
 void DUChainWriteLocker::unlock()
 {
   if (m_locked && m_lock) {
     m_lock->releaseWriteLock();
     m_locked = false;
   }
 }
 
 }
diff --git a/plugins/problemreporter/problemhighlighter.cpp b/plugins/problemreporter/problemhighlighter.cpp
index e7b39c7df..cab75ffa9 100644
--- a/plugins/problemreporter/problemhighlighter.cpp
+++ b/plugins/problemreporter/problemhighlighter.cpp
@@ -1,206 +1,205 @@
 /*
  * KDevelop Problem Reporter
  *
  * Copyright 2008 Hamish Rodda <rodda@kde.org>
  * Copyright 2008-2009 David Nolden <david.nolden.kdevelop@art-master.de>
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU Library General Public License as
  * published by the Free Software Foundation; either version 2 of the
  * License, or (at your option) any later version.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public
  * License along with this program; if not, write to the
  * Free Software Foundation, Inc.,
  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "problemhighlighter.h"
 
 #include <KTextEditor/Document>
 #include <KTextEditor/MarkInterface>
 #include <ktexteditor/view.h>
 #include <ktexteditor/movinginterface.h>
 
 #include <serialization/indexedstring.h>
 #include <language/duchain/navigation/abstractnavigationwidget.h>
 #include <language/util/navigationtooltip.h>
 #include <interfaces/icore.h>
 #include <interfaces/ilanguagecontroller.h>
 #include <interfaces/icompletionsettings.h>
 #include <language/duchain/duchainlock.h>
 #include <language/duchain/duchainutils.h>
 #include <language/duchain/topducontext.h>
 #include <language/duchain/navigation/problemnavigationcontext.h>
 #include <util/texteditorhelpers.h>
 
 #include <kcolorscheme.h>
 
 #include <shell/problem.h>
 
 using namespace KTextEditor;
 using namespace KDevelop;
 
 namespace
 {
 
 QColor colorForSeverity(IProblem::Severity severity)
 {
     KColorScheme scheme(QPalette::Active);
     switch (severity) {
     case IProblem::Error:
         return scheme.foreground(KColorScheme::NegativeText).color();
     case IProblem::Warning:
         return scheme.foreground(KColorScheme::NeutralText).color();
     case IProblem::Hint:
     default:
         return scheme.foreground(KColorScheme::PositiveText).color();
     }
 }
 }
 
 ProblemHighlighter::ProblemHighlighter(KTextEditor::Document* document)
     : m_document(document)
 {
     Q_ASSERT(m_document);
 
     connect(ICore::self()->languageController()->completionSettings(), &ICompletionSettings::settingsChanged, this,
             &ProblemHighlighter::settingsChanged);
     connect(m_document.data(), &Document::aboutToReload, this, &ProblemHighlighter::clearProblems);
     if (qobject_cast<MovingInterface*>(m_document)) {
         // can't use new signal/slot syntax here, MovingInterface is not a QObject
         connect(m_document, SIGNAL(aboutToInvalidateMovingInterfaceContent(KTextEditor::Document*)), this,
                 SLOT(clearProblems()));
     }
     connect(m_document, SIGNAL(aboutToRemoveText(KTextEditor::Range)), this,
             SLOT(aboutToRemoveText(KTextEditor::Range)));
 }
 
 void ProblemHighlighter::settingsChanged()
 {
     // Re-highlight
     setProblems(m_problems);
 }
 
 ProblemHighlighter::~ProblemHighlighter()
 {
     if (m_topHLRanges.isEmpty() || !m_document)
         return;
 
     qDeleteAll(m_topHLRanges);
 }
 
 void ProblemHighlighter::setProblems(const QVector<IProblem::Ptr>& problems)
 {
-    qDebug() << "updating problem highlight";
     if (!m_document)
         return;
 
     const bool hadProblems = !m_problems.isEmpty();
     m_problems = problems;
 
     qDeleteAll(m_topHLRanges);
     m_topHLRanges.clear();
     m_problemsForRanges.clear();
 
     IndexedString url(m_document->url());
 
     /// TODO: create a better MarkInterface that makes it possible to add the marks to the scrollbar
     ///      but having no background.
     ///      also make it nicer together with other plugins, this would currently fail with
     ///      this method...
     const uint errorMarkType = KTextEditor::MarkInterface::Error;
     const uint warningMarkType = KTextEditor::MarkInterface::Warning;
     KTextEditor::MarkInterface* markIface = dynamic_cast<KTextEditor::MarkInterface*>(m_document.data());
     if (markIface && hadProblems) {
         // clear previously added marks
         foreach (KTextEditor::Mark* mark, markIface->marks()) {
             if (mark->type == errorMarkType || mark->type == warningMarkType) {
                 markIface->removeMark(mark->line, mark->type);
             }
         }
     }
 
     if (problems.isEmpty()) {
         return;
     }
 
     DUChainReadLocker lock;
 
     TopDUContext* top = DUChainUtils::standardContextForUrl(m_document->url());
 
     KTextEditor::MovingInterface* iface = dynamic_cast<KTextEditor::MovingInterface*>(m_document.data());
     Q_ASSERT(iface);
 
     foreach (const IProblem::Ptr& problem, problems) {
         if (problem->finalLocation().document != url || !problem->finalLocation().isValid())
             continue;
 
         KTextEditor::Range range;
         if (top)
             range = top->transformFromLocalRevision(RangeInRevision::castFromSimpleRange(problem->finalLocation()));
         else
             range = problem->finalLocation();
 
         if (range.end().line() >= m_document->lines())
             range.end() = KTextEditor::Cursor(m_document->endOfLine(m_document->lines() - 1));
 
         if (range.isEmpty()) {
             range.setEnd(range.end() + KTextEditor::Cursor(0, 1));
         }
 
         KTextEditor::MovingRange* problemRange = iface->newMovingRange(range);
 
         m_problemsForRanges.insert(problemRange, problem);
         m_topHLRanges.append(problemRange);
 
         if (problem->source() != IProblem::ToDo
             && (problem->severity() != IProblem::Hint
                 || ICore::self()->languageController()->completionSettings()->highlightSemanticProblems())) {
             KTextEditor::Attribute::Ptr attribute(new KTextEditor::Attribute());
             attribute->setUnderlineStyle(QTextCharFormat::WaveUnderline);
             attribute->setUnderlineColor(colorForSeverity(problem->severity()));
             problemRange->setAttribute(attribute);
         }
 
         if (markIface && ICore::self()->languageController()->completionSettings()->highlightProblematicLines()) {
             uint mark;
             if (problem->severity() == IProblem::Error) {
                 mark = errorMarkType;
             } else if (problem->severity() == IProblem::Warning) {
                 mark = warningMarkType;
             } else {
                 continue;
             }
             markIface->addMark(problem->finalLocation().start().line(), mark);
         }
     }
 }
 
 void ProblemHighlighter::aboutToRemoveText(const KTextEditor::Range& range)
 {
     if (range.onSingleLine()) { // no need to optimize this
         return;
     }
 
     QList<MovingRange*>::iterator it = m_topHLRanges.begin();
     while (it != m_topHLRanges.end()) {
         if (range.contains((*it)->toRange())) {
             m_problemsForRanges.remove(*it);
             delete (*it);
             it = m_topHLRanges.erase(it);
         } else {
             ++it;
         }
     }
 }
 
 void ProblemHighlighter::clearProblems()
 {
     setProblems({});
 }