Zephyr message queue with or without semaphore + bonus yielding question

Question

Consider the following scenario: reading messages from UART and then interpreting them in a lower priority thread. One way or doing it would be to create a message queue with n items and add the incoming lines. In the same time give a semaphore (with the maximum value of n). The lower priority thread takes the semaphore and a message out of the queue to processes it:

K_MSGQ_DEFINE(uartRxMsgQ, uartFrameSize, uartMsgQSize, 4);
K_SEM_DEFINE(messageSemaphore, 0, uartMsgQSize);

static void uart_isr_handler(const struct device *dev, struct uart_event *event, void *user_data) {
    switch (event->type) {
        case UART_RX_RDY:
            for (size_t n = event->data.rx.offset; n < event->data.rx.offset + event->data.rx.len; n++) {
                if (*(event->data.rx.buf + n) == '\n' || *(event->data.rx.buf + n) == '\r') {
                    if (uartFramePos > 0) {
                        uartFrameBuff[uartFramePos] = 0;

                        if (k_msgq_put(&uartRxMsgQ, &uartFrameBuff, K_NO_WAIT) == 0) 
                            k_sem_give(&messageSemaphore);
                        else
                            LOG_ERR("Uart RX message queue full");

                        uartFramePos = 0;
                    }
                } else if (uartFramePos < uartFrameSize - 1) uartFrameBuff[uartFramePos++] = event->data.rx.buf[n];
            }
            break;
    }
}

void msg_processor_thread() {
    static uint8_t incomingMsg[uartFrameSize];

    while (1) {
        k_sem_take(&messageSemaphore, K_FOREVER);
        k_msgq_get(&uartRxMsgQ, &incomingMsg, K_FOREVER);
        LOG_INF("RX: %s", incomingMsg);
    }
}

So if uartMsgQSize = 10; the semaphore indicates the number of messages in the queue. And if the queue is empty, take will block and the thread is happy.

But how about k_msgq_get(&uartRxMsgQ, &incomingMsg, K_FOREVER);? For this specific example would it not block just as well as trying to take the semaphore? Are there any benefits using semaphores in this case? Is there a difference (other than the overhead of managing the semaphore) at all?

Bonus question: Does the while loop in the msg_processor_thread() need to yield? My interpretation of the situation is that with no yield this thread can possibly starve all other threads until it has processed all the messages in the queue. Once it becomes active it will process all the messages until the point it can not take the semaphore anymore. Even higher priority threads will be affected, correct? With a yield in the loop it would only happen with lower priority threads, is that right? So if I write:

while (1) {
        k_sem_take(&messageSemaphore, K_FOREVER);
        k_msgq_get(&uartRxMsgQ, &incomingMsg, K_FOREVER);
        LOG_INF("RX: %s", incomingMsg);
        k_yield();
    }

after every message the scheduler will get a chance to switch to something more important to do. So my guess is that it makes way more sense with the yield. Do I see this right?