diff --git a/examples/benchmark/tls_bench.c b/examples/benchmark/tls_bench.c
index 686060aa4..c1c318def 100644
--- a/examples/benchmark/tls_bench.c
+++ b/examples/benchmark/tls_bench.c
@@ -307,7 +307,6 @@ typedef struct {
     int read_bytes;
     int read_idx;
 
-    wolfSSL_Mutex mutex;
     COND_TYPE cond;
 
     int done;
@@ -398,12 +397,12 @@ static double gettime_secs(int reset)
 /* server send callback */
 static int ServerMemSend(info_t* info, char* buf, int sz)
 {
-    THREAD_CHECK_RET(wc_LockMutex(&info->to_client.mutex));
+    THREAD_CHECK_RET(wolfSSL_CondStart(&info->to_client.cond));
 
 #ifndef BENCH_USE_NONBLOCK
     /* check for overflow */
     if (info->to_client.write_idx + sz > MEM_BUFFER_SZ) {
-        THREAD_CHECK_RET(wc_UnLockMutex(&info->to_client.mutex));
+        THREAD_CHECK_RET(wolfSSL_CondEnd(&info->to_client.cond));
         fprintf(stderr, "ServerMemSend overflow\n");
         return -1;
     }
@@ -416,9 +415,9 @@ static int ServerMemSend(info_t* info, char* buf, int sz)
     XMEMCPY(&info->to_client.buf[info->to_client.write_idx], buf, sz);
     info->to_client.write_idx += sz;
     info->to_client.write_bytes += sz;
-    THREAD_CHECK_RET(wc_UnLockMutex(&info->to_client.mutex));
 
     THREAD_CHECK_RET(wolfSSL_CondSignal(&info->to_client.cond));
+    THREAD_CHECK_RET(wolfSSL_CondEnd(&info->to_client.cond));
 
 #ifdef BENCH_USE_NONBLOCK
     if (sz == 0) {
@@ -431,14 +430,12 @@ static int ServerMemSend(info_t* info, char* buf, int sz)
 /* server recv callback */
 static int ServerMemRecv(info_t* info, char* buf, int sz)
 {
-    THREAD_CHECK_RET(wc_LockMutex(&info->to_server.mutex));
+    THREAD_CHECK_RET(wolfSSL_CondStart(&info->to_server.cond));
 
 #ifndef BENCH_USE_NONBLOCK
     while (info->to_server.write_idx - info->to_server.read_idx < sz &&
             !info->to_client.done) {
-        THREAD_CHECK_RET(wc_UnLockMutex(&info->to_server.mutex));
         THREAD_CHECK_RET(wolfSSL_CondWait(&info->to_server.cond));
-        THREAD_CHECK_RET(wc_LockMutex(&info->to_server.mutex));
     }
 #else
     if (info->to_server.write_idx - info->to_server.read_idx < sz) {
@@ -456,7 +453,7 @@ static int ServerMemRecv(info_t* info, char* buf, int sz)
         info->to_server.write_bytes = info->to_server.write_idx = 0;
     }
 
-    THREAD_CHECK_RET(wc_UnLockMutex(&info->to_server.mutex));
+    THREAD_CHECK_RET(wolfSSL_CondEnd(&info->to_server.cond));
 
     if (info->to_client.done != 0) {
         return -1;
@@ -473,14 +470,14 @@ static int ServerMemRecv(info_t* info, char* buf, int sz)
 /* client send callback */
 static int ClientMemSend(info_t* info, char* buf, int sz)
 {
-    THREAD_CHECK_RET(wc_LockMutex(&info->to_server.mutex));
+    THREAD_CHECK_RET(wolfSSL_CondStart(&info->to_server.cond));
 
 #ifndef BENCH_USE_NONBLOCK
     /* check for overflow */
     if (info->to_server.write_idx + sz > MEM_BUFFER_SZ) {
         fprintf(stderr, "ClientMemSend overflow %d %d %d\n",
             info->to_server.write_idx, sz, MEM_BUFFER_SZ);
-        THREAD_CHECK_RET(wc_UnLockMutex(&info->to_server.mutex));
+        THREAD_CHECK_RET(wolfSSL_CondEnd(&info->to_server.cond));
         return -1;
     }
 #else
@@ -493,8 +490,8 @@ static int ClientMemSend(info_t* info, char* buf, int sz)
     info->to_server.write_idx += sz;
     info->to_server.write_bytes += sz;
 
-    THREAD_CHECK_RET(wc_UnLockMutex(&info->to_server.mutex));
     THREAD_CHECK_RET(wolfSSL_CondSignal(&info->to_server.cond));
+    THREAD_CHECK_RET(wolfSSL_CondEnd(&info->to_server.cond));
 
 #ifdef BENCH_USE_NONBLOCK
     if (sz == 0) {
@@ -507,14 +504,12 @@ static int ClientMemSend(info_t* info, char* buf, int sz)
 /* client recv callback */
 static int ClientMemRecv(info_t* info, char* buf, int sz)
 {
-    THREAD_CHECK_RET(wc_LockMutex(&info->to_client.mutex));
+    THREAD_CHECK_RET(wolfSSL_CondStart(&info->to_client.cond));
 
 #ifndef BENCH_USE_NONBLOCK
     while (info->to_client.write_idx - info->to_client.read_idx < sz &&
             !info->to_server.done) {
-        THREAD_CHECK_RET(wc_UnLockMutex(&info->to_client.mutex));
         THREAD_CHECK_RET(wolfSSL_CondWait(&info->to_client.cond));
-        THREAD_CHECK_RET(wc_LockMutex(&info->to_client.mutex));
     }
 #else
     if (info->to_client.write_idx - info->to_client.read_idx < sz) {
@@ -532,7 +527,7 @@ static int ClientMemRecv(info_t* info, char* buf, int sz)
         info->to_client.write_bytes = info->to_client.write_idx = 0;
     }
 
-    THREAD_CHECK_RET(wc_UnLockMutex(&info->to_client.mutex));
+    THREAD_CHECK_RET(wolfSSL_CondEnd(&info->to_client.cond));
 
     if (info->to_server.done != 0) {
         return -1;
@@ -1054,15 +1049,13 @@ static int bench_tls_client(info_t* info)
 #if !defined(SINGLE_THREADED) && defined(WOLFSSL_DTLS)
         /* synchronize with server */
         if (info->doDTLS && !info->clientOrserverOnly) {
-            THREAD_CHECK_RET(wc_LockMutex(&info->dtls_mutex));
+            THREAD_CHECK_RET(wolfSSL_CondStart(&info->dtls_cond));
             if (info->serverReady != 1) {
-                THREAD_CHECK_RET(wc_UnLockMutex(&info->dtls_mutex));
                 THREAD_CHECK_RET(wolfSSL_CondWait(&info->dtls_cond));
-                THREAD_CHECK_RET(wc_LockMutex(&info->dtls_mutex));
             }
             /* for next loop */
             info->serverReady = 0;
-            THREAD_CHECK_RET(wc_UnLockMutex(&info->dtls_mutex));
+            THREAD_CHECK_RET(wolfSSL_CondEnd(&info->dtls_cond));
         }
 #endif
         /* perform connect */
@@ -1204,9 +1197,11 @@ static THREAD_RETURN WOLFSSL_THREAD_NO_JOIN client_thread(void* args)
 
     ret = bench_tls_client(info);
 
+    THREAD_CHECK_RET(wolfSSL_CondStart(&info->to_server.cond));
     info->to_client.done = 1;
     info->client.ret = ret;
     THREAD_CHECK_RET(wolfSSL_CondSignal(&info->to_server.cond));
+    THREAD_CHECK_RET(wolfSSL_CondEnd(&info->to_server.cond));
 
     WOLFSSL_RETURN_FROM_THREAD(NULL);
 }
@@ -1292,10 +1287,10 @@ static int SocketWaitClient(info_t* info)
         char msg[64];
 #ifndef SINGLE_THREADED
         if (!info->clientOrserverOnly) {
-            THREAD_CHECK_RET(wc_LockMutex(&info->dtls_mutex));
+            THREAD_CHECK_RET(wolfSSL_CondStart(&info->dtls_cond));
             info->serverReady = 1;
-            THREAD_CHECK_RET(wc_UnLockMutex(&info->dtls_mutex));
             THREAD_CHECK_RET(wolfSSL_CondSignal(&info->dtls_cond));
+            THREAD_CHECK_RET(wolfSSL_CondEnd(&info->dtls_cond));
         }
 #endif
         connd = (int)recvfrom(info->listenFd, (char *)msg, sizeof(msg),
@@ -1662,9 +1657,11 @@ static THREAD_RETURN WOLFSSL_THREAD_NO_JOIN server_thread(void* args)
         }
     }
 
+    THREAD_CHECK_RET(wolfSSL_CondStart(&info->to_client.cond));
     info->to_server.done = 1;
     info->server.ret = ret;
     THREAD_CHECK_RET(wolfSSL_CondSignal(&info->to_client.cond));
+    THREAD_CHECK_RET(wolfSSL_CondEnd(&info->to_client.cond));
 
     WOLFSSL_RETURN_FROM_THREAD(NULL);
 }
@@ -2127,8 +2124,6 @@ int bench_tls(void* args)
                 else {
             #if !defined(SINGLE_THREADED) && defined(WOLFSSL_THREAD_NO_JOIN)
                     info->useLocalMem = argLocalMem;
-                    THREAD_CHECK_RET(wc_InitMutex(&info->to_server.mutex));
-                    THREAD_CHECK_RET(wc_InitMutex(&info->to_client.mutex));
             #ifdef WOLFSSL_DTLS
                     THREAD_CHECK_RET(wc_InitMutex(&info->dtls_mutex));
                     THREAD_CHECK_RET(wolfSSL_CondInit(&info->dtls_cond));
diff --git a/examples/client/client.c b/examples/client/client.c
index af288fd2c..c7789e454 100644
--- a/examples/client/client.c
+++ b/examples/client/client.c
@@ -1066,6 +1066,55 @@ static int ClientRead(WOLFSSL* ssl, char* reply, int replyLen, int mustRead,
     return err;
 }
 
+static int ClientWriteRead(WOLFSSL* ssl, const char* msg, int msgSz,
+        char* reply, int replyLen, int mustRead,
+        const char* str, int exitWithRet)
+{
+    int ret = 0;
+
+    do {
+        ret = ClientWrite(ssl, msg, msgSz, str, exitWithRet);
+        if (ret != 0) {
+            if (!exitWithRet)
+                err_sys("ClientWrite failed");
+            else
+                break;
+        }
+        if (wolfSSL_dtls(ssl)) {
+            ret = tcp_select(wolfSSL_get_fd(ssl), DEFAULT_TIMEOUT_SEC);
+            if (ret == TEST_TIMEOUT) {
+                continue;
+            }
+            else if (ret == TEST_RECV_READY) {
+                /* Ready to read */
+            }
+            else {
+                LOG_ERROR("%s tcp_select error\n", str);
+                if (!exitWithRet)
+                    err_sys("tcp_select failed");
+                else
+                    ret = WOLFSSL_FATAL_ERROR;
+                break;
+            }
+        }
+        ret = ClientRead(ssl, reply, replyLen, mustRead, str, exitWithRet);
+        if (mustRead && ret != 0) {
+            if (!exitWithRet)
+                err_sys("ClientRead failed");
+            else
+                break;
+        }
+        break;
+    } while (1);
+
+    if (ret != 0) {
+        char buffer[WOLFSSL_MAX_ERROR_SZ];
+        LOG_ERROR("SSL_write%s msg error %d, %s\n", str, ret,
+                                        wolfSSL_ERR_error_string(ret, buffer));
+    }
+
+    return ret;
+}
 
 /* when adding new option, please follow the steps below: */
 /*  1. add new option message in English section          */
@@ -4195,15 +4244,8 @@ THREAD_RETURN WOLFSSL_THREAD client_test(void* args)
         wolfSSL_update_keys(ssl);
 #endif
 
-    err = ClientWrite(ssl, msg, msgSz, "", exitWithRet);
-    if (exitWithRet && (err != 0)) {
-        ((func_args*)args)->return_code = err;
-        wolfSSL_free(ssl); ssl = NULL;
-        wolfSSL_CTX_free(ctx); ctx = NULL;
-        goto exit;
-    }
-
-    err = ClientRead(ssl, reply, sizeof(reply)-1, 1, "", exitWithRet);
+    err = ClientWriteRead(ssl, msg, msgSz, reply, sizeof(reply)-1, 1, "",
+            exitWithRet);
     if (exitWithRet && (err != 0)) {
         ((func_args*)args)->return_code = err;
         wolfSSL_free(ssl); ssl = NULL;
@@ -4500,10 +4542,9 @@ THREAD_RETURN WOLFSSL_THREAD client_test(void* args)
             msgSz = (int)XSTRLEN(kResumeMsg);
             XMEMCPY(msg, kResumeMsg, msgSz);
         }
-        (void)ClientWrite(sslResume, msg, msgSz, " resume", 0);
 
-        (void)ClientRead(sslResume, reply, sizeof(reply)-1, sendGET,
-                         "Server resume: ", 0);
+        (void)ClientWriteRead(sslResume, msg, msgSz, reply, sizeof(reply)-1,
+                sendGET, " resume", 0);
 
         ret = wolfSSL_shutdown(sslResume);
         if (wc_shutdown && ret == WOLFSSL_SHUTDOWN_NOT_DONE)
diff --git a/examples/echoserver/echoserver.c b/examples/echoserver/echoserver.c
index 5f6293e0e..c6afdcb09 100644
--- a/examples/echoserver/echoserver.c
+++ b/examples/echoserver/echoserver.c
@@ -71,11 +71,11 @@ static void SignalReady(void* args, word16 port)
     /* signal ready to tcp_accept */
     func_args* server_args = (func_args*)args;
     tcp_ready* ready = server_args->signal;
-    THREAD_CHECK_RET(wc_LockMutex(&ready->mutex));
+    THREAD_CHECK_RET(wolfSSL_CondStart(&ready->cond));
     ready->ready = 1;
     ready->port = port;
-    THREAD_CHECK_RET(wc_UnLockMutex(&ready->mutex));
     THREAD_CHECK_RET(wolfSSL_CondSignal(&ready->cond));
+    THREAD_CHECK_RET(wolfSSL_CondEnd(&ready->cond));
 #endif /* NO_MAIN_DRIVER && WOLFSSL_COND */
     (void)args;
     (void)port;
diff --git a/src/crl.c b/src/crl.c
index 49048703c..20160e3d3 100644
--- a/src/crl.c
+++ b/src/crl.c
@@ -928,24 +928,20 @@ int wolfSSL_X509_STORE_add_crl(WOLFSSL_X509_STORE *store, WOLFSSL_X509_CRL *newc
 /* Signal Monitor thread is setup, save status to setup flag, 0 on success */
 static int SignalSetup(WOLFSSL_CRL* crl, int status)
 {
-    int ret;
+    int ret, condRet;
 
-    /* signal to calling thread we're setup */
-    if (wc_LockMutex(&crl->crlLock) != 0) {
-        WOLFSSL_MSG("wc_LockMutex crlLock failed");
-        return BAD_MUTEX_E;
-    }
-    crl->setup = status;
-    if (wc_UnLockMutex(&crl->crlLock) != 0) {
-        WOLFSSL_MSG("wc_UnLockMutex crlLock failed");
-        return BAD_MUTEX_E;
-    }
-
-    ret = wolfSSL_CondSignal(&crl->cond);
+    ret = wolfSSL_CondStart(&crl->cond);
     if (ret != 0)
-        return BAD_COND_E;
+        return ret;
 
-    return 0;
+    crl->setup = status;
+
+    condRet = wolfSSL_CondSignal(&crl->cond);
+    ret = wolfSSL_CondEnd(&crl->cond);
+    if (ret != 0)
+        return ret;
+
+    return condRet;
 }
 
 
@@ -1248,18 +1244,9 @@ static THREAD_RETURN WOLFSSL_THREAD DoMonitor(void* arg)
         }
     }
 
-#ifdef WOLFSSL_SMALL_STACK
-    buff = (char*)XMALLOC(8192, NULL, DYNAMIC_TYPE_TMP_BUFFER);
-    if (buff == NULL)
-        return NULL;
-#endif
 
     /* signal to calling thread we're setup */
     if (SignalSetup(crl, 1) != 0) {
-        #ifdef WOLFSSL_SMALL_STACK
-            XFREE(buff, NULL, DYNAMIC_TYPE_TMP_BUFFER);
-        #endif
-
         if (wd > 0) {
             if (inotify_rm_watch(notifyFd, wd) < 0)
                 WOLFSSL_MSG("inotify_rm_watch #1 failed in DoMonitor");
@@ -1269,6 +1256,12 @@ static THREAD_RETURN WOLFSSL_THREAD DoMonitor(void* arg)
         return NULL;
     }
 
+#ifdef WOLFSSL_SMALL_STACK
+    buff = (char*)XMALLOC(8192, NULL, DYNAMIC_TYPE_TMP_BUFFER);
+    if (buff == NULL)
+        return NULL;
+#endif
+
     for (;;) {
         fd_set readfds;
         int    result;
@@ -1489,21 +1482,13 @@ static int StartMonitorCRL(WOLFSSL_CRL* crl)
     }
 
     /* wait for setup to complete */
-    if (wc_LockMutex(&crl->crlLock) != 0) {
-        WOLFSSL_MSG("wc_LockMutex crlLock failed");
+    if (wolfSSL_CondStart(&crl->cond) != 0) {
+        WOLFSSL_MSG("wolfSSL_CondStart failed");
         return BAD_MUTEX_E;
     }
     while (crl->setup == 0) {
         int condRet;
-        if (wc_UnLockMutex(&crl->crlLock) != 0) {
-            WOLFSSL_MSG("wc_UnLockMutex crlLock failed");
-            return BAD_MUTEX_E;
-        }
         condRet = wolfSSL_CondWait(&crl->cond);
-        if (wc_LockMutex(&crl->crlLock) != 0) {
-            WOLFSSL_MSG("wc_LockMutex crlLock failed");
-            return BAD_MUTEX_E;
-        }
         if (condRet != 0) {
             ret = BAD_COND_E;
             break;
@@ -1516,8 +1501,8 @@ static int StartMonitorCRL(WOLFSSL_CRL* crl)
         WOLFSSL_MSG("DoMonitor setup failure");
         crl->tid = INVALID_THREAD_VAL;  /* thread already done */
     }
-    if (wc_UnLockMutex(&crl->crlLock) != 0) {
-        WOLFSSL_MSG("wc_UnLockMutex crlLock failed");
+    if (wolfSSL_CondEnd(&crl->cond) != 0) {
+        WOLFSSL_MSG("wolfSSL_CondEnd failed");
         return BAD_MUTEX_E;
     }
 
diff --git a/tests/utils.c b/tests/utils.c
index 14480855c..7414edb19 100644
--- a/tests/utils.c
+++ b/tests/utils.c
@@ -320,10 +320,10 @@ int test_memio_setup(struct test_memio_ctx *ctx,
 #if !defined(SINGLE_THREADED) && defined(WOLFSSL_COND)
 void signal_ready(tcp_ready* ready)
 {
-    THREAD_CHECK_RET(wc_LockMutex(&ready->mutex));
+    THREAD_CHECK_RET(wolfSSL_CondStart(&ready->cond));
     ready->ready = 1;
-    THREAD_CHECK_RET(wc_UnLockMutex(&ready->mutex));
     THREAD_CHECK_RET(wolfSSL_CondSignal(&ready->cond));
+    THREAD_CHECK_RET(wolfSSL_CondEnd(&ready->cond));
 }
 #endif
 
@@ -331,14 +331,12 @@ void wait_tcp_ready(func_args* args)
 {
 #if !defined(SINGLE_THREADED) && defined(WOLFSSL_COND)
     tcp_ready* ready = args->signal;
-    THREAD_CHECK_RET(wc_LockMutex(&ready->mutex));
+    THREAD_CHECK_RET(wolfSSL_CondStart(&ready->cond));
     if (!ready->ready) {
-        THREAD_CHECK_RET(wc_UnLockMutex(&ready->mutex));
         THREAD_CHECK_RET(wolfSSL_CondWait(&ready->cond));
-        THREAD_CHECK_RET(wc_LockMutex(&ready->mutex));
     }
     ready->ready = 0; /* reset */
-    THREAD_CHECK_RET(wc_UnLockMutex(&ready->mutex));
+    THREAD_CHECK_RET(wolfSSL_CondEnd(&ready->cond));
 #else
     /* no threading wait or single threaded */
     (void)args;
diff --git a/wolfcrypt/src/wc_port.c b/wolfcrypt/src/wc_port.c
index 13ca5799b..197c7ceff 100644
--- a/wolfcrypt/src/wc_port.c
+++ b/wolfcrypt/src/wc_port.c
@@ -3462,10 +3462,16 @@ char* mystrnstr(const char* s1, const char* s2, unsigned int n)
         if (cond == NULL)
             return BAD_FUNC_ARG;
 
-        *cond = CreateEventA(NULL, FALSE, FALSE, NULL);
-        if (*cond == NULL)
+        cond->cond = CreateEventA(NULL, FALSE, FALSE, NULL);
+        if (cond->cond == NULL)
             return MEMORY_E;
 
+        if (wc_InitMutex(&cond->mutex) != 0) {
+            if (CloseHandle(cond->cond) == 0)
+                return MEMORY_E;
+            return MEMORY_E;
+        }
+
         return 0;
     }
 
@@ -3474,20 +3480,37 @@ char* mystrnstr(const char* s1, const char* s2, unsigned int n)
         if (cond == NULL)
             return BAD_FUNC_ARG;
 
-        if (CloseHandle(*cond) == 0)
+        if (CloseHandle(cond->cond) == 0)
             return MEMORY_E;
 
         return 0;
     }
 
+    int wolfSSL_CondStart(COND_TYPE* cond)
+    {
+        if (cond == NULL)
+            return BAD_FUNC_ARG;
+
+        if (wc_LockMutex(&cond->mutex) != 0)
+            return BAD_MUTEX_E;
+
+        return 0;
+    }
+
     int wolfSSL_CondSignal(COND_TYPE* cond)
     {
         if (cond == NULL)
             return BAD_FUNC_ARG;
 
-        if (SetEvent(*cond) == 0)
+        if (wc_UnLockMutex(&cond->mutex) != 0)
+            return BAD_MUTEX_E;
+
+        if (SetEvent(cond->cond) == 0)
             return MEMORY_E;
 
+        if (wc_LockMutex(&cond->mutex) != 0)
+            return BAD_MUTEX_E;
+
         return 0;
     }
 
@@ -3496,9 +3519,26 @@ char* mystrnstr(const char* s1, const char* s2, unsigned int n)
         if (cond == NULL)
             return BAD_FUNC_ARG;
 
-        if (WaitForSingleObject(*cond, INFINITE) == WAIT_FAILED)
+        if (wc_UnLockMutex(&cond->mutex) != 0)
+            return BAD_MUTEX_E;
+
+        if (WaitForSingleObject(cond->cond, INFINITE) == WAIT_FAILED)
             return MEMORY_E;
 
+        if (wc_LockMutex(&cond->mutex) != 0)
+            return BAD_MUTEX_E;
+
+        return 0;
+    }
+
+    int wolfSSL_CondEnd(COND_TYPE* cond)
+    {
+        if (cond == NULL)
+            return BAD_FUNC_ARG;
+
+        if (wc_UnLockMutex(&cond->mutex) != 0)
+            return BAD_MUTEX_E;
+
         return 0;
     }
 #endif /* WOLFSSL_COND */
@@ -3731,42 +3771,48 @@ char* mystrnstr(const char* s1, const char* s2, unsigned int n)
         return ret;
     }
 
-    int wolfSSL_CondSignal(COND_TYPE* cond)
+    int wolfSSL_CondStart(COND_TYPE* cond)
     {
-        int ret = 0;
-
         if (cond == NULL)
             return BAD_FUNC_ARG;
 
         if (pthread_mutex_lock(&cond->mutex) != 0)
             return BAD_MUTEX_E;
 
+        return 0;
+    }
+
+    int wolfSSL_CondSignal(COND_TYPE* cond)
+    {
+        if (cond == NULL)
+            return BAD_FUNC_ARG;
+
         if (pthread_cond_signal(&cond->cond) != 0)
-            ret = MEMORY_E;
+            return MEMORY_E;
 
-        if (pthread_mutex_unlock(&cond->mutex) != 0)
-            ret = MEMORY_E;
-
-        return ret;
+        return 0;
     }
 
     int wolfSSL_CondWait(COND_TYPE* cond)
     {
-        int ret = 0;
-
         if (cond == NULL)
             return BAD_FUNC_ARG;
 
-        if (pthread_mutex_lock(&cond->mutex) != 0)
-            return BAD_MUTEX_E;
-
         if (pthread_cond_wait(&cond->cond, &cond->mutex) != 0)
-            ret = MEMORY_E;
+            return MEMORY_E;
+
+        return 0;
+    }
+
+    int wolfSSL_CondEnd(COND_TYPE* cond)
+    {
+        if (cond == NULL)
+            return BAD_FUNC_ARG;
 
         if (pthread_mutex_unlock(&cond->mutex) != 0)
-            ret = MEMORY_E;
+            return BAD_MUTEX_E;
 
-        return ret;
+        return 0;
     }
     #else /* __MACH__ */
     /* Apple style dispatch semaphore */
@@ -3780,9 +3826,15 @@ char* mystrnstr(const char* s1, const char* s2, unsigned int n)
          * dispatch_semaphore_create().  work around this by initing
          * with 0, then incrementing it afterwards.
          */
-        *cond = dispatch_semaphore_create(0);
-        if (*cond == NULL)
+        cond->cond = dispatch_semaphore_create(0);
+        if (cond->cond == NULL)
             return MEMORY_E;
+
+        if (wc_InitMutex(&cond->mutex) != 0) {
+            dispatch_release(cond->cond);
+            return MEMORY_E;
+        }
+
         return 0;
     }
 
@@ -3791,8 +3843,24 @@ char* mystrnstr(const char* s1, const char* s2, unsigned int n)
         if (cond == NULL)
             return BAD_FUNC_ARG;
 
-        dispatch_release(*cond);
-        *cond = NULL;
+        dispatch_release(cond->cond);
+        cond->cond = NULL;
+
+        if (wc_FreeMutex(&cond->mutex) != 0) {
+            return MEMORY_E;
+        }
+
+        return 0;
+    }
+
+    int wolfSSL_CondStart(COND_TYPE* cond)
+    {
+        if (cond == NULL)
+            return BAD_FUNC_ARG;
+
+        if (wc_LockMutex(&cond->mutex) != 0)
+            return BAD_MUTEX_E;
+
         return 0;
     }
 
@@ -3801,7 +3869,14 @@ char* mystrnstr(const char* s1, const char* s2, unsigned int n)
         if (cond == NULL)
             return BAD_FUNC_ARG;
 
-        dispatch_semaphore_signal(*cond);
+        if (wc_UnLockMutex(&cond->mutex) != 0)
+            return BAD_MUTEX_E;
+
+        dispatch_semaphore_signal(cond->cond);
+
+        if (wc_LockMutex(&cond->mutex) != 0)
+            return BAD_MUTEX_E;
+
         return 0;
     }
 
@@ -3810,7 +3885,25 @@ char* mystrnstr(const char* s1, const char* s2, unsigned int n)
         if (cond == NULL)
             return BAD_FUNC_ARG;
 
-        dispatch_semaphore_wait(*cond, DISPATCH_TIME_FOREVER);
+        if (wc_UnLockMutex(&cond->mutex) != 0)
+            return BAD_MUTEX_E;
+
+        dispatch_semaphore_wait(cond->cond, DISPATCH_TIME_FOREVER);
+
+        if (wc_LockMutex(&cond->mutex) != 0)
+            return BAD_MUTEX_E;
+
+        return 0;
+    }
+
+    int wolfSSL_CondEnd(COND_TYPE* cond)
+    {
+        if (cond == NULL)
+            return BAD_FUNC_ARG;
+
+        if (wc_UnLockMutex(&cond->mutex) != 0)
+            return BAD_MUTEX_E;
+
         return 0;
     }
     #endif /* __MACH__ */
diff --git a/wolfssl/test.h b/wolfssl/test.h
index e468e7bae..859e44b13 100644
--- a/wolfssl/test.h
+++ b/wolfssl/test.h
@@ -691,11 +691,9 @@ static WC_INLINE void srtp_helper_init(srtp_test_helper *srtp)
 static WC_INLINE void srtp_helper_get_ekm(srtp_test_helper *srtp,
                                           uint8_t **ekm, size_t *size)
 {
-    THREAD_CHECK_RET(wc_LockMutex(&srtp->mutex));
+    THREAD_CHECK_RET(wolfSSL_CondStart(&srtp->cond));
     if (srtp->server_srtp_ekm == NULL) {
-        THREAD_CHECK_RET(wc_UnLockMutex(&srtp->mutex));
         THREAD_CHECK_RET(wolfSSL_CondWait(&srtp->cond));
-        THREAD_CHECK_RET(wc_LockMutex(&srtp->mutex));
     }
     *ekm = srtp->server_srtp_ekm;
     *size = srtp->server_srtp_ekm_size;
@@ -703,7 +701,7 @@ static WC_INLINE void srtp_helper_get_ekm(srtp_test_helper *srtp,
     /* reset */
     srtp->server_srtp_ekm = NULL;
     srtp->server_srtp_ekm_size = 0;
-    THREAD_CHECK_RET(wc_UnLockMutex(&srtp->mutex));
+    THREAD_CHECK_RET(wolfSSL_CondEnd(&srtp->cond));
 }
 
 /**
@@ -720,11 +718,11 @@ static WC_INLINE void srtp_helper_get_ekm(srtp_test_helper *srtp,
 static WC_INLINE void srtp_helper_set_ekm(srtp_test_helper *srtp,
                                           uint8_t *ekm, size_t size)
 {
-    THREAD_CHECK_RET(wc_LockMutex(&srtp->mutex));
+    THREAD_CHECK_RET(wolfSSL_CondStart(&srtp->cond));
     srtp->server_srtp_ekm_size = size;
     srtp->server_srtp_ekm = ekm;
-    THREAD_CHECK_RET(wc_UnLockMutex(&srtp->mutex));
     THREAD_CHECK_RET(wolfSSL_CondSignal(&srtp->cond));
+    THREAD_CHECK_RET(wolfSSL_CondEnd(&srtp->cond));
 }
 
 static WC_INLINE void srtp_helper_free(srtp_test_helper *srtp)
@@ -2218,13 +2216,15 @@ static WC_INLINE void udp_accept(SOCKET_T* sockfd, SOCKET_T* clientfd,
     if (args != NULL && args->signal != NULL) {
 #ifndef SINGLE_THREADED
         tcp_ready* ready = args->signal;
-        THREAD_CHECK_RET(wc_LockMutex(&ready->mutex));
+    #ifdef WOLFSSL_COND
+        THREAD_CHECK_RET(wolfSSL_CondStart(&ready->cond));
+    #endif
         ready->ready = 1;
         ready->port = port;
-        THREAD_CHECK_RET(wc_UnLockMutex(&ready->mutex));
     #ifdef WOLFSSL_COND
         /* signal ready to accept data */
         THREAD_CHECK_RET(wolfSSL_CondSignal(&ready->cond));
+        THREAD_CHECK_RET(wolfSSL_CondEnd(&ready->cond));
     #endif
 #endif /* !SINGLE_THREADED */
     }
@@ -2257,12 +2257,14 @@ static WC_INLINE void tcp_accept(SOCKET_T* sockfd, SOCKET_T* clientfd,
         if (args)
             ready = args->signal;
         if (ready) {
-            THREAD_CHECK_RET(wc_LockMutex(&ready->mutex));
+        #ifdef WOLFSSL_COND
+            THREAD_CHECK_RET(wolfSSL_CondStart(&ready->cond));
+        #endif
             ready->ready = 1;
             ready->port = port;
-            THREAD_CHECK_RET(wc_UnLockMutex(&ready->mutex));
         #ifdef WOLFSSL_COND
             THREAD_CHECK_RET(wolfSSL_CondSignal(&ready->cond));
+            THREAD_CHECK_RET(wolfSSL_CondEnd(&ready->cond));
         #endif
         }
 #endif /* !SINGLE_THREADED */
diff --git a/wolfssl/wolfcrypt/types.h b/wolfssl/wolfcrypt/types.h
index 3a6b8a7af..53b192d96 100644
--- a/wolfssl/wolfcrypt/types.h
+++ b/wolfssl/wolfcrypt/types.h
@@ -1388,7 +1388,10 @@ typedef struct w64wrapper {
             } COND_TYPE;
         #else
             #include <dispatch/dispatch.h>
-            typedef dispatch_semaphore_t COND_TYPE;
+            typedef struct COND_TYPE {
+                wolfSSL_Mutex mutex;
+                dispatch_semaphore_t cond;
+            } COND_TYPE;
         #endif
         typedef void*         THREAD_RETURN;
         typedef pthread_t     THREAD_TYPE;
@@ -1404,7 +1407,10 @@ typedef struct w64wrapper {
     #elif defined(_MSC_VER)
         typedef unsigned      THREAD_RETURN;
         typedef uintptr_t     THREAD_TYPE;
-        typedef HANDLE        COND_TYPE;
+        typedef struct COND_TYPE {
+            wolfSSL_Mutex mutex;
+            HANDLE cond;
+        } COND_TYPE;
         #define WOLFSSL_COND
         #define INVALID_THREAD_VAL ((THREAD_TYPE)(INVALID_HANDLE_VALUE))
         #define WOLFSSL_THREAD __stdcall
@@ -1482,6 +1488,8 @@ typedef struct w64wrapper {
             WOLFSSL_API int wolfSSL_CondFree(COND_TYPE* cond);
             WOLFSSL_API int wolfSSL_CondSignal(COND_TYPE* cond);
             WOLFSSL_API int wolfSSL_CondWait(COND_TYPE* cond);
+            WOLFSSL_API int wolfSSL_CondStart(COND_TYPE* cond);
+            WOLFSSL_API int wolfSSL_CondEnd(COND_TYPE* cond);
         #endif
     #else
         #define WOLFSSL_RETURN_FROM_THREAD(x) return (THREAD_RETURN)(x)