diff --git a/frameworks/native/camera/src/input/camera_input.cpp b/frameworks/native/camera/src/input/camera_input.cpp
index d460ee340022fc269167138b1c3ede0aaa3e5d92..c72b61cd003c0c9279630c084b748f2520ed55e8 100644
--- a/frameworks/native/camera/src/input/camera_input.cpp
+++ b/frameworks/native/camera/src/input/camera_input.cpp
@@ -150,6 +150,7 @@ int CameraInput::Release()
 
 void CameraInput::SetErrorCallback(std::shared_ptr<ErrorCallback> errorCallback)
 {
+    std::lock_guard<std::mutex> lock(errorCallbackMutex_);
     if (errorCallback == nullptr) {
         MEDIA_ERR_LOG("SetErrorCallback: Unregistering error callback");
     }
@@ -178,6 +179,7 @@ sptr<ICameraDeviceService> CameraInput::GetCameraDevice()
 
 std::shared_ptr<ErrorCallback> CameraInput::GetErrorCallback()
 {
+    std::lock_guard<std::mutex> lock(errorCallbackMutex_);
     return errorCallback_;
 }
 std::shared_ptr<ResultCallback> CameraInput::GetResultCallback()
diff --git a/frameworks/native/camera/src/input/camera_manager.cpp b/frameworks/native/camera/src/input/camera_manager.cpp
index 339af64387775547f67c5923412f64d3267e8d93..6a4e190f7563f6722e9618170b80b7d6d12ae7aa 100644
--- a/frameworks/native/camera/src/input/camera_manager.cpp
+++ b/frameworks/native/camera/src/input/camera_manager.cpp
@@ -59,7 +59,6 @@ CameraManager::~CameraManager()
     deathRecipient_ = nullptr;
     cameraSvcCallback_ = nullptr;
     cameraMuteSvcCallback_ = nullptr;
-    cameraMngrCallback_ = nullptr;
     for (unsigned int i = 0; i < cameraMuteListenerList.size(); i++) {
         if (cameraMuteListenerList[i]) {
             cameraMuteListenerList[i] = nullptr;
@@ -461,7 +460,10 @@ void CameraManager::Init()
 {
     CAMERA_SYNC_TRACE;
     sptr<IRemoteObject> object = nullptr;
-    cameraMngrCallback_ = nullptr;
+    {
+        std::lock_guard<std::mutex> lock(cameraMngrCbMutex_);
+        cameraMngrCallback_ = nullptr;
+    }
     auto samgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
     if (samgr == nullptr) {
         MEDIA_ERR_LOG("Failed to get System ability manager");
@@ -533,6 +535,7 @@ void CameraManager::SetCallback(std::shared_ptr<CameraManagerCallback> callback)
     if (callback == nullptr) {
         MEDIA_INFO_LOG("Application unregistering the callback");
     }
+    std::lock_guard<std::mutex> lock(cameraMngrCbMutex_);
     cameraMngrCallback_ = callback;
 }
 
@@ -540,6 +543,7 @@ std::shared_ptr<CameraManagerCallback> CameraManager::GetApplicationCallback()
 {
     MEDIA_INFO_LOG("callback! isExist = %{public}d",
                    cameraMngrCallback_ != nullptr);
+    std::lock_guard<std::mutex> lock(cameraMngrCbMutex_);
     return cameraMngrCallback_;
 }
 
diff --git a/frameworks/native/camera/src/output/metadata_output.cpp b/frameworks/native/camera/src/output/metadata_output.cpp
index 4334501cc9433350025af14aef8286b37f084ecc..a72a43d8f46624a225ec864da6c5fb94fad16863 100644
--- a/frameworks/native/camera/src/output/metadata_output.cpp
+++ b/frameworks/native/camera/src/output/metadata_output.cpp
@@ -60,8 +60,20 @@ MetadataOutput::~MetadataOutput()
         }
         surface_ = nullptr;
     }
-    appObjectCallback_ = nullptr;
-    appStateCallback_ = nullptr;
+}
+
+std::shared_ptr<MetadataObjectCallback> MetadataOutput::GetAppObjectCallback()
+{
+    MEDIA_DEBUG_LOG("CameraDeviceServiceCallback::GetAppObjectCallback");
+    std::lock_guard<std::mutex> lock(outputCallbackMutex_);
+    return appObjectCallback_;
+}
+
+std::shared_ptr<MetadataStateCallback> MetadataOutput::GetAppStateCallback()
+{
+    MEDIA_DEBUG_LOG("CameraDeviceServiceCallback::GetAppStateCallback");
+    std::lock_guard<std::mutex> lock(outputCallbackMutex_);
+    return appStateCallback_;
 }
 
 std::vector<MetadataObjectType> MetadataOutput::GetSupportedMetadataObjectTypes()
@@ -107,11 +119,13 @@ void MetadataOutput::SetCapturingMetadataObjectTypes(std::vector<MetadataObjectT
 
 void MetadataOutput::SetCallback(std::shared_ptr<MetadataObjectCallback> metadataObjectCallback)
 {
+    std::lock_guard<std::mutex> lock(outputCallbackMutex_);
     appObjectCallback_ = metadataObjectCallback;
 }
 
 void MetadataOutput::SetCallback(std::shared_ptr<MetadataStateCallback> metadataStateCallback)
 {
+    std::lock_guard<std::mutex> lock(outputCallbackMutex_);
     appStateCallback_ = metadataStateCallback;
 }
 
@@ -148,6 +162,11 @@ int32_t MetadataOutput::Stop()
 
 int32_t MetadataOutput::Release()
 {
+    {
+        std::lock_guard<std::mutex> lock(outputCallbackMutex_);
+        appObjectCallback_ = nullptr;
+        appStateCallback_ = nullptr;
+    }
     if (GetStream() == nullptr) {
         MEDIA_ERR_LOG("MetadataOutput Failed to Release!, GetStream is nullptr");
         return CameraErrorCode::SERVICE_FATL_ERROR;
@@ -163,8 +182,6 @@ int32_t MetadataOutput::Release()
         }
         surface_ = nullptr;
     }
-    appObjectCallback_ = nullptr;
-    appStateCallback_ = nullptr;
     CaptureOutput::Release();
     return ServiceToCameraError(errCode);
 }
@@ -220,7 +237,7 @@ int32_t MetadataObjectListener::ProcessMetadataBuffer(void* buffer, int64_t time
             }
         }
     }
-    std::shared_ptr<MetadataObjectCallback> appObjectCallback = metadata_->appObjectCallback_;
+    std::shared_ptr<MetadataObjectCallback> appObjectCallback = metadata_->GetAppObjectCallback();
     if (!metaObjects.empty() && appObjectCallback) {
         appObjectCallback->OnMetadataObjectsAvailable(metaObjects);
     }
@@ -249,7 +266,7 @@ void MetadataObjectListener::OnBufferAvailable()
     }
     int32_t ret = ProcessMetadataBuffer(buffer->GetVirAddr(), timestamp);
     if (ret) {
-        std::shared_ptr<MetadataStateCallback> appStateCallback = metadata_->appStateCallback_;
+        std::shared_ptr<MetadataStateCallback> appStateCallback = metadata_->GetAppStateCallback();
         if (appStateCallback) {
             appStateCallback->OnError(ret);
         }
diff --git a/frameworks/native/camera/src/output/photo_output.cpp b/frameworks/native/camera/src/output/photo_output.cpp
index 5298d06c432433106d68dea98dfbee101d7412bd..5ba0a0d27ddb92d681c8e63bc7b03f5ac2af8012 100644
--- a/frameworks/native/camera/src/output/photo_output.cpp
+++ b/frameworks/native/camera/src/output/photo_output.cpp
@@ -212,13 +212,12 @@ PhotoOutput::PhotoOutput(sptr<IStreamCapture> &streamCapture)
 PhotoOutput::~PhotoOutput()
 {
     MEDIA_DEBUG_LOG("Enter Into PhotoOutput::~PhotoOutput()");
-    cameraSvcCallback_ = nullptr;
-    appCallback_ = nullptr;
     defaultCaptureSetting_ = nullptr;
 }
 
 void PhotoOutput::SetCallback(std::shared_ptr<PhotoStateCallback> callback)
 {
+    std::lock_guard<std::mutex> lock(outputCallbackMutex_);
     appCallback_ = callback;
     if (appCallback_ != nullptr) {
         if (cameraSvcCallback_ == nullptr) {
@@ -283,6 +282,7 @@ int32_t PhotoOutput::SetThumbnail(bool isEnabled)
 
 std::shared_ptr<PhotoStateCallback> PhotoOutput::GetApplicationCallback()
 {
+    std::lock_guard<std::mutex> lock(outputCallbackMutex_);
     return appCallback_;
 }
 
@@ -368,6 +368,11 @@ int32_t PhotoOutput::CancelCapture()
 
 int32_t PhotoOutput::Release()
 {
+    {
+        std::lock_guard<std::mutex> lock(outputCallbackMutex_);
+        cameraSvcCallback_ = nullptr;
+        appCallback_ = nullptr;
+    }
     std::lock_guard<std::mutex> lock(asyncOpMutex_);
     MEDIA_DEBUG_LOG("Enter Into PhotoOutput::Release");
     if (GetStream() == nullptr) {
@@ -384,8 +389,6 @@ int32_t PhotoOutput::Release()
     if (errCode != CAMERA_OK) {
         MEDIA_ERR_LOG("PhotoOutput Failed to release!, errCode: %{public}d", errCode);
     }
-    cameraSvcCallback_ = nullptr;
-    appCallback_ = nullptr;
     defaultCaptureSetting_ = nullptr;
     CaptureOutput::Release();
     return ServiceToCameraError(errCode);
diff --git a/frameworks/native/camera/src/output/preview_output.cpp b/frameworks/native/camera/src/output/preview_output.cpp
index a99eb8dfea3ef1490b71951fcbe0c08d7dd3f11a..8aabe452b3b0b867c2e43096f20cef4324c0fd44 100644
--- a/frameworks/native/camera/src/output/preview_output.cpp
+++ b/frameworks/native/camera/src/output/preview_output.cpp
@@ -26,12 +26,15 @@ PreviewOutput::PreviewOutput(sptr<IStreamRepeat> &streamRepeat)
 
 PreviewOutput::~PreviewOutput()
 {
-    svcCallback_ = nullptr;
-    appCallback_ = nullptr;
 }
 
 int32_t PreviewOutput::Release()
 {
+    {
+        std::lock_guard<std::mutex> lock(outputCallbackMutex_);
+        svcCallback_ = nullptr;
+        appCallback_ = nullptr;
+    }
     std::lock_guard<std::mutex> lock(asyncOpMutex_);
     MEDIA_DEBUG_LOG("Enter Into PreviewOutput::Release");
     if (GetStream() == nullptr) {
@@ -48,8 +51,6 @@ int32_t PreviewOutput::Release()
     } else {
         MEDIA_ERR_LOG("PreviewOutput::Release() itemStream is nullptr");
     }
-    svcCallback_ = nullptr;
-    appCallback_ = nullptr;
     CaptureOutput::Release();
     return ServiceToCameraError(errCode);
 }
@@ -150,6 +151,7 @@ int32_t PreviewOutput::Stop()
 
 void PreviewOutput::SetCallback(std::shared_ptr<PreviewStateCallback> callback)
 {
+    std::lock_guard<std::mutex> lock(outputCallbackMutex_);
     appCallback_ = callback;
     if (appCallback_ != nullptr) {
         if (svcCallback_ == nullptr) {
@@ -182,6 +184,7 @@ void PreviewOutput::SetCallback(std::shared_ptr<PreviewStateCallback> callback)
 
 std::shared_ptr<PreviewStateCallback> PreviewOutput::GetApplicationCallback()
 {
+    std::lock_guard<std::mutex> lock(outputCallbackMutex_);
     return appCallback_;
 }
 } // CameraStandard
diff --git a/frameworks/native/camera/src/output/video_output.cpp b/frameworks/native/camera/src/output/video_output.cpp
index 7aef708350a540950adea722f294ddbcd26f2d99..910bf63f0368451599e8b0957f4e30272a8fee10 100644
--- a/frameworks/native/camera/src/output/video_output.cpp
+++ b/frameworks/native/camera/src/output/video_output.cpp
@@ -28,8 +28,6 @@ VideoOutput::VideoOutput(sptr<IStreamRepeat> &streamRepeat)
 
 VideoOutput::~VideoOutput()
 {
-    svcCallback_ = nullptr;
-    appCallback_ = nullptr;
 }
 
 int32_t VideoOutputCallbackImpl::OnFrameStarted()
@@ -66,6 +64,7 @@ int32_t VideoOutputCallbackImpl::OnFrameError(const int32_t errorCode)
 
 void VideoOutput::SetCallback(std::shared_ptr<VideoStateCallback> callback)
 {
+    std::lock_guard<std::mutex> lock(outputCallbackMutex_);
     appCallback_ = callback;
     if (appCallback_ != nullptr) {
         if (svcCallback_ == nullptr) {
@@ -181,6 +180,11 @@ int32_t VideoOutput::Pause()
 
 int32_t VideoOutput::Release()
 {
+    {
+        std::lock_guard<std::mutex> lock(outputCallbackMutex_);
+        svcCallback_ = nullptr;
+        appCallback_ = nullptr;
+    }
     std::lock_guard<std::mutex> lock(asyncOpMutex_);
     MEDIA_DEBUG_LOG("Enter Into VideoOutput::Release");
     if (GetStream() == nullptr) {
@@ -197,14 +201,13 @@ int32_t VideoOutput::Release()
     if (errCode != CAMERA_OK) {
         MEDIA_ERR_LOG("Failed to release VideoOutput!, errCode: %{public}d", errCode);
     }
-    svcCallback_ = nullptr;
-    appCallback_ = nullptr;
     CaptureOutput::Release();
     return ServiceToCameraError(errCode);
 }
 
 std::shared_ptr<VideoStateCallback> VideoOutput::GetApplicationCallback()
 {
+    std::lock_guard<std::mutex> lock(outputCallbackMutex_);
     return appCallback_;
 }
 
diff --git a/frameworks/native/camera/src/session/capture_session.cpp b/frameworks/native/camera/src/session/capture_session.cpp
index 399d3e633470d2924f440bdcf2fd7460f54e7237..b2819601bd00eb8cfad9f07e80477db753c5182b 100644
--- a/frameworks/native/camera/src/session/capture_session.cpp
+++ b/frameworks/native/camera/src/session/capture_session.cpp
@@ -123,10 +123,6 @@ CaptureSession::~CaptureSession()
     inputDevice_ = nullptr;
     captureSession_ = nullptr;
     changedMetadata_ = nullptr;
-    appCallback_ = nullptr;
-    captureSessionCallback_ = nullptr;
-    exposureCallback_ = nullptr;
-    focusCallback_ = nullptr;
 }
 
 int32_t CaptureSession::BeginConfig()
@@ -338,8 +334,9 @@ int32_t CaptureSession::Release()
     }
     inputDevice_ = nullptr;
     captureSession_ = nullptr;
-    captureSessionCallback_ = nullptr;
     changedMetadata_ = nullptr;
+    std::lock_guard<std::mutex> lock(sessionCallbackMutex_);
+    captureSessionCallback_ = nullptr;
     appCallback_ = nullptr;
     exposureCallback_ = nullptr;
     focusCallback_ = nullptr;
@@ -348,6 +345,7 @@ int32_t CaptureSession::Release()
 
 void CaptureSession::SetCallback(std::shared_ptr<SessionCallback> callback)
 {
+    std::lock_guard<std::mutex> lock(sessionCallbackMutex_);
     if (callback == nullptr) {
         MEDIA_ERR_LOG("CaptureSession::SetCallback: Unregistering application callback!");
     }
@@ -373,6 +371,7 @@ void CaptureSession::SetCallback(std::shared_ptr<SessionCallback> callback)
 
 std::shared_ptr<SessionCallback> CaptureSession::GetApplicationCallback()
 {
+    std::lock_guard<std::mutex> lock(sessionCallbackMutex_);
     return appCallback_;
 }
 
@@ -1017,6 +1016,7 @@ int32_t CaptureSession::GetExposureValue(float &exposureValue)
 
 void CaptureSession::SetExposureCallback(std::shared_ptr<ExposureCallback> exposureCallback)
 {
+    std::lock_guard<std::mutex> lock(sessionCallbackMutex_);
     exposureCallback_ = exposureCallback;
 }
 
@@ -1033,6 +1033,7 @@ void CaptureSession::ProcessAutoExposureUpdates(const std::shared_ptr<Camera::Ca
     ret = Camera::FindCameraMetadataItem(metadata, OHOS_CONTROL_EXPOSURE_STATE, &item);
     if (ret == CAM_META_SUCCESS) {
         MEDIA_INFO_LOG("Exposure state: %{public}d", item.data.u8[0]);
+        std::lock_guard<std::mutex> lock(sessionCallbackMutex_);
         if (exposureCallback_ != nullptr) {
             auto itr = metaToFwExposureState_.find(static_cast<camera_exposure_state_t>(item.data.u8[0]));
             if (itr != metaToFwExposureState_.end()) {
@@ -1099,6 +1100,7 @@ int32_t CaptureSession::GetSupportedFocusModes(std::vector<FocusMode> &supported
 
 void CaptureSession::SetFocusCallback(std::shared_ptr<FocusCallback> focusCallback)
 {
+    std::lock_guard<std::mutex> lock(sessionCallbackMutex_);
     focusCallback_ = focusCallback;
     return;
 }
@@ -1397,6 +1399,7 @@ void CaptureSession::ProcessAutoFocusUpdates(const std::shared_ptr<Camera::Camer
     ret = Camera::FindCameraMetadataItem(metadata, OHOS_CONTROL_FOCUS_STATE, &item);
     if (ret == CAM_META_SUCCESS) {
         MEDIA_DEBUG_LOG("Focus state: %{public}d", item.data.u8[0]);
+        std::lock_guard<std::mutex> lock(sessionCallbackMutex_);
         if (focusCallback_ != nullptr) {
             auto itr = metaToFwFocusState_.find(static_cast<camera_focus_state_t>(item.data.u8[0]));
             if (itr != metaToFwFocusState_.end() && itr->second != focusCallback_->currentState) {
diff --git a/interfaces/inner_api/native/camera/include/input/camera_input.h b/interfaces/inner_api/native/camera/include/input/camera_input.h
index 4a7b36ef8cef7fd5079aae89d720c89bcf65da44..39643062bc2475341d2f93094906b14cf8b813ef 100644
--- a/interfaces/inner_api/native/camera/include/input/camera_input.h
+++ b/interfaces/inner_api/native/camera/include/input/camera_input.h
@@ -316,6 +316,7 @@ public:
     int32_t SetCameraSettings(std::string setting);
 
 private:
+    std::mutex errorCallbackMutex_;
     sptr<ICameraDeviceService> deviceObj_;
     sptr<CameraDevice> cameraObj_;
     std::shared_ptr<ResultCallback> resultCallback_;
diff --git a/interfaces/inner_api/native/camera/include/input/camera_manager.h b/interfaces/inner_api/native/camera/include/input/camera_manager.h
index f3fbe4d2b73c8068e50ad96264db651adac676a0..644be1a0ae0f8bf2047bf4b8bc0fe1fc6872ae93 100644
--- a/interfaces/inner_api/native/camera/include/input/camera_manager.h
+++ b/interfaces/inner_api/native/camera/include/input/camera_manager.h
@@ -480,6 +480,7 @@ private:
         std::shared_ptr<OHOS::Camera::CameraMetadata> metadata, const camera_metadata_item_t &item);
 
     std::mutex mutex_;
+    std::mutex cameraMngrCbMutex_;
     int CreateCameraDevice(std::string cameraId, sptr<ICameraDeviceService> *pICameraDeviceService);
     camera_format_t GetCameraMetadataFormat(CameraFormat format);
     bool GetDmDeviceInfo();
diff --git a/interfaces/inner_api/native/camera/include/output/capture_output.h b/interfaces/inner_api/native/camera/include/output/capture_output.h
index 747c8eb297fbbe7ce3cadcc196c212232e282245..1416e37ecb214b39e6792d3d95fb73413b4b5537 100644
--- a/interfaces/inner_api/native/camera/include/output/capture_output.h
+++ b/interfaces/inner_api/native/camera/include/output/capture_output.h
@@ -56,6 +56,7 @@ public:
     CaptureSession* GetSession();
     void SetSession(CaptureSession* captureSession);
     std::mutex asyncOpMutex_;
+    std::mutex outputCallbackMutex_;
 private:
     CaptureOutputType outputType_;
     StreamType streamType_;
diff --git a/interfaces/inner_api/native/camera/include/output/metadata_output.h b/interfaces/inner_api/native/camera/include/output/metadata_output.h
index 6dcf7812be9815a892d3348bacbf9dd9731f0dc3..db4b1dfd89812cbba5908a62ea98b306a454c28b 100644
--- a/interfaces/inner_api/native/camera/include/output/metadata_output.h
+++ b/interfaces/inner_api/native/camera/include/output/metadata_output.h
@@ -123,7 +123,8 @@ public:
      * @brief Releases a instance of the MetadataOutput.
      */
     int32_t Release() override;
-
+    std::shared_ptr<MetadataObjectCallback> GetAppObjectCallback();
+    std::shared_ptr<MetadataStateCallback> GetAppStateCallback();
     friend class MetadataObjectListener;
 private:
     sptr<IConsumerSurface> surface_;
diff --git a/interfaces/inner_api/native/camera/include/session/capture_session.h b/interfaces/inner_api/native/camera/include/session/capture_session.h
index 21e3de4a8455887aa8387fc951897b6213ebf5f0..65b621d6d77648fed9aea706adfcefce4d57f008 100644
--- a/interfaces/inner_api/native/camera/include/session/capture_session.h
+++ b/interfaces/inner_api/native/camera/include/session/capture_session.h
@@ -695,6 +695,7 @@ public:
     bool IsSessionConfiged();
 private:
     std::mutex changeMetaMutex_;
+    std::mutex sessionCallbackMutex_;
     std::shared_ptr<OHOS::Camera::CameraMetadata> changedMetadata_;
     sptr<ICaptureSession> captureSession_;
     std::shared_ptr<SessionCallback> appCallback_;