要實現RabbitMQ的同步返回結果，可以使用RabbitMQ的RPC機制。RPC（Remote Procedure Call）是一種進程間通信的方式，它允許一個程序調用另一個程序中的函數或方法，就像調用本地函數一樣。

下面是實現RabbitMQ同步返回結果的大致步驟：

1. 創建一個RPC客戶端和一個RPC服務器。
2. 客戶端發送請求消息到服務器，并且帶有一個唯一的回調隊列。
3. 服務器接收到請求消息后，開始處理請求，并將結果發送到客戶端指定的回調隊列。
4. 客戶端等待接收結果，并將結果返回給調用者。

具體實現步驟如下：

1. 定義一個回調隊列，用于接收服務器返回的結果。
2. 客戶端發送請求消息時，將回調隊列的名稱作為消息屬性的值發送給服務器。
3. 服務器在處理請求時，將結果發送到回調隊列。
4. 客戶端在發送請求后，開始監聽回調隊列，等待接收結果。
5. 客戶端接收到結果后，將結果返回給調用者。

以下是一個簡單的示例代碼：

RPC客戶端：

import pika
import uuid

class RpcClient:
    def __init__(self):
        self.connection = pika.BlockingConnection(pika.ConnectionParameters('localhost'))
        self.channel = self.connection.channel()

        result = self.channel.queue_declare(queue='', exclusive=True)
        self.callback_queue = result.method.queue

        self.channel.basic_consume(queue=self.callback_queue, on_message_callback=self.on_response, auto_ack=True)

    def on_response(self, ch, method, props, body):
        if self.correlation_id == props.correlation_id:
            self.response = body

    def call(self, message):
        self.response = None
        self.correlation_id = str(uuid.uuid4())

        self.channel.basic_publish(
            exchange='',
            routing_key='rpc_queue',
            properties=pika.BasicProperties(
                reply_to=self.callback_queue,
                correlation_id=self.correlation_id,
            ),
            body=message)

        while self.response is None:
            self.connection.process_data_events()

        return self.response


rpc_client = RpcClient()
response = rpc_client.call('Hello, World!')
print(response)

RPC服務器：

import pika

class RpcServer:
    def __init__(self):
        self.connection = pika.BlockingConnection(pika.ConnectionParameters('localhost'))
        self.channel = self.connection.channel()

        self.channel.queue_declare(queue='rpc_queue')

        self.channel.basic_qos(prefetch_count=1)
        self.channel.basic_consume(queue='rpc_queue', on_message_callback=self.on_request)

    def on_request(self, ch, method, props, body):
        message = body.decode()
        response = self.process_request(message)

        ch.basic_publish(
            exchange='',
            routing_key=props.reply_to,
            properties=pika.BasicProperties(correlation_id=props.correlation_id),
            body=str(response))

        ch.basic_ack(delivery_tag=method.delivery_tag)

    def process_request(self, message):
        # 處理請求的邏輯
        response = 'Hello, ' + message
        return response


rpc_server = RpcServer()
rpc_server.channel.start_consuming()

在上面的示例代碼中，客戶端發送請求消息時，將回調隊列的名稱作為消息屬性的值發送給服務器。服務器在處理請求時，將結果發送到回調隊列。客戶端在發送請求后，開始監聽回調隊列，等待接收結果。客戶端接收到結果后，將結果返回給調用者。

注意：上述示例代碼是使用Python的pika庫實現的，如果使用其他編程語言，可以參考相應語言的RabbitMQ RPC實現方式。