One producer multiple consumers

First of all it would be good to use the standard Java Conventions, i.e. method names start with a lower case letter. i.e. StartconsumerProducer shold either be startconsumerProducer or simply run.

Also handle InterruptedException correctly. For details have a look at the book Java Concurrency in Practice

In your case it does not make sense to catch the InterruptedException you can simply declare it as thrown.

The ArrayList for the threads is not necessary, you have a fix number of Threads, you can replace it by an Array.

public static void main(String[] args) throws InterruptedException {
    ConsumerProducer cp = new ConsumerProducer();
    cp.run();
}

You are not really waiting for all threads to fininsh. If one of your threads run in an timeout you simply ignore it. You can fix this by stetting a flag that signals your thread to terminate.

I've done this by adding a class Terminatable which Consumer and Producer extend and which have a flag that signals them to terminate as soon as possible.

Your ConsumerProducerMonitor contains only one value which is overwritten by the Producer Loop via the put method, nothing prevents this. The notifyAll calls are useless because nobody actually waits for the ConsumerProducerMonitor

There are a lot of issues in your code so I've decided to rewrite it in a way that actually works.

It uses a Queue to transport the elements Elem from the Producer to the Consumer

The Producer notifies any waiting Consumer via notifyAll about new Elements.

The Consumer uses an Index to determine whether he should pull elements from the queue and increments the shouldRun after he has taken the 10 elements from the queue.

In the Consumer I give you an example how the wait() in Java can be used, and a possible way how to deal with InterruptedExcpetions.

import java.util.Arrays;
import java.util.List;
import java.util.Queue;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.atomic.AtomicInteger;

public class ConsumerProducer {

    public static void main(String[] args) throws InterruptedException {
        ConsumerProducer cp = new ConsumerProducer();
        cp.run();
    }

       // Creates Threads and waits for them to finish till timeout
        private LinkedBlockingQueue<Elem> queue = new LinkedBlockingQueue<>();

        public void run() throws InterruptedException {
            Terminatable[] terminateables = new Terminatable[] {
                    new Producer(queue), new Consumer(queue),
                    new Consumer(queue), new Consumer(queue), };

            startThreads(terminateables);
            join(terminateables);
        }

        private static void join(Terminatable[] terminatables)
                throws InterruptedException {
            List<Terminatable> maybeNotTerminated = Arrays
                    .asList(terminatables);

            while (!maybeNotTerminated.isEmpty()) {
                for (int idx = maybeNotTerminated.size() - 1; idx >= 0; --idx) {
                    Terminatable t = maybeNotTerminated.get(idx);
                    if (t.isAlive()) {
                        t.join(20_000);
                        // force termination
                        t.terminate = true;
                    } else {
                        maybeNotTerminated.remove(idx);
                    }
                }
            }
        }

        private static void startThreads(Runnable[] runnables) {
            for (int i = 0; i < runnables.length; i++) {
                new Thread(runnables[i]).start();
            }
        }

    static abstract private class Terminatable implements Runnable {
        volatile boolean terminate = false;

        public boolean isAlive() {
            return Thread.currentThread().isAlive();
        }

        public void join(long millis) throws InterruptedException {
            Thread.currentThread().join(millis);
        }
    }

    static private class Elem {
        public final int idx;
        public final String name;

        public Elem(int i, String name) {
            this.idx = i;
            this.name = name;
        }
    }

    // Producer class
    static private class Producer extends Terminatable implements Runnable {

        private Queue<Elem> queue;

        Producer(Queue<Elem> queue) {
            this.queue = queue;
        }

        @Override
        public void run() {
            for (int i = 0; i <= 100; ++i) {
                Elem e = new Elem(i, Thread.currentThread().getName());                 
                queue.offer(e);

                synchronized (queue) {
                    queue.notifyAll();
                }

            }
        }
    }

    // Consumer Class
    static private class Consumer extends Terminatable implements Runnable {

        private Queue<Elem> queue;
        private final int myIdx;
        private static int consumerCounter = 0;
        private static AtomicInteger shouldRun = new AtomicInteger(0);

        public Consumer(Queue<Elem> queue) {
            this.queue = queue;
            myIdx = consumerCounter;
            consumerCounter++;
        }


        @Override
        // very long with two nested loops
        // should be refactored.
        public void run() {
            while (!terminate) {
                for (int idx = 0; idx < 10; ++idx) {                
                    try {
                        // wait until elements are produced
                        do {
                            if (queue.isEmpty()) {
                                synchronized (queue) {
                                    queue.wait(100);
                                }
                            }
                        } while (shouldRun.get() != myIdx);
                        // continue only if this consumer should execute
                        Elem elem = queue.poll();
                        if (elem != null) {
                            System.out.println("Thread "
                                    + Thread.currentThread().getName()
                                    + " fetch Element " + elem.idx);
                        }
                    } catch (InterruptedException ie) {
                        Thread.currentThread().interrupt();
                    }

                }

                // allow the next consumer to run
                shouldRun.set((myIdx + 1) % consumerCounter);               
            }

        }

    }
}