Module coalescing_buffer::simple

This is similar to having an atomic variable shared. The only difference is only one receiver thread is allowed.

extern crate coalescing_buffer;

use coalescing_buffer::simple::new_simple_buffer;
use std::thread;
use std::sync::Arc;

fn main(){
    let (sx, rx) = new_simple_buffer::<i32>();

    let sx = Arc::new(sx);
    let sx1 = sx.clone();

    let producer0 = thread::spawn(move || {
        for i in 0..10000000 {
            sx.offer(i);
        }
        sx.offer(-1);
    });

    let producer1 = thread::spawn(move || {
        for i in 0..10000000 {
            sx1.offer(i);
        }
        sx1.offer(-1);
    });

    let consumer = thread::spawn(move || loop {
        if let Some(ref value) = rx.poll() {
            if *value == -1 {
                break;
            }
        }
    });

    let _ = producer0.join();
    let _ = producer1.join();
    let _ = consumer.join();

}

Structs

Receiver
Sender

Functions

new_simple_buffer

Creates a ring buffer and provides a sender(producer) and a receiver(consumer) to send/receive data to/from the buffer. Sender and Receiver can only be access by one thread