strategy.rs

use std::sync::{Arc, Mutex};
use std::vec::Vec;

trait Queue<T> {
    fn new() -> Self where Self:Sized;
	fn enqueue(&mut self, item:T);
}

#[derive(Debug)]
struct FIFOQueue<T>{
    data: Vec<T>,
}

impl<T> Queue<T> for FIFOQueue<T> {
    fn new() -> Self {
        FIFOQueue {
            data: Vec::new(),
        }
    }
	fn enqueue(&mut self, item: T) {
        self.data.push(item);
	}
}

struct FILOQueue<T>{
    data: Vec<T>,
}

impl<T> Queue<T> for FILOQueue<T> {
    fn new() -> Self {
        FILOQueue {
            data: Vec::new(),
        }
    }
	fn enqueue(&mut self, item: T) {
        self.data.push(item);
	}
}

struct Worker<'a, T> {
	queue: Arc<Mutex<Queue<T> + 'a>>,
}

impl<'a, T> Worker<'a, T> {
	fn enqueue(&self, item: T) {
		(*self.queue.lock().unwrap()).enqueue(item);
	}
	fn set_queue(&mut self, queue: Arc<Mutex<Queue<T> + 'a>>) {
		self.queue = queue;
	}
}

fn main() {
    for _ in 1..1000 {
	    let fifo = Arc::new(Mutex::new(FIFOQueue::new()));
	    let filo = Arc::new(Mutex::new(FILOQueue::new()));
	    let mut worker = Worker { queue: fifo.clone() };
        for i in 1..1000{
	        worker.enqueue(i as usize);
        }
	    worker.set_queue(filo.clone());
        for i in 1..1000{
	        worker.enqueue(i as usize);
        }
    }
}