diff --git a/lib/posix/options/key.c b/lib/posix/options/key.c
index aa87e93..5e68381 100644
--- a/lib/posix/options/key.c
+++ b/lib/posix/options/key.c
@@ -11,7 +11,6 @@
 #include <zephyr/posix/pthread.h>
 #include <zephyr/sys/bitarray.h>
 #include <zephyr/sys/__assert.h>
-#include <zephyr/sys/sem.h>
 
 struct pthread_key_data {
 	sys_snode_t node;
@@ -20,7 +19,7 @@
 
 LOG_MODULE_REGISTER(pthread_key, CONFIG_PTHREAD_KEY_LOG_LEVEL);
 
-static SYS_SEM_DEFINE(pthread_key_lock, 1, 1);
+static struct k_spinlock pthread_key_lock;
 
 /* This is non-standard (i.e. an implementation detail) */
 #define PTHREAD_KEY_INITIALIZER (-1)
@@ -129,40 +128,42 @@
 int pthread_key_delete(pthread_key_t key)
 {
 	size_t bit;
-	int ret = 0;
-	pthread_key_obj *key_obj = NULL;
+	__unused int ret;
+	pthread_key_obj *key_obj;
 	struct pthread_key_data *key_data;
 	sys_snode_t *node_l, *next_node_l;
+	k_spinlock_key_t key_key;
 
-	SYS_SEM_LOCK(&pthread_key_lock) {
-		key_obj = get_posix_key(key);
-		if (key_obj == NULL) {
-			ret = EINVAL;
-			SYS_SEM_LOCK_BREAK;
-		}
+	key_key = k_spin_lock(&pthread_key_lock);
 
-		/* Delete thread-specific elements associated with the key */
-		SYS_SLIST_FOR_EACH_NODE_SAFE(&(key_obj->key_data_l), node_l, next_node_l) {
-
-			/* Remove the object from the list key_data_l */
-			key_data = (struct pthread_key_data *)sys_slist_get(&(key_obj->key_data_l));
-
-			/* Deallocate the object's memory */
-			k_free((void *)key_data);
-			LOG_DBG("Freed key data %p for key %x in thread %x", key_data, key,
-				pthread_self());
-		}
-
-		bit = posix_key_to_offset(key_obj);
-		ret = sys_bitarray_free(&posix_key_bitarray, 1, bit);
-		__ASSERT_NO_MSG(ret == 0);
+	key_obj = get_posix_key(key);
+	if (key_obj == NULL) {
+		k_spin_unlock(&pthread_key_lock, key_key);
+		return EINVAL;
 	}
 
-	if (ret == 0) {
-		LOG_DBG("Deleted key %p (%x)", key_obj, key);
+	/* Delete thread-specific elements associated with the key */
+	SYS_SLIST_FOR_EACH_NODE_SAFE(&(key_obj->key_data_l),
+			node_l, next_node_l) {
+
+		/* Remove the object from the list key_data_l */
+		key_data = (struct pthread_key_data *)
+			sys_slist_get(&(key_obj->key_data_l));
+
+		/* Deallocate the object's memory */
+		k_free((void *)key_data);
+		LOG_DBG("Freed key data %p for key %x in thread %x", key_data, key, pthread_self());
 	}
 
-	return ret;
+	bit = posix_key_to_offset(key_obj);
+	ret = sys_bitarray_free(&posix_key_bitarray, 1, bit);
+	__ASSERT_NO_MSG(ret == 0);
+
+	k_spin_unlock(&pthread_key_lock, key_key);
+
+	LOG_DBG("Deleted key %p (%x)", key_obj, key);
+
+	return 0;
 }
 
 /**
@@ -172,10 +173,12 @@
  */
 int pthread_setspecific(pthread_key_t key, const void *value)
 {
-	pthread_key_obj *key_obj = NULL;
+	pthread_key_obj *key_obj;
 	struct posix_thread *thread;
 	struct pthread_key_data *key_data;
-	sys_snode_t *node_l = NULL;
+	pthread_thread_data *thread_spec_data;
+	k_spinlock_key_t key_key;
+	sys_snode_t *node_l;
 	int retval = 0;
 
 	thread = to_posix_thread(pthread_self());
@@ -187,37 +190,37 @@
 	 * If the key is already in the list, re-assign its value.
 	 * Else add the key to the thread's list.
 	 */
-	SYS_SEM_LOCK(&pthread_key_lock) {
-		key_obj = get_posix_key(key);
-		if (key_obj == NULL) {
-			retval = EINVAL;
-			SYS_SEM_LOCK_BREAK;
+	key_key = k_spin_lock(&pthread_key_lock);
+
+	key_obj = get_posix_key(key);
+	if (key_obj == NULL) {
+		k_spin_unlock(&pthread_key_lock, key_key);
+		return EINVAL;
+	}
+
+	SYS_SLIST_FOR_EACH_NODE(&(thread->key_list), node_l) {
+
+		thread_spec_data = (pthread_thread_data *)node_l;
+
+		if (thread_spec_data->key == key_obj) {
+
+			/* Key is already present so
+			 * associate thread specific data
+			 */
+			thread_spec_data->spec_data = (void *)value;
+			LOG_DBG("Paired key %x to value %p for thread %x", key, value,
+				pthread_self());
+			goto out;
 		}
+	}
 
-		SYS_SLIST_FOR_EACH_NODE(&(thread->key_list), node_l) {
-			pthread_thread_data *thread_spec_data = (pthread_thread_data *)node_l;
-
-			if (thread_spec_data->key == key_obj) {
-				/* Key is already present so associate thread specific data */
-				thread_spec_data->spec_data = (void *)value;
-				LOG_DBG("Paired key %x to value %p for thread %x", key, value,
-					pthread_self());
-				break;
-			}
-		}
-
-		if (node_l != NULL) {
-			/* Key is already present, so we are done */
-			SYS_SEM_LOCK_BREAK;
-		}
-
-		/* Key and data need to be added */
+	if (node_l == NULL) {
 		key_data = k_malloc(sizeof(struct pthread_key_data));
 
 		if (key_data == NULL) {
 			LOG_DBG("Failed to allocate key data for key %x", key);
 			retval = ENOMEM;
-			SYS_SEM_LOCK_BREAK;
+			goto out;
 		}
 
 		LOG_DBG("Allocated key data %p for key %x in thread %x", key_data, key,
@@ -236,6 +239,9 @@
 		LOG_DBG("Paired key %x to value %p for thread %x", key, value, pthread_self());
 	}
 
+out:
+	k_spin_unlock(&pthread_key_lock, key_key);
+
 	return retval;
 }
 
@@ -251,30 +257,33 @@
 	pthread_thread_data *thread_spec_data;
 	void *value = NULL;
 	sys_snode_t *node_l;
+	k_spinlock_key_t key_key;
 
 	thread = to_posix_thread(pthread_self());
 	if (thread == NULL) {
 		return NULL;
 	}
 
-	SYS_SEM_LOCK(&pthread_key_lock) {
-		key_obj = get_posix_key(key);
-		if (key_obj == NULL) {
-			value = NULL;
-			SYS_SEM_LOCK_BREAK;
-		}
+	key_key = k_spin_lock(&pthread_key_lock);
 
-		/* Traverse the list of keys set by the thread, looking for key */
+	key_obj = get_posix_key(key);
+	if (key_obj == NULL) {
+		k_spin_unlock(&pthread_key_lock, key_key);
+		return NULL;
+	}
 
-		SYS_SLIST_FOR_EACH_NODE(&(thread->key_list), node_l) {
-			thread_spec_data = (pthread_thread_data *)node_l;
-			if (thread_spec_data->key == key_obj) {
-				/* Key is present, so get the set thread data */
-				value = thread_spec_data->spec_data;
-				break;
-			}
+	/* Traverse the list of keys set by the thread, looking for key */
+
+	SYS_SLIST_FOR_EACH_NODE(&(thread->key_list), node_l) {
+		thread_spec_data = (pthread_thread_data *)node_l;
+		if (thread_spec_data->key == key_obj) {
+			/* Key is present, so get the set thread data */
+			value = thread_spec_data->spec_data;
+			break;
 		}
 	}
 
+	k_spin_unlock(&pthread_key_lock, key_key);
+
 	return value;
 }
diff --git a/lib/posix/options/mutex.c b/lib/posix/options/mutex.c
index 4676083..62953e2 100644
--- a/lib/posix/options/mutex.c
+++ b/lib/posix/options/mutex.c
@@ -12,11 +12,10 @@
 #include <zephyr/logging/log.h>
 #include <zephyr/posix/pthread.h>
 #include <zephyr/sys/bitarray.h>
-#include <zephyr/sys/sem.h>
 
 LOG_MODULE_REGISTER(pthread_mutex, CONFIG_PTHREAD_MUTEX_LOG_LEVEL);
 
-static SYS_SEM_DEFINE(lock, 1, 1);
+static struct k_spinlock pthread_mutex_spinlock;
 
 int64_t timespec_to_timeoutms(const struct timespec *abstime);
 
@@ -107,41 +106,35 @@
 
 static int acquire_mutex(pthread_mutex_t *mu, k_timeout_t timeout)
 {
+	int type;
+	size_t bit;
 	int ret = 0;
-	int type = -1;
-	size_t bit = -1;
-	size_t lock_count = -1;
-	struct k_mutex *m = NULL;
-	struct k_thread *owner = NULL;
+	struct k_mutex *m;
+	k_spinlock_key_t key;
 
-	SYS_SEM_LOCK(&lock) {
-		m = to_posix_mutex(mu);
-		if (m == NULL) {
-			ret = EINVAL;
-			SYS_SEM_LOCK_BREAK;
-		}
+	key = k_spin_lock(&pthread_mutex_spinlock);
 
-		LOG_DBG("Locking mutex %p with timeout %llx", m, timeout.ticks);
-
-		bit = posix_mutex_to_offset(m);
-		type = posix_mutex_type[bit];
-		owner = m->owner;
-		lock_count = m->lock_count;
+	m = to_posix_mutex(mu);
+	if (m == NULL) {
+		k_spin_unlock(&pthread_mutex_spinlock, key);
+		return EINVAL;
 	}
 
-	if (ret != 0) {
-		goto handle_error;
-	}
+	LOG_DBG("Locking mutex %p with timeout %llx", m, timeout.ticks);
 
-	if (owner == k_current_get()) {
+	bit = posix_mutex_to_offset(m);
+	type = posix_mutex_type[bit];
+
+	if (m->owner == k_current_get()) {
 		switch (type) {
 		case PTHREAD_MUTEX_NORMAL:
 			if (K_TIMEOUT_EQ(timeout, K_NO_WAIT)) {
+				k_spin_unlock(&pthread_mutex_spinlock, key);
 				LOG_DBG("Timeout locking mutex %p", m);
-				ret = EBUSY;
-				break;
+				return EBUSY;
 			}
 			/* On most POSIX systems, this usually results in an infinite loop */
+			k_spin_unlock(&pthread_mutex_spinlock, key);
 			LOG_DBG("Attempt to relock non-recursive mutex %p", m);
 			do {
 				(void)k_sleep(K_FOREVER);
@@ -149,7 +142,7 @@
 			CODE_UNREACHABLE;
 			break;
 		case PTHREAD_MUTEX_RECURSIVE:
-			if (lock_count >= MUTEX_MAX_REC_LOCK) {
+			if (m->lock_count >= MUTEX_MAX_REC_LOCK) {
 				LOG_DBG("Mutex %p locked recursively too many times", m);
 				ret = EAGAIN;
 			}
@@ -164,6 +157,7 @@
 			break;
 		}
 	}
+	k_spin_unlock(&pthread_mutex_spinlock, key);
 
 	if (ret == 0) {
 		ret = k_mutex_lock(m, timeout);
@@ -177,7 +171,6 @@
 		}
 	}
 
-handle_error:
 	if (ret < 0) {
 		LOG_DBG("k_mutex_unlock() failed: %d", ret);
 		ret = -ret;
diff --git a/lib/posix/options/pthread.c b/lib/posix/options/pthread.c
index bd9c85e..a46cde7 100644
--- a/lib/posix/options/pthread.c
+++ b/lib/posix/options/pthread.c
@@ -16,7 +16,6 @@
 #include <zephyr/sys/atomic.h>
 #include <zephyr/posix/pthread.h>
 #include <zephyr/posix/unistd.h>
-#include <zephyr/sys/sem.h>
 #include <zephyr/sys/slist.h>
 #include <zephyr/sys/util.h>
 
@@ -88,7 +87,7 @@
 	SYS_DLIST_STATIC_INIT(&posix_thread_q[POSIX_THREAD_DONE_Q]),
 };
 static struct posix_thread posix_thread_pool[CONFIG_MAX_PTHREAD_COUNT];
-static SYS_SEM_DEFINE(pthread_pool_lock, 1, 1);
+static struct k_spinlock pthread_pool_lock;
 static int pthread_concurrency;
 
 static inline void posix_thread_q_set(struct posix_thread *t, enum posix_thread_qid qid)
@@ -220,7 +219,7 @@
 	struct posix_thread *t = NULL;
 	struct __pthread_cleanup *const c = (struct __pthread_cleanup *)cleanup;
 
-	SYS_SEM_LOCK(&pthread_pool_lock) {
+	K_SPINLOCK(&pthread_pool_lock) {
 		t = to_posix_thread(pthread_self());
 		BUILD_ASSERT(3 * sizeof(void *) == sizeof(*c));
 		__ASSERT_NO_MSG(t != NULL);
@@ -237,7 +236,7 @@
 	struct __pthread_cleanup *c = NULL;
 	struct posix_thread *t = NULL;
 
-	SYS_SEM_LOCK(&pthread_pool_lock) {
+	K_SPINLOCK(&pthread_pool_lock) {
 		t = to_posix_thread(pthread_self());
 		__ASSERT_NO_MSG(t != NULL);
 		node = sys_slist_get(&t->cleanup_list);
@@ -477,6 +476,7 @@
 static void posix_thread_finalize(struct posix_thread *t, void *retval)
 {
 	sys_snode_t *node_l;
+	k_spinlock_key_t key;
 	pthread_key_obj *key_obj;
 	pthread_thread_data *thread_spec_data;
 
@@ -491,11 +491,11 @@
 	}
 
 	/* move thread from run_q to done_q */
-	SYS_SEM_LOCK(&pthread_pool_lock) {
-		sys_dlist_remove(&t->q_node);
-		posix_thread_q_set(t, POSIX_THREAD_DONE_Q);
-		t->retval = retval;
-	}
+	key = k_spin_lock(&pthread_pool_lock);
+	sys_dlist_remove(&t->q_node);
+	posix_thread_q_set(t, POSIX_THREAD_DONE_Q);
+	t->retval = retval;
+	k_spin_unlock(&pthread_pool_lock, key);
 
 	/* trigger recycle work */
 	(void)k_work_schedule(&posix_thread_recycle_work, K_MSEC(CONFIG_PTHREAD_RECYCLER_DELAY_MS));
@@ -526,22 +526,22 @@
 
 static void posix_thread_recycle(void)
 {
+	k_spinlock_key_t key;
 	struct posix_thread *t;
 	struct posix_thread *safe_t;
 	sys_dlist_t recyclables = SYS_DLIST_STATIC_INIT(&recyclables);
 
-	SYS_SEM_LOCK(&pthread_pool_lock) {
-		SYS_DLIST_FOR_EACH_CONTAINER_SAFE(&posix_thread_q[POSIX_THREAD_DONE_Q], t, safe_t,
-						  q_node) {
-			if (t->attr.detachstate == PTHREAD_CREATE_JOINABLE) {
-				/* thread has not been joined yet */
-				continue;
-			}
-
-			sys_dlist_remove(&t->q_node);
-			sys_dlist_append(&recyclables, &t->q_node);
+	key = k_spin_lock(&pthread_pool_lock);
+	SYS_DLIST_FOR_EACH_CONTAINER_SAFE(&posix_thread_q[POSIX_THREAD_DONE_Q], t, safe_t, q_node) {
+		if (t->attr.detachstate == PTHREAD_CREATE_JOINABLE) {
+			/* thread has not been joined yet */
+			continue;
 		}
+
+		sys_dlist_remove(&t->q_node);
+		sys_dlist_append(&recyclables, &t->q_node);
 	}
+	k_spin_unlock(&pthread_pool_lock, key);
 
 	if (sys_dlist_is_empty(&recyclables)) {
 		return;
@@ -557,12 +557,12 @@
 		}
 	}
 
-	SYS_SEM_LOCK(&pthread_pool_lock) {
-		while (!sys_dlist_is_empty(&recyclables)) {
-			t = CONTAINER_OF(sys_dlist_get(&recyclables), struct posix_thread, q_node);
-			posix_thread_q_set(t, POSIX_THREAD_READY_Q);
-		}
+	key = k_spin_lock(&pthread_pool_lock);
+	while (!sys_dlist_is_empty(&recyclables)) {
+		t = CONTAINER_OF(sys_dlist_get(&recyclables), struct posix_thread, q_node);
+		posix_thread_q_set(t, POSIX_THREAD_READY_Q);
 	}
+	k_spin_unlock(&pthread_pool_lock, key);
 }
 
 /**
@@ -587,7 +587,7 @@
 	/* reclaim resources greedily */
 	posix_thread_recycle();
 
-	SYS_SEM_LOCK(&pthread_pool_lock) {
+	K_SPINLOCK(&pthread_pool_lock) {
 		if (!sys_dlist_is_empty(&posix_thread_q[POSIX_THREAD_READY_Q])) {
 			t = CONTAINER_OF(sys_dlist_get(&posix_thread_q[POSIX_THREAD_READY_Q]),
 					 struct posix_thread, q_node);
@@ -603,7 +603,7 @@
 		err = pthread_barrier_init(&barrier, NULL, 2);
 		if (err != 0) {
 			/* cannot allocate barrier. move thread back to ready_q */
-			SYS_SEM_LOCK(&pthread_pool_lock) {
+			K_SPINLOCK(&pthread_pool_lock) {
 				sys_dlist_remove(&t->q_node);
 				posix_thread_q_set(t, POSIX_THREAD_READY_Q);
 			}
@@ -625,7 +625,7 @@
 		}
 		if (err != 0) {
 			/* cannot allocate pthread attributes (e.g. stack) */
-			SYS_SEM_LOCK(&pthread_pool_lock) {
+			K_SPINLOCK(&pthread_pool_lock) {
 				sys_dlist_remove(&t->q_node);
 				posix_thread_q_set(t, POSIX_THREAD_READY_Q);
 			}
@@ -673,7 +673,7 @@
 {
 	int ret = 0;
 
-	SYS_SEM_LOCK(&pthread_pool_lock) {
+	K_SPINLOCK(&pthread_pool_lock) {
 		ret = pthread_concurrency;
 	}
 
@@ -690,7 +690,7 @@
 		return EAGAIN;
 	}
 
-	SYS_SEM_LOCK(&pthread_pool_lock) {
+	K_SPINLOCK(&pthread_pool_lock) {
 		pthread_concurrency = new_level;
 	}
 
@@ -705,8 +705,8 @@
 int pthread_setcancelstate(int state, int *oldstate)
 {
 	int ret = 0;
+	struct posix_thread *t;
 	bool cancel_pending = false;
-	struct posix_thread *t = NULL;
 	bool cancel_type = PTHREAD_CANCEL_ENABLE;
 
 	if (state != PTHREAD_CANCEL_ENABLE && state != PTHREAD_CANCEL_DISABLE) {
@@ -714,11 +714,11 @@
 		return EINVAL;
 	}
 
-	SYS_SEM_LOCK(&pthread_pool_lock) {
+	K_SPINLOCK(&pthread_pool_lock) {
 		t = to_posix_thread(pthread_self());
 		if (t == NULL) {
 			ret = EINVAL;
-			SYS_SEM_LOCK_BREAK;
+			K_SPINLOCK_BREAK;
 		}
 
 		if (oldstate != NULL) {
@@ -753,11 +753,11 @@
 		return EINVAL;
 	}
 
-	SYS_SEM_LOCK(&pthread_pool_lock) {
+	K_SPINLOCK(&pthread_pool_lock) {
 		t = to_posix_thread(pthread_self());
 		if (t == NULL) {
 			ret = EINVAL;
-			SYS_SEM_LOCK_BREAK;
+			K_SPINLOCK_BREAK;
 		}
 
 		if (oldtype != NULL) {
@@ -776,16 +776,16 @@
  */
 void pthread_testcancel(void)
 {
+	struct posix_thread *t;
 	bool cancel_pended = false;
-	struct posix_thread *t = NULL;
 
-	SYS_SEM_LOCK(&pthread_pool_lock) {
+	K_SPINLOCK(&pthread_pool_lock) {
 		t = to_posix_thread(pthread_self());
 		if (t == NULL) {
-			SYS_SEM_LOCK_BREAK;
+			K_SPINLOCK_BREAK;
 		}
 		if (t->attr.cancelstate != PTHREAD_CANCEL_ENABLE) {
-			SYS_SEM_LOCK_BREAK;
+			K_SPINLOCK_BREAK;
 		}
 		if (t->attr.cancelpending) {
 			cancel_pended = true;
@@ -810,17 +810,17 @@
 	bool cancel_type = PTHREAD_CANCEL_DEFERRED;
 	struct posix_thread *t = NULL;
 
-	SYS_SEM_LOCK(&pthread_pool_lock) {
+	K_SPINLOCK(&pthread_pool_lock) {
 		t = to_posix_thread(pthread);
 		if (t == NULL) {
 			ret = ESRCH;
-			SYS_SEM_LOCK_BREAK;
+			K_SPINLOCK_BREAK;
 		}
 
 		if (!__attr_is_initialized(&t->attr)) {
 			/* thread has already terminated */
 			ret = ESRCH;
-			SYS_SEM_LOCK_BREAK;
+			K_SPINLOCK_BREAK;
 		}
 
 		t->attr.cancelpending = true;
@@ -852,11 +852,11 @@
 		return EINVAL;
 	}
 
-	SYS_SEM_LOCK(&pthread_pool_lock) {
+	K_SPINLOCK(&pthread_pool_lock) {
 		t = to_posix_thread(pthread);
 		if (t == NULL) {
 			ret = ESRCH;
-			SYS_SEM_LOCK_BREAK;
+			K_SPINLOCK_BREAK;
 		}
 
 		new_prio = posix_to_zephyr_priority(param->sched_priority, policy);
@@ -892,11 +892,11 @@
 		return EINVAL;
 	}
 
-	SYS_SEM_LOCK(&pthread_pool_lock) {
+	K_SPINLOCK(&pthread_pool_lock) {
 		t = to_posix_thread(thread);
 		if (t == NULL) {
 			ret = ESRCH;
-			SYS_SEM_LOCK_BREAK;
+			K_SPINLOCK_BREAK;
 		}
 
 		new_prio = posix_to_zephyr_priority(prio, policy);
@@ -965,16 +965,16 @@
 		return EINVAL;
 	}
 
-	SYS_SEM_LOCK(&pthread_pool_lock) {
+	K_SPINLOCK(&pthread_pool_lock) {
 		t = to_posix_thread(pthread);
 		if (t == NULL) {
 			ret = ESRCH;
-			SYS_SEM_LOCK_BREAK;
+			K_SPINLOCK_BREAK;
 		}
 
 		if (!__attr_is_initialized(&t->attr)) {
 			ret = ESRCH;
-			SYS_SEM_LOCK_BREAK;
+			K_SPINLOCK_BREAK;
 		}
 
 		param->sched_priority =
@@ -999,7 +999,7 @@
 		return EINVAL;
 	}
 
-	SYS_SEM_LOCK(&pthread_pool_lock) {
+	K_SPINLOCK(&pthread_pool_lock) {
 		if (!_once->flag) {
 			run_init_func = true;
 			_once->flag = true;
@@ -1023,10 +1023,10 @@
 {
 	struct posix_thread *self = NULL;
 
-	SYS_SEM_LOCK(&pthread_pool_lock) {
+	K_SPINLOCK(&pthread_pool_lock) {
 		self = to_posix_thread(pthread_self());
 		if (self == NULL) {
-			SYS_SEM_LOCK_BREAK;
+			K_SPINLOCK_BREAK;
 		}
 
 		/* Mark a thread as cancellable before exiting */
@@ -1060,11 +1060,11 @@
 		return EDEADLK;
 	}
 
-	SYS_SEM_LOCK(&pthread_pool_lock) {
+	K_SPINLOCK(&pthread_pool_lock) {
 		t = to_posix_thread(pthread);
 		if (t == NULL) {
 			ret = ESRCH;
-			SYS_SEM_LOCK_BREAK;
+			K_SPINLOCK_BREAK;
 		}
 
 		LOG_DBG("Pthread %p joining..", &t->thread);
@@ -1072,12 +1072,12 @@
 		if (t->attr.detachstate != PTHREAD_CREATE_JOINABLE) {
 			/* undefined behaviour */
 			ret = EINVAL;
-			SYS_SEM_LOCK_BREAK;
+			K_SPINLOCK_BREAK;
 		}
 
 		if (posix_thread_q_get(t) == POSIX_THREAD_READY_Q) {
 			ret = ESRCH;
-			SYS_SEM_LOCK_BREAK;
+			K_SPINLOCK_BREAK;
 		}
 
 		/*
@@ -1124,18 +1124,18 @@
 	int ret = 0;
 	struct posix_thread *t;
 
-	SYS_SEM_LOCK(&pthread_pool_lock) {
+	K_SPINLOCK(&pthread_pool_lock) {
 		t = to_posix_thread(pthread);
 		if (t == NULL) {
 			ret = ESRCH;
-			SYS_SEM_LOCK_BREAK;
+			K_SPINLOCK_BREAK;
 		}
 
 		if (posix_thread_q_get(t) == POSIX_THREAD_READY_Q ||
 		    t->attr.detachstate != PTHREAD_CREATE_JOINABLE) {
 			LOG_DBG("Pthread %p cannot be detached", &t->thread);
 			ret = EINVAL;
-			SYS_SEM_LOCK_BREAK;
+			K_SPINLOCK_BREAK;
 		}
 
 		t->attr.detachstate = PTHREAD_CREATE_DETACHED;
@@ -1437,11 +1437,11 @@
 		return EINVAL;
 	}
 
-	SYS_SEM_LOCK(&pthread_pool_lock) {
+	K_SPINLOCK(&pthread_pool_lock) {
 		t = to_posix_thread(pthread_self());
 		if (t == NULL) {
 			ret = ESRCH;
-			SYS_SEM_LOCK_BREAK;
+			K_SPINLOCK_BREAK;
 		}
 
 		if (oset != NULL) {
@@ -1449,7 +1449,7 @@
 		}
 
 		if (set == NULL) {
-			SYS_SEM_LOCK_BREAK;
+			K_SPINLOCK_BREAK;
 		}
 
 		switch (how) {
diff --git a/lib/posix/options/rwlock.c b/lib/posix/options/rwlock.c
index 3d6752a..b8a91a0 100644
--- a/lib/posix/options/rwlock.c
+++ b/lib/posix/options/rwlock.c
@@ -11,7 +11,6 @@
 #include <zephyr/logging/log.h>
 #include <zephyr/posix/pthread.h>
 #include <zephyr/sys/bitarray.h>
-#include <zephyr/sys/sem.h>
 
 #define CONCURRENT_READER_LIMIT  (CONFIG_MAX_PTHREAD_COUNT + 1)
 
@@ -33,7 +32,7 @@
 
 LOG_MODULE_REGISTER(pthread_rwlock, CONFIG_PTHREAD_RWLOCK_LOG_LEVEL);
 
-static SYS_SEM_DEFINE(posix_rwlock_lock, 1, 1);
+static struct k_spinlock posix_rwlock_spinlock;
 
 static struct posix_rwlock posix_rwlock_pool[CONFIG_MAX_PTHREAD_RWLOCK_COUNT];
 SYS_BITARRAY_DEFINE_STATIC(posix_rwlock_bitarray, CONFIG_MAX_PTHREAD_RWLOCK_COUNT);
@@ -151,10 +150,10 @@
 		return EINVAL;
 	}
 
-	SYS_SEM_LOCK(&posix_rwlock_lock) {
+	K_SPINLOCK(&posix_rwlock_spinlock) {
 		if (rwl->wr_owner != NULL) {
 			ret = EBUSY;
-			SYS_SEM_LOCK_BREAK;
+			K_SPINLOCK_BREAK;
 		}
 
 		bit = posix_rwlock_to_offset(rwl);