diff --git a/interface/src/raypick/LaserPointer.cpp b/interface/src/raypick/LaserPointer.cpp
index 55ddd01123..0e0f13cd6c 100644
--- a/interface/src/raypick/LaserPointer.cpp
+++ b/interface/src/raypick/LaserPointer.cpp
@@ -49,11 +49,13 @@ LaserPointer::~LaserPointer() {
 }
 
 void LaserPointer::enable() {
+    QWriteLocker lock(getLock());
     DependencyManager::get<RayPickScriptingInterface>()->enableRayPick(_rayPickUID);
     _renderingEnabled = true;
 }
 
 void LaserPointer::disable() {
+    QWriteLocker lock(getLock());
     DependencyManager::get<RayPickScriptingInterface>()->disableRayPick(_rayPickUID);
     _renderingEnabled = false;
     if (!_currentRenderState.empty()) {
@@ -67,6 +69,7 @@ void LaserPointer::disable() {
 }
 
 void LaserPointer::setRenderState(const std::string& state) {
+    QWriteLocker lock(getLock());
     if (!_currentRenderState.empty() && state != _currentRenderState) {
         if (_renderStates.find(_currentRenderState) != _renderStates.end()) {
             disableRenderState(_renderStates[_currentRenderState]);
@@ -79,6 +82,7 @@ void LaserPointer::setRenderState(const std::string& state) {
 }
 
 void LaserPointer::editRenderState(const std::string& state, const QVariant& startProps, const QVariant& pathProps, const QVariant& endProps) {
+    QWriteLocker lock(getLock());
     updateRenderStateOverlay(_renderStates[state].getStartID(), startProps);
     updateRenderStateOverlay(_renderStates[state].getPathID(), pathProps);
     updateRenderStateOverlay(_renderStates[state].getEndID(), endProps);
@@ -92,6 +96,11 @@ void LaserPointer::updateRenderStateOverlay(const OverlayID& id, const QVariant&
     }
 }
 
+const RayPickResult LaserPointer::getPrevRayPickResult() {
+    QReadLocker lock(getLock());
+    return DependencyManager::get<RayPickScriptingInterface>()->getPrevRayPickResult(_rayPickUID);
+}
+
 void LaserPointer::updateRenderState(const RenderState& renderState, const IntersectionType type, const float distance, const QUuid& objectID, const PickRay& pickRay, const bool defaultState) {
     if (!renderState.getStartID().isNull()) {
         QVariantMap startProps;
@@ -183,6 +192,8 @@ void LaserPointer::disableRenderState(const RenderState& renderState) {
 }
 
 void LaserPointer::update() {
+    // This only needs to be a read lock because update won't change any of the properties that can be modified from scripts
+    QReadLocker lock(getLock());
     RayPickResult prevRayPickResult = DependencyManager::get<RayPickScriptingInterface>()->getPrevRayPickResult(_rayPickUID);
     if (_renderingEnabled && !_currentRenderState.empty() && _renderStates.find(_currentRenderState) != _renderStates.end() &&
             (prevRayPickResult.type != IntersectionType::NONE || _laserLength > 0.0f || !_objectLockEnd.first.isNull())) {
@@ -198,6 +209,51 @@ void LaserPointer::update() {
     }
 }
 
+void LaserPointer::setPrecisionPicking(const bool precisionPicking) {
+    QWriteLocker lock(getLock());
+    DependencyManager::get<RayPickScriptingInterface>()->setPrecisionPicking(_rayPickUID, precisionPicking);
+}
+
+void LaserPointer::setLaserLength(const float laserLength) {
+    QWriteLocker lock(getLock());
+    _laserLength = laserLength;
+}
+
+void LaserPointer::setLockEndUUID(QUuid objectID, const bool isOverlay) {
+    QWriteLocker lock(getLock());
+    _objectLockEnd = std::pair<QUuid, bool>(objectID, isOverlay);
+}
+
+void LaserPointer::setIgnoreEntities(const QScriptValue& ignoreEntities) {
+    QWriteLocker lock(getLock());
+    DependencyManager::get<RayPickScriptingInterface>()->setIgnoreEntities(_rayPickUID, ignoreEntities);
+}
+
+void LaserPointer::setIncludeEntities(const QScriptValue& includeEntities) {
+    QWriteLocker lock(getLock());
+    DependencyManager::get<RayPickScriptingInterface>()->setIncludeEntities(_rayPickUID, includeEntities);
+}
+
+void LaserPointer::setIgnoreOverlays(const QScriptValue& ignoreOverlays) {
+    QWriteLocker lock(getLock());
+    DependencyManager::get<RayPickScriptingInterface>()->setIgnoreOverlays(_rayPickUID, ignoreOverlays);
+}
+
+void LaserPointer::setIncludeOverlays(const QScriptValue& includeOverlays) {
+    QWriteLocker lock(getLock());
+    DependencyManager::get<RayPickScriptingInterface>()->setIncludeOverlays(_rayPickUID, includeOverlays);
+}
+
+void LaserPointer::setIgnoreAvatars(const QScriptValue& ignoreAvatars) {
+    QWriteLocker lock(getLock());
+    DependencyManager::get<RayPickScriptingInterface>()->setIgnoreAvatars(_rayPickUID, ignoreAvatars);
+}
+
+void LaserPointer::setIncludeAvatars(const QScriptValue& includeAvatars) {
+    QWriteLocker lock(getLock());
+    DependencyManager::get<RayPickScriptingInterface>()->setIncludeAvatars(_rayPickUID, includeAvatars);
+}
+
 RenderState::RenderState(const OverlayID& startID, const OverlayID& pathID, const OverlayID& endID) :
     _startID(startID), _pathID(pathID), _endID(endID)
 {
diff --git a/interface/src/raypick/LaserPointer.h b/interface/src/raypick/LaserPointer.h
index 5467a8233e..01dfe01cfd 100644
--- a/interface/src/raypick/LaserPointer.h
+++ b/interface/src/raypick/LaserPointer.h
@@ -58,22 +58,24 @@ public:
     QUuid getRayUID() { return _rayPickUID; }
     void enable();
     void disable();
-    const RayPickResult getPrevRayPickResult() { return DependencyManager::get<RayPickScriptingInterface>()->getPrevRayPickResult(_rayPickUID); }
+    const RayPickResult getPrevRayPickResult();
 
     void setRenderState(const std::string& state);
     // You cannot use editRenderState to change the overlay type of any part of the laser pointer.  You can only edit the properties of the existing overlays.
     void editRenderState(const std::string& state, const QVariant& startProps, const QVariant& pathProps, const QVariant& endProps);
 
-    void setPrecisionPicking(const bool precisionPicking) { DependencyManager::get<RayPickScriptingInterface>()->setPrecisionPicking(_rayPickUID, precisionPicking); }
-    void setLaserLength(const float laserLength) { _laserLength = laserLength; }
-    void setIgnoreEntities(const QScriptValue& ignoreEntities) { DependencyManager::get<RayPickScriptingInterface>()->setIgnoreEntities(_rayPickUID, ignoreEntities); }
-    void setIncludeEntities(const QScriptValue& includeEntities) { DependencyManager::get<RayPickScriptingInterface>()->setIncludeEntities(_rayPickUID, includeEntities); }
-    void setIgnoreOverlays(const QScriptValue& ignoreOverlays) { DependencyManager::get<RayPickScriptingInterface>()->setIgnoreOverlays(_rayPickUID, ignoreOverlays); }
-    void setIncludeOverlays(const QScriptValue& includeOverlays) { DependencyManager::get<RayPickScriptingInterface>()->setIncludeOverlays(_rayPickUID, includeOverlays); }
-    void setIgnoreAvatars(const QScriptValue& ignoreAvatars) { DependencyManager::get<RayPickScriptingInterface>()->setIgnoreAvatars(_rayPickUID, ignoreAvatars); }
-    void setIncludeAvatars(const QScriptValue& includeAvatars) { DependencyManager::get<RayPickScriptingInterface>()->setIncludeAvatars(_rayPickUID, includeAvatars); }
+    void setPrecisionPicking(const bool precisionPicking);
+    void setLaserLength(const float laserLength);
+    void setLockEndUUID(QUuid objectID, const bool isOverlay);
 
-    void setLockEndUUID(QUuid objectID, const bool isOverlay) { _objectLockEnd = std::pair<QUuid, bool>(objectID, isOverlay); }
+    void setIgnoreEntities(const QScriptValue& ignoreEntities);
+    void setIncludeEntities(const QScriptValue& includeEntities);
+    void setIgnoreOverlays(const QScriptValue& ignoreOverlays);
+    void setIncludeOverlays(const QScriptValue& includeOverlays);
+    void setIgnoreAvatars(const QScriptValue& ignoreAvatars);
+    void setIncludeAvatars(const QScriptValue& includeAvatars);
+
+    QReadWriteLock* getLock() { return &_lock; }
 
     void update();
 
@@ -89,6 +91,7 @@ private:
     std::pair<QUuid, bool> _objectLockEnd { std::pair<QUuid, bool>(QUuid(), false)};
 
     QUuid _rayPickUID;
+    QReadWriteLock _lock;
 
     void updateRenderStateOverlay(const OverlayID& id, const QVariant& props);
     void updateRenderState(const RenderState& renderState, const IntersectionType type, const float distance, const QUuid& objectID, const PickRay& pickRay, const bool defaultState);
diff --git a/interface/src/raypick/LaserPointerManager.cpp b/interface/src/raypick/LaserPointerManager.cpp
index b19ecc14f0..8615a96c3f 100644
--- a/interface/src/raypick/LaserPointerManager.cpp
+++ b/interface/src/raypick/LaserPointerManager.cpp
@@ -17,7 +17,6 @@ QUuid LaserPointerManager::createLaserPointer(const QVariant& rayProps, const La
         QWriteLocker containsLock(&_containsLock);
         QUuid id = QUuid::createUuid();
         _laserPointers[id] = laserPointer;
-        _laserPointerLocks[id] = std::make_shared<QReadWriteLock>();
         return id;
     }
     return QUuid();
@@ -26,46 +25,45 @@ QUuid LaserPointerManager::createLaserPointer(const QVariant& rayProps, const La
 void LaserPointerManager::removeLaserPointer(const QUuid uid) {
     QWriteLocker lock(&_containsLock);
     _laserPointers.remove(uid);
-    _laserPointerLocks.remove(uid);
 }
 
 void LaserPointerManager::enableLaserPointer(const QUuid uid) {
     QReadLocker lock(&_containsLock);
-    if (_laserPointers.contains(uid)) {
-        QWriteLocker laserLock(_laserPointerLocks[uid].get());
-        _laserPointers[uid]->enable();
+    auto laserPointer = _laserPointers.find(uid);
+    if (laserPointer != _laserPointers.end()) {
+        laserPointer.value()->enable();
     }
 }
 
 void LaserPointerManager::disableLaserPointer(const QUuid uid) {
     QReadLocker lock(&_containsLock);
-    if (_laserPointers.contains(uid)) {
-        QWriteLocker laserLock(_laserPointerLocks[uid].get());
-        _laserPointers[uid]->disable();
+    auto laserPointer = _laserPointers.find(uid);
+    if (laserPointer != _laserPointers.end()) {
+        laserPointer.value()->disable();
     }
 }
 
 void LaserPointerManager::setRenderState(QUuid uid, const std::string& renderState) {
     QReadLocker lock(&_containsLock);
-    if (_laserPointers.contains(uid)) {
-        QWriteLocker laserLock(_laserPointerLocks[uid].get());
-        _laserPointers[uid]->setRenderState(renderState);
+    auto laserPointer = _laserPointers.find(uid);
+    if (laserPointer != _laserPointers.end()) {
+        laserPointer.value()->setRenderState(renderState);
     }
 }
 
 void LaserPointerManager::editRenderState(QUuid uid, const std::string& state, const QVariant& startProps, const QVariant& pathProps, const QVariant& endProps) {
     QReadLocker lock(&_containsLock);
-    if (_laserPointers.contains(uid)) {
-        QWriteLocker laserLock(_laserPointerLocks[uid].get());
-        _laserPointers[uid]->editRenderState(state, startProps, pathProps, endProps);
+    auto laserPointer = _laserPointers.find(uid);
+    if (laserPointer != _laserPointers.end()) {
+        laserPointer.value()->editRenderState(state, startProps, pathProps, endProps);
     }
 }
 
 const RayPickResult LaserPointerManager::getPrevRayPickResult(const QUuid uid) {
     QReadLocker lock(&_containsLock);
-    if (_laserPointers.contains(uid)) {
-        QReadLocker laserLock(_laserPointerLocks[uid].get());
-        return _laserPointers[uid]->getPrevRayPickResult();
+    auto laserPointer = _laserPointers.find(uid);
+    if (laserPointer != _laserPointers.end()) {
+        return laserPointer.value()->getPrevRayPickResult();
     }
     return RayPickResult();
 }
@@ -73,80 +71,79 @@ const RayPickResult LaserPointerManager::getPrevRayPickResult(const QUuid uid) {
 void LaserPointerManager::update() {
     QReadLocker lock(&_containsLock);
     for (QUuid& uid : _laserPointers.keys()) {
-        // This only needs to be a read lock because update won't change any of the properties that can be modified from scripts
-        QReadLocker laserLock(_laserPointerLocks[uid].get());
-        _laserPointers[uid]->update();
+        auto laserPointer = _laserPointers.find(uid);
+        laserPointer.value()->update();
     }
 }
 
 void LaserPointerManager::setPrecisionPicking(QUuid uid, const bool precisionPicking) {
     QReadLocker lock(&_containsLock);
-    if (_laserPointers.contains(uid)) {
-        QWriteLocker laserLock(_laserPointerLocks[uid].get());
-        _laserPointers[uid]->setPrecisionPicking(precisionPicking);
+    auto laserPointer = _laserPointers.find(uid);
+    if (laserPointer != _laserPointers.end()) {
+        laserPointer.value()->setPrecisionPicking(precisionPicking);
     }
 }
 
 void LaserPointerManager::setLaserLength(QUuid uid, const float laserLength) {
     QReadLocker lock(&_containsLock);
-    if (_laserPointers.contains(uid)) {
-        QWriteLocker laserLock(_laserPointerLocks[uid].get());
-        _laserPointers[uid]->setLaserLength(laserLength);
+    auto laserPointer = _laserPointers.find(uid);
+    if (laserPointer != _laserPointers.end()) {
+        laserPointer.value()->setLaserLength(laserLength);
     }
 }
 
 void LaserPointerManager::setIgnoreEntities(QUuid uid, const QScriptValue& ignoreEntities) {
     QReadLocker lock(&_containsLock);
-    if (_laserPointers.contains(uid)) {
-        QWriteLocker laserLock(_laserPointerLocks[uid].get());
-        _laserPointers[uid]->setIgnoreEntities(ignoreEntities);
+    auto laserPointer = _laserPointers.find(uid);
+    if (laserPointer != _laserPointers.end()) {
+        laserPointer.value()->setIgnoreEntities(ignoreEntities);
     }
 }
 
 void LaserPointerManager::setIncludeEntities(QUuid uid, const QScriptValue& includeEntities) {
     QReadLocker lock(&_containsLock);
-    if (_laserPointers.contains(uid)) {
-        QWriteLocker laserLock(_laserPointerLocks[uid].get());
-        _laserPointers[uid]->setIncludeEntities(includeEntities);
+    auto laserPointer = _laserPointers.find(uid);
+    if (laserPointer != _laserPointers.end()) {
+        laserPointer.value()->setIncludeEntities(includeEntities);
     }
 }
 
 void LaserPointerManager::setIgnoreOverlays(QUuid uid, const QScriptValue& ignoreOverlays) {
     QReadLocker lock(&_containsLock);
-    if (_laserPointers.contains(uid)) {
-        QWriteLocker laserLock(_laserPointerLocks[uid].get());
-        _laserPointers[uid]->setIgnoreOverlays(ignoreOverlays);
+    auto laserPointer = _laserPointers.find(uid);
+    if (laserPointer != _laserPointers.end()) {
+        laserPointer.value()->setIgnoreOverlays(ignoreOverlays);
     }
 }
 
 void LaserPointerManager::setIncludeOverlays(QUuid uid, const QScriptValue& includeOverlays) {
     QReadLocker lock(&_containsLock);
-    if (_laserPointers.contains(uid)) {
-        QWriteLocker laserLock(_laserPointerLocks[uid].get());
-        _laserPointers[uid]->setIncludeOverlays(includeOverlays);
+    auto laserPointer = _laserPointers.find(uid);
+    if (laserPointer != _laserPointers.end()) {
+        laserPointer.value()->setIncludeOverlays(includeOverlays);
     }
 }
 
 void LaserPointerManager::setIgnoreAvatars(QUuid uid, const QScriptValue& ignoreAvatars) {
     QReadLocker lock(&_containsLock);
-    if (_laserPointers.contains(uid)) {
-        QWriteLocker laserLock(_laserPointerLocks[uid].get());
-        _laserPointers[uid]->setIgnoreAvatars(ignoreAvatars);
+    auto laserPointer = _laserPointers.find(uid);
+    if (laserPointer != _laserPointers.end()) {
+        laserPointer.value()->setIgnoreAvatars(ignoreAvatars);
     }
 }
 
 void LaserPointerManager::setIncludeAvatars(QUuid uid, const QScriptValue& includeAvatars) {
     QReadLocker lock(&_containsLock);
-    if (_laserPointers.contains(uid)) {
-        QWriteLocker laserLock(_laserPointerLocks[uid].get());
-        _laserPointers[uid]->setIncludeAvatars(includeAvatars);
+    auto laserPointer = _laserPointers.find(uid);
+    if (laserPointer != _laserPointers.end()) {
+        laserPointer.value()->setIncludeAvatars(includeAvatars);
     }
 }
 
 void LaserPointerManager::setLockEndUUID(QUuid uid, QUuid objectID, const bool isOverlay) {
     QReadLocker lock(&_containsLock);
-    if (_laserPointers.contains(uid)) {
-        QWriteLocker laserLock(_laserPointerLocks[uid].get());
-        _laserPointers[uid]->setLockEndUUID(objectID, isOverlay);
+    auto laserPointer = _laserPointers.find(uid);
+    if (laserPointer != _laserPointers.end()) {
+        laserPointer.value()->setLockEndUUID(objectID, isOverlay);
     }
 }
diff --git a/interface/src/raypick/LaserPointerManager.h b/interface/src/raypick/LaserPointerManager.h
index 6494bb7056..b841877578 100644
--- a/interface/src/raypick/LaserPointerManager.h
+++ b/interface/src/raypick/LaserPointerManager.h
@@ -13,7 +13,6 @@
 
 #include <memory>
 #include <glm/glm.hpp>
-#include <QReadWriteLock>
 
 #include "LaserPointer.h"
 
@@ -46,7 +45,6 @@ public:
 
 private:
     QHash<QUuid, std::shared_ptr<LaserPointer>> _laserPointers;
-    QHash<QUuid, std::shared_ptr<QReadWriteLock>> _laserPointerLocks;
     QReadWriteLock _containsLock;
 
 };
diff --git a/interface/src/raypick/RayPick.cpp b/interface/src/raypick/RayPick.cpp
index 70170a8f85..a5b1299210 100644
--- a/interface/src/raypick/RayPick.cpp
+++ b/interface/src/raypick/RayPick.cpp
@@ -16,3 +16,47 @@ RayPick::RayPick(const RayPickFilter& filter, const float maxDistance, const boo
     _enabled(enabled)
 {
 }
+void RayPick::enable() {
+    QWriteLocker lock(getLock());
+    _enabled = true;
+}
+
+void RayPick::disable() {
+    QWriteLocker lock(getLock());
+    _enabled = false;
+}
+
+const RayPickResult& RayPick::getPrevRayPickResult() {
+    QReadLocker lock(getLock());
+    return _prevResult;
+}
+
+void RayPick::setIgnoreEntities(const QScriptValue& ignoreEntities) {
+    QWriteLocker lock(getLock());
+    _ignoreEntities = qVectorEntityItemIDFromScriptValue(ignoreEntities);
+}
+
+void RayPick::setIncludeEntities(const QScriptValue& includeEntities) {
+    QWriteLocker lock(getLock());
+    _includeEntities = qVectorEntityItemIDFromScriptValue(includeEntities);
+}
+
+void RayPick::setIgnoreOverlays(const QScriptValue& ignoreOverlays) {
+    QWriteLocker lock(getLock());
+    _ignoreOverlays = qVectorOverlayIDFromScriptValue(ignoreOverlays);
+}
+
+void RayPick::setIncludeOverlays(const QScriptValue& includeOverlays) {
+    QWriteLocker lock(getLock());
+    _includeOverlays = qVectorOverlayIDFromScriptValue(includeOverlays);
+}
+
+void RayPick::setIgnoreAvatars(const QScriptValue& ignoreAvatars) {
+    QWriteLocker lock(getLock());
+    _ignoreAvatars = qVectorEntityItemIDFromScriptValue(ignoreAvatars);
+}
+
+void RayPick::setIncludeAvatars(const QScriptValue& includeAvatars) {
+    QWriteLocker lock(getLock());
+    _includeAvatars = qVectorEntityItemIDFromScriptValue(includeAvatars);
+}
\ No newline at end of file
diff --git a/interface/src/raypick/RayPick.h b/interface/src/raypick/RayPick.h
index 0686a05718..6dacc084b4 100644
--- a/interface/src/raypick/RayPick.h
+++ b/interface/src/raypick/RayPick.h
@@ -16,6 +16,7 @@
 
 #include "EntityItemID.h"
 #include "ui/overlays/Overlay.h"
+#include <QReadWriteLock>
 
 class RayPickFilter {
 public:
@@ -102,13 +103,13 @@ public:
 
     virtual const PickRay getPickRay(bool& valid) const = 0;
 
-    void enable() { _enabled = true; }
-    void disable() { _enabled = false; }
+    void enable();
+    void disable();
 
     const RayPickFilter& getFilter() { return _filter; }
     float getMaxDistance() { return _maxDistance; }
     bool isEnabled() { return _enabled; }
-    const RayPickResult& getPrevRayPickResult() { return _prevResult; }
+    const RayPickResult& getPrevRayPickResult();
 
     void setPrecisionPicking(bool precisionPicking) { _filter.setFlag(RayPickFilter::PICK_COURSE, !precisionPicking); }
 
@@ -120,12 +121,14 @@ public:
     const QVector<OverlayID>& getIncludeOverlays() { return _includeOverlays; }
     const QVector<EntityItemID>& getIgnoreAvatars() { return _ignoreAvatars; }
     const QVector<EntityItemID>& getIncludeAvatars() { return _includeAvatars; }
-    void setIgnoreEntities(const QScriptValue& ignoreEntities) { _ignoreEntities = qVectorEntityItemIDFromScriptValue(ignoreEntities); }
-    void setIncludeEntities(const QScriptValue& includeEntities) { _includeEntities = qVectorEntityItemIDFromScriptValue(includeEntities); }
-    void setIgnoreOverlays(const QScriptValue& ignoreOverlays) { _ignoreOverlays = qVectorOverlayIDFromScriptValue(ignoreOverlays); }
-    void setIncludeOverlays(const QScriptValue& includeOverlays) { _includeOverlays = qVectorOverlayIDFromScriptValue(includeOverlays); }
-    void setIgnoreAvatars(const QScriptValue& ignoreAvatars) { _ignoreAvatars = qVectorEntityItemIDFromScriptValue(ignoreAvatars); }
-    void setIncludeAvatars(const QScriptValue& includeAvatars) { _includeAvatars = qVectorEntityItemIDFromScriptValue(includeAvatars); }
+    void setIgnoreEntities(const QScriptValue& ignoreEntities);
+    void setIncludeEntities(const QScriptValue& includeEntities);
+    void setIgnoreOverlays(const QScriptValue& ignoreOverlays);
+    void setIncludeOverlays(const QScriptValue& includeOverlays);
+    void setIgnoreAvatars(const QScriptValue& ignoreAvatars);
+    void setIncludeAvatars(const QScriptValue& includeAvatars);
+
+    QReadWriteLock* getLock() { return &_lock; }
 
 private:
     RayPickFilter _filter;
@@ -139,6 +142,8 @@ private:
     QVector<OverlayID> _includeOverlays;
     QVector<EntityItemID> _ignoreAvatars;
     QVector<EntityItemID> _includeAvatars;
+
+    QReadWriteLock _lock;
 };
 
 #endif // hifi_RayPick_h
diff --git a/interface/src/raypick/RayPickManager.cpp b/interface/src/raypick/RayPickManager.cpp
index bfc6e3fcb2..1728ecd01a 100644
--- a/interface/src/raypick/RayPickManager.cpp
+++ b/interface/src/raypick/RayPickManager.cpp
@@ -47,6 +47,7 @@ void RayPickManager::update() {
     RayPickCache results;
     for (auto& uid : _rayPicks.keys()) {
         std::shared_ptr<RayPick> rayPick = _rayPicks[uid];
+        QWriteLocker lock(rayPick->getLock());
         if (!rayPick->isEnabled() || rayPick->getFilter().doesPickNothing() || rayPick->getMaxDistance() < 0.0f) {
             continue;
         }
@@ -114,7 +115,6 @@ void RayPickManager::update() {
             }
         }
 
-        QWriteLocker lock(_rayPickLocks[uid].get());
         if (rayPick->getMaxDistance() == 0.0f || (rayPick->getMaxDistance() > 0.0f && res.distance < rayPick->getMaxDistance())) {
             rayPick->setRayPickResult(res);
         } else {
@@ -127,7 +127,6 @@ QUuid RayPickManager::createRayPick(const std::string& jointName, const glm::vec
     QWriteLocker lock(&_containsLock);
     QUuid id = QUuid::createUuid();
     _rayPicks[id] = std::make_shared<JointRayPick>(jointName, posOffset, dirOffset, filter, maxDistance, enabled);
-    _rayPickLocks[id] = std::make_shared<QReadWriteLock>();
     return id;
 }
 
@@ -135,7 +134,6 @@ QUuid RayPickManager::createRayPick(const RayPickFilter& filter, const float max
     QWriteLocker lock(&_containsLock);
     QUuid id = QUuid::createUuid();
     _rayPicks[id] = std::make_shared<MouseRayPick>(filter, maxDistance, enabled);
-    _rayPickLocks[id] = std::make_shared<QReadWriteLock>();
     return id;
 }
 
@@ -143,93 +141,91 @@ QUuid RayPickManager::createRayPick(const glm::vec3& position, const glm::vec3&
     QWriteLocker lock(&_containsLock);
     QUuid id = QUuid::createUuid();
     _rayPicks[id] = std::make_shared<StaticRayPick>(position, direction, filter, maxDistance, enabled);
-    _rayPickLocks[id] = std::make_shared<QReadWriteLock>();
     return id;
 }
 
 void RayPickManager::removeRayPick(const QUuid uid) {
     QWriteLocker lock(&_containsLock);
     _rayPicks.remove(uid);
-    _rayPickLocks.remove(uid);
 }
 
 void RayPickManager::enableRayPick(const QUuid uid) {
     QReadLocker containsLock(&_containsLock);
-    if (_rayPicks.contains(uid)) {
-        QWriteLocker rayPickLock(_rayPickLocks[uid].get());
-        _rayPicks[uid]->enable();
+    auto rayPick = _rayPicks.find(uid);
+    if (rayPick != _rayPicks.end()) {
+        rayPick.value()->enable();
     }
 }
 
 void RayPickManager::disableRayPick(const QUuid uid) {
     QReadLocker containsLock(&_containsLock);
-    if (_rayPicks.contains(uid)) {
-        QWriteLocker rayPickLock(_rayPickLocks[uid].get());
-        _rayPicks[uid]->disable();
+    auto rayPick = _rayPicks.find(uid);
+    if (rayPick != _rayPicks.end()) {
+        rayPick.value()->disable();
     }
 }
 
 const RayPickResult RayPickManager::getPrevRayPickResult(const QUuid uid) {
     QReadLocker containsLock(&_containsLock);
-    if (_rayPicks.contains(uid)) {
-        QReadLocker lock(_rayPickLocks[uid].get());
-        return _rayPicks[uid]->getPrevRayPickResult();
+    auto rayPick = _rayPicks.find(uid);
+    if (rayPick != _rayPicks.end()) {
+        return rayPick.value()->getPrevRayPickResult();
     }
     return RayPickResult();
 }
 
 void RayPickManager::setPrecisionPicking(QUuid uid, const bool precisionPicking) {
     QReadLocker containsLock(&_containsLock);
-    if (_rayPicks.contains(uid)) {
-        QWriteLocker lock(_rayPickLocks[uid].get());
-        _rayPicks[uid]->setPrecisionPicking(precisionPicking);
+    auto rayPick = _rayPicks.find(uid);
+    if (rayPick != _rayPicks.end()) {
+        rayPick.value()->setPrecisionPicking(precisionPicking);
     }
 }
 
 void RayPickManager::setIgnoreEntities(QUuid uid, const QScriptValue& ignoreEntities) {
     QReadLocker containsLock(&_containsLock);
-    if (_rayPicks.contains(uid)) {
-        QWriteLocker lock(_rayPickLocks[uid].get());
-        _rayPicks[uid]->setIgnoreEntities(ignoreEntities);
+    auto rayPick = _rayPicks.find(uid);
+    if (rayPick != _rayPicks.end()) {
+        rayPick.value()->setIgnoreEntities(ignoreEntities);
     }
 }
 
 void RayPickManager::setIncludeEntities(QUuid uid, const QScriptValue& includeEntities) {
     QReadLocker containsLock(&_containsLock);
-    if (_rayPicks.contains(uid)) {
-        QWriteLocker lock(_rayPickLocks[uid].get());
-        _rayPicks[uid]->setIncludeEntities(includeEntities);
+    auto rayPick = _rayPicks.find(uid);
+    if (rayPick != _rayPicks.end()) {
+        rayPick.value()->setIncludeEntities(includeEntities);
     }
 }
 
 void RayPickManager::setIgnoreOverlays(QUuid uid, const QScriptValue& ignoreOverlays) {
     QReadLocker containsLock(&_containsLock);
-    if (_rayPicks.contains(uid)) {
-        QWriteLocker lock(_rayPickLocks[uid].get());
-        _rayPicks[uid]->setIgnoreOverlays(ignoreOverlays);
+    auto rayPick = _rayPicks.find(uid);
+    if (rayPick != _rayPicks.end()) {
+        rayPick.value()->setIgnoreOverlays(ignoreOverlays);
     }
 }
 
 void RayPickManager::setIncludeOverlays(QUuid uid, const QScriptValue& includeOverlays) {
     QReadLocker containsLock(&_containsLock);
-    if (_rayPicks.contains(uid)) {
-        QWriteLocker lock(_rayPickLocks[uid].get());
-        _rayPicks[uid]->setIncludeOverlays(includeOverlays);
+    auto rayPick = _rayPicks.find(uid);
+    if (rayPick != _rayPicks.end()) {
+        rayPick.value()->setIncludeOverlays(includeOverlays);
     }
 }
 
 void RayPickManager::setIgnoreAvatars(QUuid uid, const QScriptValue& ignoreAvatars) {
     QReadLocker containsLock(&_containsLock);
-    if (_rayPicks.contains(uid)) {
-        QWriteLocker lock(_rayPickLocks[uid].get());
-        _rayPicks[uid]->setIgnoreAvatars(ignoreAvatars);
+    auto rayPick = _rayPicks.find(uid);
+    if (rayPick != _rayPicks.end()) {
+        rayPick.value()->setIgnoreAvatars(ignoreAvatars);
     }
 }
 
 void RayPickManager::setIncludeAvatars(QUuid uid, const QScriptValue& includeAvatars) {
     QReadLocker containsLock(&_containsLock);
-    if (_rayPicks.contains(uid)) {
-        QWriteLocker lock(_rayPickLocks[uid].get());
-        _rayPicks[uid]->setIncludeAvatars(includeAvatars);
+    auto rayPick = _rayPicks.find(uid);
+    if (rayPick != _rayPicks.end()) {
+        rayPick.value()->setIncludeAvatars(includeAvatars);
     }
 }
\ No newline at end of file
diff --git a/interface/src/raypick/RayPickManager.h b/interface/src/raypick/RayPickManager.h
index 9717767f19..974022eb4d 100644
--- a/interface/src/raypick/RayPickManager.h
+++ b/interface/src/raypick/RayPickManager.h
@@ -15,7 +15,6 @@
 
 #include <memory>
 #include <QtCore/QObject>
-#include <QReadWriteLock>
 
 #include "RegisteredMetaTypes.h"
 
@@ -47,7 +46,6 @@ public:
 
 private:
     QHash<QUuid, std::shared_ptr<RayPick>> _rayPicks;
-    QHash<QUuid, std::shared_ptr<QReadWriteLock>> _rayPickLocks;
     QReadWriteLock _containsLock;
 
     typedef QHash<QPair<glm::vec3, glm::vec3>, std::unordered_map<RayPickFilter::Flags, RayPickResult>> RayPickCache;