Documentation

  lang:   lib:

Get started

ZeroMQ (also spelled ØMQ, 0MQ or ZMQ) is a high-performance asynchronous messaging library, aimed at use in distributed or concurrent applications. It provides a message queue, but unlike message-oriented middleware, a ZeroMQ system can run without a dedicated message broker.

ZeroMQ supports common messaging patterns (pub/sub, request/reply, client/server and others) over a variety of transports (TCP, in-process, inter-process, multicast, WebSocket and more), making inter-process messaging as simple as inter-thread messaging. This keeps your code clear, modular and extremely easy to scale.

ZeroMQ is developed by a large community of contributors. There are third-party bindings for many popular programming languages and native ports for C# and Java.

The Zero in ZeroMQ

The philosophy of ZeroMQ starts with the zero. The zero is for zero broker (ZeroMQ is brokerless), zero latency, zero cost (it’s free), and zero administration.

More generally, “zero” refers to the culture of minimalism that permeates the project. We add power by removing complexity rather than by exposing new functionality.

The Guide

The guide explains how to use ØMQ, covers basic, intermediate and advanced use with 60+ diagrams and 750 examples in 28 languages.

Also available as a book O’Reilly.

Libzmq - the low level library

Libzmq (https://github.com/zeromq/libzmq) is the low-level library behind most of the different language bindings. Libzmq expose C-API and implemented in C++. You will rarely use libzmq directly, however if you want to contribute to the project or learn the internals of zeromq, that is the place to start.

Pick your language

Pick your library

libzmq | C

ZeroMQ core engine in C++
tcp, udp, pgm, norm, ipc, inproc, gssapi
PLAIN, CURVE

czmq | C

High-level binding for libzmq
tcp, udp, pgm, norm, ipc, inproc, gssapi
PLAIN, CURVE

zmqpp | C++

High-level binding for libzmq
tcp, udp, pgm, norm, ipc, inproc, gssapi
PLAIN, CURVE

cppzmq | C++

Header-only C++ binding for libzmq
tcp, udp, pgm, norm, ipc, inproc, gssapi
PLAIN, CURVE

azmq | C++

Boost Asio style binding for libzmq
tcp, udp, pgm, norm, ipc, inproc, gssapi
PLAIN, CURVE

czmqpp | C++

Minimal, simple wrapper for czmq
tcp, udp, pgm, norm, ipc, inproc, gssapi
PLAIN, CURVE

NetMQ | C#

ZeroMQ engine in C# for .Net
tcp, inproc, pgm
PLAIN

clrzmq4 | C#

.Net binding for libzmq
tcp, udp, pgm, norm, ipc, inproc, gssapi
PLAIN, CURVE

Chumak | Erlang

ZeroMQ engine in Erlang
tcp
PLAIN, CURVE

ezmq | Erlang

ZeroMQ engine in Erlang
tcp
PLAIN

erlang-czmq | Erlang

Erlang binding for czmq
tcp, udp, pgm, norm, ipc, inproc, gssapi
PLAIN, CURVE

FsNetMQ | F#

F# binding for NetMQ
tcp, inproc, pgm
PLAIN

fszmq | F#

F# binding for libzmq
tcp, udp, pgm, norm, ipc, inproc, gssapi
PLAIN, CURVE

zmq4 | Go

Go binding for libzmq
tcp, udp, pgm, norm, ipc, inproc, gssapi
PLAIN, CURVE

goczmq | Go

Go binding for czmq
tcp, udp, pgm, norm, ipc, inproc, gssapi
PLAIN, CURVE

zeromq-haskell | Haskell

Haskell binding for libzmq
tcp, udp, pgm, norm, ipc, inproc, gssapi
PLAIN, CURVE

JeroMQ | Java

ZeroMQ engine in pure Java
tcp, inproc, ipc (JeroMQ only)
PLAIN, CURVE

JZMQ | Java

JNI binding for libzmq
tcp, udp, pgm, norm, ipc, inproc, gssapi
PLAIN, CURVE

jczmq | Java

JNI binding for czmq
tcp, udp, pgm, norm, ipc, inproc, gssapi
PLAIN, CURVE

zeromqjs | Node.js

Node.js binding for czmq
tcp, udp, pgm, norm, ipc, inproc, gssapi
PLAIN, CURVE

perlzmq | Perl

Perl binding for libzmq
tcp, udp, pgm, norm, ipc, inproc, gssapi
PLAIN, CURVE

Pyzmq | Python

Python binding for libzmq
tcp, udp, pgm, norm, ipc, inproc, gssapi
PLAIN, CURVE

rbzmq | Ruby

Ruby binding for libzmq
tcp, udp, pgm, norm, ipc, inproc, gssapi
PLAIN, CURVE

rust-zmq | Rust

Rust binding for libzmq
tcp, udp, pgm, norm, ipc, inproc, gssapi
PLAIN, CURVE

First example

So let’s start with some code, the “Hello world” example (of course).

//  Hello World server
#include <zmq.h>
#include <string.h>
#include <stdio.h>
#include <unistd.h>
#include <assert.h>

int main (void)
{
    //  Socket to talk to clients
    void *context = zmq_ctx_new ();
    void *responder = zmq_socket (context, ZMQ_REP);
    int rc = zmq_bind (responder, "tcp://*:5555");
    assert (rc == 0);

    while (1) {
        char buffer [10];
        zmq_recv (responder, buffer, 10, 0);
        printf ("Received Hello\n");
        sleep (1);          //  Do some 'work'
        zmq_send (responder, "World", 5, 0);
    }
    return 0;
}
//  Hello World server
#include <czmq.h>

int main (void)
{
    //  Socket to talk to clients
    zsock_t *responder = zsock_new (ZMQ_REP);
    int rc = zsock_bind (responder, "tcp://*:5555");
    assert (rc == 0);

    while (1) {
        char *str = zstr_recv (responder);
        printf ("Received Hello\n");
        sleep (1);          //  Do some 'work'
        zstr_send (responder, "World");
        zstr_free (&str);
    }
    return 0;
}
//  Hello World server

#include <zmqpp/zmqpp.hpp>
#include <string>
#include <iostream>
#include <chrono>
#include <thread>

using namespace std;

int main(int argc, char *argv[]) {
  const string endpoint = "tcp://*:5555";

  // initialize the 0MQ context
  zmqpp::context context;

  // generate a pull socket
  zmqpp::socket_type type = zmqpp::socket_type::reply;
  zmqpp::socket socket (context, type);

  // bind to the socket
  socket.bind(endpoint);
  while (1) {
    // receive the message
    zmqpp::message message;
    // decompose the message 
    socket.receive(message);
    string text;
    message >> text;

    //Do some 'work'
    std::this_thread::sleep_for(std::chrono::seconds(1));
    cout << "Received Hello" << endl;
    socket.send("World");
  }

}
#include <string>
#include <chrono>
#include <thread>
#include <iostream>

#include <zmq.hpp>

int main() 
{
    using namespace std::chrono_literals;

    // initialize the zmq context with a single IO thread
    zmq::context_t context{1};

    // construct a REP (reply) socket and bind to interface
    zmq::socket_t socket{context, ZMQ_REP};
    socket.bind("tcp://*:5555");

    // prepare some static data for responses
    const std::string data{"World"};

    for (;;) 
    {
        zmq::message_t request;

        // receive a request from client
        socket.recv(request, zmq::recv_flags::none);
        std::cout << "Received " << request.to_string() << std::endl;

        // simulate work
        std::this_thread::sleep_for(1s);

        // construct a reply message
        zmq::message_t reply{data.cbegin(), data.cend()};

        // send the reply to the client
        socket.send(reply, zmq::send_flags::none);
    }

    return 0;
}
Example hello_world_server is missing for azmq. Would you like to contribute it? Then follow the steps below:

    git clone https://github.com/zeromq/zeromq.org
    example_dir=content/docs/examples/cpp/azmq
    cd zeromq.org && mkdir -p $example_dir
    [ -s $example_dir/index.md ] || cat >$example_dir/index.md <<'EOF'
---
headless: true
---
EOF
    cp archetypes/examples/hello_world_server.md
    $example_dir/hello_world_server.md
Example hello_world_server is missing for czmqpp. Would you like to contribute it? Then follow the steps below:

    git clone https://github.com/zeromq/zeromq.org
    example_dir=content/docs/examples/cpp/czmqpp
    cd zeromq.org && mkdir -p $example_dir
    [ -s $example_dir/index.md ] || cat >$example_dir/index.md <<'EOF'
---
headless: true
---
EOF
    cp archetypes/examples/hello_world_server.md
    $example_dir/hello_world_server.md
using System;
using System.Threading;
using NetMQ;
using NetMQ.Sockets;

static class Program
{
    public static void Main()
    {        
        using (var responder = new ResponseSocket())
        {
            responder.Bind("tcp://*:5555");

            while (true) 
            {
                string str = responder.ReceiveFrameString();
                Console.WriteLine("Received Hello");
                Thread.Sleep(1000);  //  Do some 'work'
                responder.SendFrame("World");
            }
        }
    }
}
Example hello_world_server is missing for clrzmq4. Would you like to contribute it? Then follow the steps below:

    git clone https://github.com/zeromq/zeromq.org
    example_dir=content/docs/examples/csharp/clrzmq4
    cd zeromq.org && mkdir -p $example_dir
    [ -s $example_dir/index.md ] || cat >$example_dir/index.md <<'EOF'
---
headless: true
---
EOF
    cp archetypes/examples/hello_world_server.md
    $example_dir/hello_world_server.md
Example hello_world_server is missing for Chumak. Would you like to contribute it? Then follow the steps below:

    git clone https://github.com/zeromq/zeromq.org
    example_dir=content/docs/examples/erlang/chumak
    cd zeromq.org && mkdir -p $example_dir
    [ -s $example_dir/index.md ] || cat >$example_dir/index.md <<'EOF'
---
headless: true
---
EOF
    cp archetypes/examples/hello_world_server.md
    $example_dir/hello_world_server.md
Example hello_world_server is missing for ezmq. Would you like to contribute it? Then follow the steps below:

    git clone https://github.com/zeromq/zeromq.org
    example_dir=content/docs/examples/erlang/ezmq
    cd zeromq.org && mkdir -p $example_dir
    [ -s $example_dir/index.md ] || cat >$example_dir/index.md <<'EOF'
---
headless: true
---
EOF
    cp archetypes/examples/hello_world_server.md
    $example_dir/hello_world_server.md
Example hello_world_server is missing for erlang-czmq. Would you like to contribute it? Then follow the steps below:

    git clone https://github.com/zeromq/zeromq.org
    example_dir=content/docs/examples/erlang/erlang-czmq
    cd zeromq.org && mkdir -p $example_dir
    [ -s $example_dir/index.md ] || cat >$example_dir/index.md <<'EOF'
---
headless: true
---
EOF
    cp archetypes/examples/hello_world_server.md
    $example_dir/hello_world_server.md
Example hello_world_server is missing for FsNetMQ. Would you like to contribute it? Then follow the steps below:

    git clone https://github.com/zeromq/zeromq.org
    example_dir=content/docs/examples/fsharp/fsnetmq
    cd zeromq.org && mkdir -p $example_dir
    [ -s $example_dir/index.md ] || cat >$example_dir/index.md <<'EOF'
---
headless: true
---
EOF
    cp archetypes/examples/hello_world_server.md
    $example_dir/hello_world_server.md
Example hello_world_server is missing for fszmq. Would you like to contribute it? Then follow the steps below:

    git clone https://github.com/zeromq/zeromq.org
    example_dir=content/docs/examples/fsharp/fszmq
    cd zeromq.org && mkdir -p $example_dir
    [ -s $example_dir/index.md ] || cat >$example_dir/index.md <<'EOF'
---
headless: true
---
EOF
    cp archetypes/examples/hello_world_server.md
    $example_dir/hello_world_server.md
Example hello_world_server is missing for zmq4. Would you like to contribute it? Then follow the steps below:

    git clone https://github.com/zeromq/zeromq.org
    example_dir=content/docs/examples/go/zmq4
    cd zeromq.org && mkdir -p $example_dir
    [ -s $example_dir/index.md ] || cat >$example_dir/index.md <<'EOF'
---
headless: true
---
EOF
    cp archetypes/examples/hello_world_server.md
    $example_dir/hello_world_server.md
Example hello_world_server is missing for goczmq. Would you like to contribute it? Then follow the steps below:

    git clone https://github.com/zeromq/zeromq.org
    example_dir=content/docs/examples/go/goczmq
    cd zeromq.org && mkdir -p $example_dir
    [ -s $example_dir/index.md ] || cat >$example_dir/index.md <<'EOF'
---
headless: true
---
EOF
    cp archetypes/examples/hello_world_server.md
    $example_dir/hello_world_server.md
Example hello_world_server is missing for zeromq-haskell. Would you like to contribute it? Then follow the steps below:

    git clone https://github.com/zeromq/zeromq.org
    example_dir=content/docs/examples/haskell/zeromq-haskell
    cd zeromq.org && mkdir -p $example_dir
    [ -s $example_dir/index.md ] || cat >$example_dir/index.md <<'EOF'
---
headless: true
---
EOF
    cp archetypes/examples/hello_world_server.md
    $example_dir/hello_world_server.md
//  Hello World server in Java
//  Binds REP socket to tcp://*:5555
//  Expects "Hello" from client, replies with "World"

import org.zeromq.SocketType;
import org.zeromq.ZMQ;
import org.zeromq.ZContext;

public class hwserver
{
  public static void main(String[] args) throws Exception
  {
    try (ZContext context = new ZContext()) {
      //  Socket to talk to clients
      ZMQ.Socket socket = context.createSocket(SocketType.REP);
      socket.bind("tcp://*:5555");

      while (!Thread.currentThread().isInterrupted()) {
        byte[] reply = socket.recv(0);
        System.out.println(
          "Received " + ": [" + new String(reply, ZMQ.CHARSET) + "]"
        );
        String response = "world";
        socket.send(response.getBytes(ZMQ.CHARSET), 0);
        Thread.sleep(1000); //  Do some 'work'
      }
    }
  }
}
Example hello_world_server is missing for JZMQ. Would you like to contribute it? Then follow the steps below:

    git clone https://github.com/zeromq/zeromq.org
    example_dir=content/docs/examples/java/jzmq
    cd zeromq.org && mkdir -p $example_dir
    [ -s $example_dir/index.md ] || cat >$example_dir/index.md <<'EOF'
---
headless: true
---
EOF
    cp archetypes/examples/hello_world_server.md
    $example_dir/hello_world_server.md
Example hello_world_server is missing for jczmq. Would you like to contribute it? Then follow the steps below:

    git clone https://github.com/zeromq/zeromq.org
    example_dir=content/docs/examples/java/jczmq
    cd zeromq.org && mkdir -p $example_dir
    [ -s $example_dir/index.md ] || cat >$example_dir/index.md <<'EOF'
---
headless: true
---
EOF
    cp archetypes/examples/hello_world_server.md
    $example_dir/hello_world_server.md
Example hello_world_server is missing for zeromqjs. Would you like to contribute it? Then follow the steps below:

    git clone https://github.com/zeromq/zeromq.org
    example_dir=content/docs/examples/nodejs/zeromqjs
    cd zeromq.org && mkdir -p $example_dir
    [ -s $example_dir/index.md ] || cat >$example_dir/index.md <<'EOF'
---
headless: true
---
EOF
    cp archetypes/examples/hello_world_server.md
    $example_dir/hello_world_server.md
Example hello_world_server is missing for perlzmq. Would you like to contribute it? Then follow the steps below:

    git clone https://github.com/zeromq/zeromq.org
    example_dir=content/docs/examples/perl/perlzmq
    cd zeromq.org && mkdir -p $example_dir
    [ -s $example_dir/index.md ] || cat >$example_dir/index.md <<'EOF'
---
headless: true
---
EOF
    cp archetypes/examples/hello_world_server.md
    $example_dir/hello_world_server.md
Example hello_world_server is missing for Pyzmq. Would you like to contribute it? Then follow the steps below:

    git clone https://github.com/zeromq/zeromq.org
    example_dir=content/docs/examples/python/pyzmq
    cd zeromq.org && mkdir -p $example_dir
    [ -s $example_dir/index.md ] || cat >$example_dir/index.md <<'EOF'
---
headless: true
---
EOF
    cp archetypes/examples/hello_world_server.md
    $example_dir/hello_world_server.md
Example hello_world_server is missing for rbzmq. Would you like to contribute it? Then follow the steps below:

    git clone https://github.com/zeromq/zeromq.org
    example_dir=content/docs/examples/ruby/rbzmq
    cd zeromq.org && mkdir -p $example_dir
    [ -s $example_dir/index.md ] || cat >$example_dir/index.md <<'EOF'
---
headless: true
---
EOF
    cp archetypes/examples/hello_world_server.md
    $example_dir/hello_world_server.md
#![crate_name = "helloworld_server"]

//! Hello World server in Rust
//! Binds REP socket to tcp://*:5555
//! Expects "Hello" from client, replies with "World"

use std::thread;
use std::time::Duration;

fn main() {
    let context = zmq::Context::new();
    let responder = context.socket(zmq::REP).unwrap();

    assert!(responder.bind("tcp://*:5555").is_ok());

    let mut msg = zmq::Message::new();
    loop {
        responder.recv(&mut msg, 0).unwrap();
        println!("Received {}", msg.as_str().unwrap());
        thread::sleep(Duration::from_millis(1000));
        responder.send("World", 0).unwrap();
    }
}

The server creates a socket of type response (you will read more about request-response later), binds it to port 5555 and then waits for messages. You can also see that we have zero configuration, we are just sending strings.

//  Hello World client
#include <zmq.h>
#include <string.h>
#include <stdio.h>
#include <unistd.h>

int main (void)
{
    printf ("Connecting to hello world server…\n");
    void *context = zmq_ctx_new ();
    void *requester = zmq_socket (context, ZMQ_REQ);
    zmq_connect (requester, "tcp://localhost:5555");

    int request_nbr;
    for (request_nbr = 0; request_nbr != 10; request_nbr++) {
        char buffer [10];
        printf ("Sending Hello %d…\n", request_nbr);
        zmq_send (requester, "Hello", 5, 0);
        zmq_recv (requester, buffer, 10, 0);
        printf ("Received World %d\n", request_nbr);
    }
    zmq_close (requester);
    zmq_ctx_destroy (context);
    return 0;
}
//  Hello World client
#include <czmq.h>

int main (void)
{
    printf ("Connecting to hello world server…\n");
    zsock_t *requester = zsock_new (ZMQ_REQ);
    zsock_connect (requester, "tcp://localhost:5555");

    int request_nbr;
    for (request_nbr = 0; request_nbr != 10; request_nbr++) {
        printf ("Sending Hello %d…\n", request_nbr);
        zstr_send (requester, "Hello");
        char *str = zstr_recv (requester);
        printf ("Received World %d\n", request_nbr);
        zstr_free (&str);
    }
    zsock_destroy (&requester);
    return 0;
}
//  Hello World client
#include <zmqpp/zmqpp.hpp>
#include <string>
#include <iostream>

using namespace std;

int main(int argc, char *argv[]) {
  const string endpoint = "tcp://localhost:5555";

  // initialize the 0MQ context
  zmqpp::context context;

  // generate a push socket
  zmqpp::socket_type type = zmqpp::socket_type::req;
  zmqpp::socket socket (context, type);

  // open the connection
  cout << "Connecting to hello world server…" << endl;
  socket.connect(endpoint);
  int request_nbr;
  for (request_nbr = 0; request_nbr != 10; request_nbr++) {
    // send a message
    cout << "Sending Hello " << request_nbr <<"…" << endl;
    zmqpp::message message;
    // compose a message from a string and a number
    message << "Hello";
    socket.send(message);
    string buffer;
    socket.receive(buffer);
    
    cout << "Received World " << request_nbr << endl;
  }
}
#include <string>
#include <iostream>

#include <zmq.hpp>

int main()
{
    // initialize the zmq context with a single IO thread
    zmq::context_t context{1};

    // construct a REQ (request) socket and connect to interface
    zmq::socket_t socket{context, ZMQ_REQ};
    socket.connect("tcp://localhost:5555");

    // set up some static data to send
    const std::string data{"Hello"};

    for (auto request_num = 0; request_num < 10; ++request_num) 
    {
        // initialize a request message
        zmq::message_t request{data.cbegin(), data.cend()};
        
        // send the request message
        std::cout << "Sending Hello " << request_num << "..." << std::endl;
        socket.send(request, zmq::send_flags::none);
        
        // wait for reply from server
        zmq::message_t reply{};
        socket.recv(reply, zmq::recv_flags::none);

        std::cout << "Received " << reply.to_string(); 
        std::cout << " (" << request_num << ")";
        std::cout << std::endl;
    }

    return 0;
}
Example hello_world_client is missing for azmq. Would you like to contribute it? Then follow the steps below:

    git clone https://github.com/zeromq/zeromq.org
    example_dir=content/docs/examples/cpp/azmq
    cd zeromq.org && mkdir -p $example_dir
    [ -s $example_dir/index.md ] || cat >$example_dir/index.md <<'EOF'
---
headless: true
---
EOF
    cp archetypes/examples/hello_world_client.md
    $example_dir/hello_world_client.md
Example hello_world_client is missing for czmqpp. Would you like to contribute it? Then follow the steps below:

    git clone https://github.com/zeromq/zeromq.org
    example_dir=content/docs/examples/cpp/czmqpp
    cd zeromq.org && mkdir -p $example_dir
    [ -s $example_dir/index.md ] || cat >$example_dir/index.md <<'EOF'
---
headless: true
---
EOF
    cp archetypes/examples/hello_world_client.md
    $example_dir/hello_world_client.md
using System;
using NetMQ;
using NetMQ.Sockets;

static class Program
{
    public static void Main()
    {
        Console.WriteLine("Connecting to hello world server…");
        using(var requester = new RequestSocket())
        {
            requester.Connect("tcp://localhost:5555");

            int requestNumber;
            for (requestNumber = 0; requestNumber != 10; requestNumber++)
            {
                Console.WriteLine("Sending Hello {0}...", requestNumber);
                requester.SendFrame("Hello");
                string str = requester.ReceiveFrameString();
                Console.WriteLine("Received World {0}", requestNumber);
            }
        }
    }    
}
Example hello_world_client is missing for clrzmq4. Would you like to contribute it? Then follow the steps below:

    git clone https://github.com/zeromq/zeromq.org
    example_dir=content/docs/examples/csharp/clrzmq4
    cd zeromq.org && mkdir -p $example_dir
    [ -s $example_dir/index.md ] || cat >$example_dir/index.md <<'EOF'
---
headless: true
---
EOF
    cp archetypes/examples/hello_world_client.md
    $example_dir/hello_world_client.md
Example hello_world_client is missing for Chumak. Would you like to contribute it? Then follow the steps below:

    git clone https://github.com/zeromq/zeromq.org
    example_dir=content/docs/examples/erlang/chumak
    cd zeromq.org && mkdir -p $example_dir
    [ -s $example_dir/index.md ] || cat >$example_dir/index.md <<'EOF'
---
headless: true
---
EOF
    cp archetypes/examples/hello_world_client.md
    $example_dir/hello_world_client.md
Example hello_world_client is missing for ezmq. Would you like to contribute it? Then follow the steps below:

    git clone https://github.com/zeromq/zeromq.org
    example_dir=content/docs/examples/erlang/ezmq
    cd zeromq.org && mkdir -p $example_dir
    [ -s $example_dir/index.md ] || cat >$example_dir/index.md <<'EOF'
---
headless: true
---
EOF
    cp archetypes/examples/hello_world_client.md
    $example_dir/hello_world_client.md
Example hello_world_client is missing for erlang-czmq. Would you like to contribute it? Then follow the steps below:

    git clone https://github.com/zeromq/zeromq.org
    example_dir=content/docs/examples/erlang/erlang-czmq
    cd zeromq.org && mkdir -p $example_dir
    [ -s $example_dir/index.md ] || cat >$example_dir/index.md <<'EOF'
---
headless: true
---
EOF
    cp archetypes/examples/hello_world_client.md
    $example_dir/hello_world_client.md
Example hello_world_client is missing for FsNetMQ. Would you like to contribute it? Then follow the steps below:

    git clone https://github.com/zeromq/zeromq.org
    example_dir=content/docs/examples/fsharp/fsnetmq
    cd zeromq.org && mkdir -p $example_dir
    [ -s $example_dir/index.md ] || cat >$example_dir/index.md <<'EOF'
---
headless: true
---
EOF
    cp archetypes/examples/hello_world_client.md
    $example_dir/hello_world_client.md
Example hello_world_client is missing for fszmq. Would you like to contribute it? Then follow the steps below:

    git clone https://github.com/zeromq/zeromq.org
    example_dir=content/docs/examples/fsharp/fszmq
    cd zeromq.org && mkdir -p $example_dir
    [ -s $example_dir/index.md ] || cat >$example_dir/index.md <<'EOF'
---
headless: true
---
EOF
    cp archetypes/examples/hello_world_client.md
    $example_dir/hello_world_client.md
Example hello_world_client is missing for zmq4. Would you like to contribute it? Then follow the steps below:

    git clone https://github.com/zeromq/zeromq.org
    example_dir=content/docs/examples/go/zmq4
    cd zeromq.org && mkdir -p $example_dir
    [ -s $example_dir/index.md ] || cat >$example_dir/index.md <<'EOF'
---
headless: true
---
EOF
    cp archetypes/examples/hello_world_client.md
    $example_dir/hello_world_client.md
Example hello_world_client is missing for goczmq. Would you like to contribute it? Then follow the steps below:

    git clone https://github.com/zeromq/zeromq.org
    example_dir=content/docs/examples/go/goczmq
    cd zeromq.org && mkdir -p $example_dir
    [ -s $example_dir/index.md ] || cat >$example_dir/index.md <<'EOF'
---
headless: true
---
EOF
    cp archetypes/examples/hello_world_client.md
    $example_dir/hello_world_client.md
Example hello_world_client is missing for zeromq-haskell. Would you like to contribute it? Then follow the steps below:

    git clone https://github.com/zeromq/zeromq.org
    example_dir=content/docs/examples/haskell/zeromq-haskell
    cd zeromq.org && mkdir -p $example_dir
    [ -s $example_dir/index.md ] || cat >$example_dir/index.md <<'EOF'
---
headless: true
---
EOF
    cp archetypes/examples/hello_world_client.md
    $example_dir/hello_world_client.md
//  Hello World client in Java
//  Connects REQ socket to tcp://localhost:5555
//  Sends "Hello" to server, expects "World" back

import org.zeromq.SocketType;
import org.zeromq.ZMQ;
import org.zeromq.ZContext;

public class hwclient
{
    public static void main(String[] args)
    {
        try (ZContext context = new ZContext()) {
            System.out.println("Connecting to hello world server");

      		//  Socket to talk to server
            ZMQ.Socket socket = context.createSocket(SocketType.REQ);
            socket.connect("tcp://localhost:5555");

            for (int requestNbr = 0; requestNbr != 10; requestNbr++) {
                String request = "Hello";
                System.out.println("Sending Hello " + requestNbr);
                socket.send(request.getBytes(ZMQ.CHARSET), 0);

                byte[] reply = socket.recv(0);
                System.out.println(
                    "Received " + new String(reply, ZMQ.CHARSET) + " " +
                    requestNbr
                );
            }
        }
    }
}
Example hello_world_client is missing for JZMQ. Would you like to contribute it? Then follow the steps below:

    git clone https://github.com/zeromq/zeromq.org
    example_dir=content/docs/examples/java/jzmq
    cd zeromq.org && mkdir -p $example_dir
    [ -s $example_dir/index.md ] || cat >$example_dir/index.md <<'EOF'
---
headless: true
---
EOF
    cp archetypes/examples/hello_world_client.md
    $example_dir/hello_world_client.md
Example hello_world_client is missing for jczmq. Would you like to contribute it? Then follow the steps below:

    git clone https://github.com/zeromq/zeromq.org
    example_dir=content/docs/examples/java/jczmq
    cd zeromq.org && mkdir -p $example_dir
    [ -s $example_dir/index.md ] || cat >$example_dir/index.md <<'EOF'
---
headless: true
---
EOF
    cp archetypes/examples/hello_world_client.md
    $example_dir/hello_world_client.md
Example hello_world_client is missing for zeromqjs. Would you like to contribute it? Then follow the steps below:

    git clone https://github.com/zeromq/zeromq.org
    example_dir=content/docs/examples/nodejs/zeromqjs
    cd zeromq.org && mkdir -p $example_dir
    [ -s $example_dir/index.md ] || cat >$example_dir/index.md <<'EOF'
---
headless: true
---
EOF
    cp archetypes/examples/hello_world_client.md
    $example_dir/hello_world_client.md
Example hello_world_client is missing for perlzmq. Would you like to contribute it? Then follow the steps below:

    git clone https://github.com/zeromq/zeromq.org
    example_dir=content/docs/examples/perl/perlzmq
    cd zeromq.org && mkdir -p $example_dir
    [ -s $example_dir/index.md ] || cat >$example_dir/index.md <<'EOF'
---
headless: true
---
EOF
    cp archetypes/examples/hello_world_client.md
    $example_dir/hello_world_client.md
Example hello_world_client is missing for Pyzmq. Would you like to contribute it? Then follow the steps below:

    git clone https://github.com/zeromq/zeromq.org
    example_dir=content/docs/examples/python/pyzmq
    cd zeromq.org && mkdir -p $example_dir
    [ -s $example_dir/index.md ] || cat >$example_dir/index.md <<'EOF'
---
headless: true
---
EOF
    cp archetypes/examples/hello_world_client.md
    $example_dir/hello_world_client.md
Example hello_world_client is missing for rbzmq. Would you like to contribute it? Then follow the steps below:

    git clone https://github.com/zeromq/zeromq.org
    example_dir=content/docs/examples/ruby/rbzmq
    cd zeromq.org && mkdir -p $example_dir
    [ -s $example_dir/index.md ] || cat >$example_dir/index.md <<'EOF'
---
headless: true
---
EOF
    cp archetypes/examples/hello_world_client.md
    $example_dir/hello_world_client.md
#![crate_name = "helloworld_client"]

//! Hello World client

fn main() {
    println!("Connecting to hello world server...\n");

    let context = zmq::Context::new();
    let requester = context.socket(zmq::REQ).unwrap();

    assert!(requester.connect("tcp://localhost:5555").is_ok());

    let mut msg = zmq::Message::new();

    for request_nbr in 0..10 {
        println!("Sending Hello {}...", request_nbr);
        requester.send("Hello", 0).unwrap();

        requester.recv(&mut msg, 0).unwrap();
        println!("Received World {}: {}", msg.as_str().unwrap(), request_nbr);
    }
}

The client creates a socket of type request, connects and starts sending messages.

Both the send and receive methods are blocking (by default). For the receive it is simple: if there are no messages the method will block. For sending it is more complicated and depends on the socket type. For request sockets, if the high watermark is reached or no peer is connected the method will block.