Elabora più messaggi con il controllo della contemporaneità

Punto chiave: il controllo della contemporaneità consente di configurare il numero di thread o flussi che la libreria client Pub/Sub utilizza per eseguire il pull dei messaggi. Con più thread, puoi elaborare più messaggi contemporaneamente.

Il controllo della contemporaneità è una funzionalità disponibile nella libreria client di alto livello di Pub/Sub. Puoi anche implementare il tuo controllo della contemporaneità quando utilizzi una libreria di basso livello.

Il supporto per il controllo della contemporaneità dipende dal linguaggio di programmazione della libreria client. Per le implementazioni di linguaggio che supportano i thread paralleli, come C++, Go e Java, le librerie client rappresentano la scelta predefinita per il numero di thread.

Questa scelta potrebbe non essere ottimale per la tua applicazione. Ad esempio, se l'applicazione del sottoscrittore non riesce a tenere il passo con il volume dei messaggi in entrata e non è vincolata alla CPU, è necessario aumentare il numero dei thread. Per le operazioni di elaborazione dei messaggi che richiedono un uso intensivo della CPU, potrebbe essere opportuno ridurre il numero di thread.

Configurazioni del controllo della contemporaneità

I valori predefiniti delle variabili di controllo della contemporaneità e i nomi delle variabili potrebbero variare a seconda delle librerie client. Ad esempio, nella libreria client Java, i metodi per configurare il controllo della contemporaneità sono setSystemExecutorProvider(), setExecutorProvider() e setParallelPullCount().

• setParallelPullCount() ti consente di decidere quanti stream aprire. Puoi aprire più flussi se il tuo client abbonato è in grado di gestire più dati di quelli inviati in un singolo stream di 10 MBps.

• setExecutorProvider() consente di personalizzare il provider di esecutore utilizzato per l'elaborazione dei messaggi. Ad esempio, puoi cambiare il provider di esecutore impostandone uno che restituisce un singolo esecutore condiviso con un numero limitato di thread in più client dell'abbonato. Questa configurazione consente di limitare il numero di thread creati.

• setSystemExecutorProvider() consente di personalizzare il provider di esecutori utilizzato per la gestione del lease. In genere, questo valore non viene configurato a meno che tu non voglia utilizzare lo stesso provider di esecutori in setExecutorProvider e setSystemExecutorProvider. Ad esempio, puoi utilizzare lo stesso provider di esecutori se disponi di diverse sottoscrizioni a bassa velocità effettiva. L'uso dello stesso valore limita il numero di thread nel client.

Il numero totale di thread utilizzati per il controllo della contemporaneità dipende dal provider di esecutori passati nella libreria client e dal numero di pull parallelo.

Esempi di codice per il controllo della contemporaneità

C++

Prima di provare questo esempio, segui le istruzioni di configurazione di C++ riportate nella Guida rapida sull'utilizzo delle librerie client. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API C++ Pub/Sub.

namespace pubsub = ::google::cloud::pubsub;
using ::google::cloud::future;
using ::google::cloud::GrpcBackgroundThreadPoolSizeOption;
using ::google::cloud::Options;
using ::google::cloud::StatusOr;
auto sample = [](std::string project_id, std::string subscription_id) {
  // Create a subscriber with 16 threads handling I/O work, by default the
  // library creates `std::thread::hardware_concurrency()` threads.
  auto subscriber = pubsub::Subscriber(pubsub::MakeSubscriberConnection(
      pubsub::Subscription(std::move(project_id), std::move(subscription_id)),
      Options{}
          .set<pubsub::MaxConcurrencyOption>(8)
          .set<GrpcBackgroundThreadPoolSizeOption>(16)));

  // Create a subscription where up to 8 messages are handled concurrently. By
  // default the library uses `std::thread::hardware_concurrency()` as the
  // maximum number of concurrent callbacks.
  auto session = subscriber.Subscribe(
      [](pubsub::Message const& m, pubsub::AckHandler h) {
        // This handler executes in the I/O threads, applications could use,
        // std::async(), a thread-pool, or any other mechanism to transfer the
        // execution to other threads.
        std::cout << "Received message " << m << "\n";
        std::move(h).ack();
        PleaseIgnoreThisSimplifiesTestingTheSamples();
      });
  return std::make_pair(subscriber, std::move(session));
};

Go

Prima di provare questo esempio, segui le istruzioni di configurazione di Go nella Guida rapida sull'utilizzo delle librerie client. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API Go Pub/Sub.

import (
	"context"
	"fmt"
	"io"
	"sync/atomic"
	"time"

	"cloud.google.com/go/pubsub"
)

func pullMsgsConcurrencyControl(w io.Writer, projectID, subID string) error {
	// projectID := "my-project-id"
	// subID := "my-sub"
	ctx := context.Background()
	client, err := pubsub.NewClient(ctx, projectID)
	if err != nil {
		return fmt.Errorf("pubsub.NewClient: %w", err)
	}
	defer client.Close()

	sub := client.Subscription(subID)
	// Must set ReceiveSettings.Synchronous to false (or leave as default) to enable
	// concurrency pulling of messages. Otherwise, NumGoroutines will be set to 1.
	sub.ReceiveSettings.Synchronous = false
	// NumGoroutines determines the number of goroutines sub.Receive will spawn to pull
	// messages.
	sub.ReceiveSettings.NumGoroutines = 16
	// MaxOutstandingMessages limits the number of concurrent handlers of messages.
	// In this case, up to 8 unacked messages can be handled concurrently.
	// Note, even in synchronous mode, messages pulled in a batch can still be handled
	// concurrently.
	sub.ReceiveSettings.MaxOutstandingMessages = 8

	// Receive messages for 10 seconds, which simplifies testing.
	// Comment this out in production, since `Receive` should
	// be used as a long running operation.
	ctx, cancel := context.WithTimeout(ctx, 10*time.Second)
	defer cancel()

	var received int32

	// Receive blocks until the context is cancelled or an error occurs.
	err = sub.Receive(ctx, func(_ context.Context, msg *pubsub.Message) {
		atomic.AddInt32(&received, 1)
		msg.Ack()
	})
	if err != nil {
		return fmt.Errorf("sub.Receive returned error: %w", err)
	}
	fmt.Fprintf(w, "Received %d messages\n", received)

	return nil
}

Java

Prima di provare questo esempio, segui le istruzioni di configurazione Java in Guida rapida sull'utilizzo delle librerie client. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API Java Pub/Sub.

import com.google.api.gax.core.ExecutorProvider;
import com.google.api.gax.core.InstantiatingExecutorProvider;
import com.google.cloud.pubsub.v1.AckReplyConsumer;
import com.google.cloud.pubsub.v1.MessageReceiver;
import com.google.cloud.pubsub.v1.Subscriber;
import com.google.pubsub.v1.ProjectSubscriptionName;
import com.google.pubsub.v1.PubsubMessage;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class SubscribeWithConcurrencyControlExample {
  public static void main(String... args) throws Exception {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "your-project-id";
    String subscriptionId = "your-subscription-id";

    subscribeWithConcurrencyControlExample(projectId, subscriptionId);
  }

  public static void subscribeWithConcurrencyControlExample(
      String projectId, String subscriptionId) {
    ProjectSubscriptionName subscriptionName =
        ProjectSubscriptionName.of(projectId, subscriptionId);

    // Instantiate an asynchronous message receiver.
    MessageReceiver receiver =
        (PubsubMessage message, AckReplyConsumer consumer) -> {
          // Handle incoming message, then ack the received message.
          System.out.println("Id: " + message.getMessageId());
          System.out.println("Data: " + message.getData().toStringUtf8());
          consumer.ack();
        };

    Subscriber subscriber = null;
    try {
      // Provides an executor service for processing messages. The default `executorProvider` used
      // by the subscriber has a default thread count of 5.
      ExecutorProvider executorProvider =
          InstantiatingExecutorProvider.newBuilder().setExecutorThreadCount(4).build();

      // `setParallelPullCount` determines how many StreamingPull streams the subscriber will open
      // to receive message. It defaults to 1. `setExecutorProvider` configures an executor for the
      // subscriber to process messages. Here, the subscriber is configured to open 2 streams for
      // receiving messages, each stream creates a new executor with 4 threads to help process the
      // message callbacks. In total 2x4=8 threads are used for message processing.
      subscriber =
          Subscriber.newBuilder(subscriptionName, receiver)
              .setParallelPullCount(2)
              .setExecutorProvider(executorProvider)
              .build();

      // Start the subscriber.
      subscriber.startAsync().awaitRunning();
      System.out.printf("Listening for messages on %s:\n", subscriptionName.toString());
      // Allow the subscriber to run for 30s unless an unrecoverable error occurs.
      subscriber.awaitTerminated(30, TimeUnit.SECONDS);
    } catch (TimeoutException timeoutException) {
      // Shut down the subscriber after 30s. Stop receiving messages.
      subscriber.stopAsync();
    }
  }
}

Ruby

Prima di provare questo esempio, segui le istruzioni di configurazione di Ruby riportate in Guida rapida sull'utilizzo delle librerie client. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API Ruby Pub/Sub.

# subscription_id = "your-subscription-id"

pubsub = Google::Cloud::Pubsub.new

subscription = pubsub.subscription subscription_id
# Use 2 threads for streaming, 4 threads for executing callbacks and 2 threads
# for sending acknowledgements and/or delays
subscriber   = subscription.listen streams: 2, threads: {
  callback: 4,
  push:     2
} do |received_message|
  puts "Received message: #{received_message.data}"
  received_message.acknowledge!
end

subscriber.start
# Let the main thread sleep for 60 seconds so the thread for listening
# messages does not quit
sleep 60
subscriber.stop.wait!

Passaggi successivi

Scopri le altre opzioni di consegna che puoi configurare per un abbonamento:

• Gestire i picchi temporanei con il controllo del flusso

• Gestire gli errori relativi ai messaggi con il criterio per i nuovi tentativi di sottoscrizione

• Inoltrare i messaggi non recapitati a un argomento messaggi non recapitabili

• Riprodurre di nuovo i messaggi compromessi in precedenza o eliminare definitivamente i messaggi

• Estendi il tempo di conferma con la gestione dei leasing

• Ricevi i messaggi in ordine

• Filtrare i messaggi in base agli attributi

• Ricevi e conferma i messaggi esattamente una volta