diff --git a/services/audiohdiproxy/include/daudio_hdf_operate.h b/services/audiohdiproxy/include/daudio_hdf_operate.h
index 52bf942baf738115f8cd0ce790dd6d04c1856e02..a30a43ff4ca3d837044626c1a59edd01349846a2 100644
--- a/services/audiohdiproxy/include/daudio_hdf_operate.h
+++ b/services/audiohdiproxy/include/daudio_hdf_operate.h
@@ -16,6 +16,7 @@
 #ifndef OHOS_DAUDIO_HDF_OPERATE_H
 #define OHOS_DAUDIO_HDF_OPERATE_H
 
+#include <atomic>
 #include <condition_variable>
 #include <mutex>
 
@@ -45,13 +46,13 @@ public:
     int32_t UnLoadDaudioHDFImpl();
 
 private:
-    int32_t WaitLoadService(const uint16_t& servStatus, const std::string& servName);
+    int32_t WaitLoadService(const std::string& servName);
 
 private:
     OHOS::sptr<IDeviceManager> devmgr_;
     OHOS::sptr<IServiceManager> servMgr_;
-    uint16_t audioServStatus_ = INVALID_VALUE;
-    uint16_t audioextServStatus_ = INVALID_VALUE;
+    std::atomic<uint16_t> audioServStatus_ = INVALID_VALUE;
+    std::atomic<uint16_t> audioextServStatus_ = INVALID_VALUE;
     std::condition_variable hdfOperateCon_;
     std::mutex hdfOperateMutex_;
 };
diff --git a/services/audiohdiproxy/src/daudio_hdf_operate.cpp b/services/audiohdiproxy/src/daudio_hdf_operate.cpp
index bd50688dfb378affe25b7e153864ac553cb0c504..f847de8e1b8f04fca97bca155d4d85d174aa2e91 100644
--- a/services/audiohdiproxy/src/daudio_hdf_operate.cpp
+++ b/services/audiohdiproxy/src/daudio_hdf_operate.cpp
@@ -37,8 +37,8 @@ void DAudioHdfServStatListener::OnReceive(const ServiceStatus& status)
 
 int32_t DaudioHdfOperate::LoadDaudioHDFImpl()
 {
-    if (audioServStatus_ == OHOS::HDI::ServiceManager::V1_0::SERVIE_STATUS_START &&
-        audioextServStatus_ == OHOS::HDI::ServiceManager::V1_0::SERVIE_STATUS_START) {
+    if (audioServStatus_.load() == OHOS::HDI::ServiceManager::V1_0::SERVIE_STATUS_START &&
+        audioextServStatus_.load() == OHOS::HDI::ServiceManager::V1_0::SERVIE_STATUS_START) {
         DHLOGD("Service has already start.");
         return DH_SUCCESS;
     }
@@ -53,10 +53,10 @@ int32_t DaudioHdfOperate::LoadDaudioHDFImpl()
                 status.serviceName.c_str(), status.status);
             std::unique_lock<std::mutex> lock(hdfOperateMutex_);
             if (status.serviceName == AUDIO_SERVICE_NAME) {
-                audioServStatus_ = status.status;
+                audioServStatus_.store(status.status);
                 hdfOperateCon_.notify_one();
             } else if (status.serviceName == AUDIOEXT_SERVICE_NAME) {
-                audioextServStatus_ = status.status;
+                audioextServStatus_.store(status.status);
                 hdfOperateCon_.notify_one();
             }
     })));
@@ -65,20 +65,19 @@ int32_t DaudioHdfOperate::LoadDaudioHDFImpl()
         return ERR_DH_AUDIO_NULLPTR;
     }
 
-    if (devmgr_->LoadDevice(AUDIO_SERVICE_NAME) != HDF_SUCCESS) {
-        DHLOGE("Load audio service failed!");
+    int32_t ret = devmgr_->LoadDevice(AUDIO_SERVICE_NAME);
+    if (ret != HDF_SUCCESS && ret != HDF_ERR_DEVICE_BUSY) {
         return ERR_DH_AUDIO_FAILED;
     }
-    if (WaitLoadService(audioServStatus_, AUDIO_SERVICE_NAME) != DH_SUCCESS) {
+    if (WaitLoadService(AUDIO_SERVICE_NAME) != DH_SUCCESS) {
         DHLOGE("Wait load audio service failed!");
         return ERR_DH_AUDIO_FAILED;
     }
-
-    if (devmgr_->LoadDevice(AUDIOEXT_SERVICE_NAME) != HDF_SUCCESS) {
-        DHLOGE("Load provider service failed!");
+    ret = devmgr_->LoadDevice(AUDIOEXT_SERVICE_NAME);
+    if (ret != HDF_SUCCESS && ret != HDF_ERR_DEVICE_BUSY) {
         return ERR_DH_AUDIO_FAILED;
     }
-    if (WaitLoadService(audioextServStatus_, AUDIOEXT_SERVICE_NAME) != DH_SUCCESS) {
+    if (WaitLoadService(AUDIOEXT_SERVICE_NAME) != DH_SUCCESS) {
         DHLOGE("Wait load provider service failed!");
         return ERR_DH_AUDIO_FAILED;
     }
@@ -89,18 +88,34 @@ int32_t DaudioHdfOperate::LoadDaudioHDFImpl()
     return DH_SUCCESS;
 }
 
-int32_t DaudioHdfOperate::WaitLoadService(const uint16_t& servStatus, const std::string& servName)
+int32_t DaudioHdfOperate::WaitLoadService(const std::string& servName)
 {
     std::unique_lock<std::mutex> lock(hdfOperateMutex_);
-    hdfOperateCon_.wait_for(lock, std::chrono::milliseconds(WAIT_TIME), [servStatus] {
-        return (servStatus == OHOS::HDI::ServiceManager::V1_0::SERVIE_STATUS_START);
-    });
+    if (servName == AUDIO_SERVICE_NAME) {
+        DHLOGD("WaitLoadService start service %s, status %hu", servName.c_str(), this->audioServStatus_.load());
+        hdfOperateCon_.wait_for(lock, std::chrono::milliseconds(WAIT_TIME), [this] {
+            return (this->audioServStatus_.load() == OHOS::HDI::ServiceManager::V1_0::SERVIE_STATUS_START);
+        });
 
-    if (servStatus != OHOS::HDI::ServiceManager::V1_0::SERVIE_STATUS_START) {
-        DHLOGE("Wait load service %{public}s failed, status %{public}d", servName.c_str(), servStatus);
-        return ERR_DH_AUDIO_FAILED;
+        if (this->audioServStatus_.load() != OHOS::HDI::ServiceManager::V1_0::SERVIE_STATUS_START) {
+            DHLOGE("Wait load service %{public}s failed, status %{public}hu", servName.c_str(),
+                this->audioServStatus_.load());
+            return ERR_DH_AUDIO_FAILED;
+        }
     }
 
+    if (servName == AUDIOEXT_SERVICE_NAME) {
+        DHLOGD("WaitLoadService start service %s, status %hu", servName.c_str(), this->audioextServStatus_.load());
+        hdfOperateCon_.wait_for(lock, std::chrono::milliseconds(WAIT_TIME), [this] {
+            return (this->audioextServStatus_.load() == OHOS::HDI::ServiceManager::V1_0::SERVIE_STATUS_START);
+        });
+
+        if (this->audioextServStatus_.load() != OHOS::HDI::ServiceManager::V1_0::SERVIE_STATUS_START) {
+            DHLOGE("Wait load service %{public}s failed, status %{public}hu", servName.c_str(),
+                this->audioextServStatus_.load());
+            return ERR_DH_AUDIO_FAILED;
+        }
+    }
     return DH_SUCCESS;
 }
 
@@ -118,8 +133,8 @@ int32_t DaudioHdfOperate::UnLoadDaudioHDFImpl()
     if (ret != HDF_SUCCESS) {
         DHLOGE("Unload device failed, ret: %{public}d", ret);
     }
-    audioServStatus_ = INVALID_VALUE;
-    audioextServStatus_ = INVALID_VALUE;
+    audioServStatus_.store(INVALID_VALUE);
+    audioextServStatus_.store(INVALID_VALUE);
     DHLOGI("UnLoad daudio hdf impl end!");
     return DH_SUCCESS;
 }