thread = threading.Thread(target=aja_kertoma, args=(number,))

class Buffer:
    def __init__(self, capacity):
        self.capacity = capacity
        self.contents = []

    def isFull(self):
        return len(self.contents) == self.capacity

    def isEmpty(self):
        return len(self.contents) == 0

    def addItem(self, item):
        if self.isFull():
            raise BufferException("Buffer is already full")
        else:
            self.contents.append(item)

    def removeItem(self):
        if self.isEmpty():
            raise BufferException("Buffer is empty")
        else:
            item = self.contents.pop(0)
            return item

    def print(self):
        print("Buffer has {} items:".format(len(self.contents)))
        for item in self.contents:
            print("  {}".format(item))
        print()

class Producer(threading.Thread):
    def __init__(self, name, factory, productionDelay):
        super().__init__()
        self.name = name
        self.factory = factory
        self.productionDelay = productionDelay
        self.itemCount = 0

    def produceItem(self):
        time.sleep(self.productionDelay)
        item = "<item {} by {}>".format(self.itemCount, self.name)
        self.itemCount += 1
        buffer = self.factory.buffer
        cv = self.factory.conditionVariable
        with cv:
            while buffer.isFull() and factory.isRunning:
                cv.wait()
            if factory.isRunning:
                print("Adding {} to buffer".format(item))
                buffer.addItem(item)
                buffer.print()
                cv.notify()
            else:
                raise FactoryStoppedException

    def run(self):
        try:
            while True:
                self.produceItem()
        except FactoryStoppedException:
            return

class Consumer(threading.Thread):
    def __init__(self, name, factory, consumptionDelay):
        super().__init__()
        self.name = name
        self.factory = factory
        self.consumptionDelay = consumptionDelay

    def consumeItem(self):
        buffer = self.factory.buffer
        cv = self.factory.conditionVariable
        with cv:
            while buffer.isEmpty() and factory.isRunning:
                cv.wait()
            if factory.isRunning:
                item = buffer.removeItem()
                print("Consumer {} removed {} from buffer".format(self.name, item))
                buffer.print()
                cv.notify()
            else:
                raise FactoryStoppedException
        time.sleep(self.consumptionDelay)

    def run(self):
        try:
            while True:
                self.consumeItem()
        except FactoryStoppedException:
            return

class Factory(threading.Thread):
    def __init__(self, bufferCapacity, producerDefinitions, consumerDefinitions, runTime):
        super().__init__()
        self.buffer = Buffer(bufferCapacity)
        self.conditionVariable = threading.Condition()
        self.producers = [ Producer(name, self, delay) for name, delay in producerDefinitions ]
        self.consumers = [ Consumer(name, self, delay) for name, delay in consumerDefinitions ]
        self.runTime = runTime
        self.isRunning = True

    def run(self):
        self.running = True
        for thread in self.consumers + self.producers:
            thread.start()
        time.sleep(self.runTime)
        with self.conditionVariable:
            self.isRunning = False
            print("Stopping factory")
            self.buffer.print()
            self.conditionVariable.notify_all()
        for thread in self.consumers + self.producers:
            thread.join()

if __name__ == "__main__":
    factory = Factory(4, [ ("p1", 1), ("p2", 1), ("p3", 1), ("p4", 1) ], [ ("c", 3) ], 20)
    factory.start()

Adding <item 0 by p1> to buffer
Buffer has 1 items:
  <item 0 by p1>

Adding <item 0 by p2> to buffer
Buffer has 2 items:
  <item 0 by p1>
  <item 0 by p2>

Adding <item 0 by p3> to buffer
Buffer has 3 items:
  <item 0 by p1>
  <item 0 by p2>
  <item 0 by p3>

Adding <item 0 by p4> to buffer
Buffer has 4 items:
  <item 0 by p1>
  <item 0 by p2>
  <item 0 by p3>
  <item 0 by p4>

Consumer c removed <item 0 by p1> from buffer
Buffer has 3 items:
  <item 0 by p2>
  <item 0 by p3>
  <item 0 by p4>

Adding <item 1 by p1> to buffer
Buffer has 4 items:
  <item 0 by p2>
  <item 0 by p3>
  <item 0 by p4>
  <item 1 by p1>

Consumer c removed <item 0 by p2> from buffer
Buffer has 3 items:
  <item 0 by p3>
  <item 0 by p4>
  <item 1 by p1>

Adding <item 1 by p2> to buffer
Buffer has 4 items:
  <item 0 by p3>
  <item 0 by p4>
  <item 1 by p1>
  <item 1 by p2>

Consumer c removed <item 0 by p3> from buffer
Buffer has 3 items:
  <item 0 by p4>
  <item 1 by p1>
  <item 1 by p2>

Adding <item 1 by p4> to buffer
Buffer has 4 items:
  <item 0 by p4>
  <item 1 by p1>
  <item 1 by p2>
  <item 1 by p4>

Consumer c removed <item 0 by p4> from buffer
Buffer has 3 items:
  <item 1 by p1>
  <item 1 by p2>
  <item 1 by p4>

Adding <item 1 by p3> to buffer
Buffer has 4 items:
  <item 1 by p1>
  <item 1 by p2>
  <item 1 by p4>
  <item 1 by p3>

Consumer c removed <item 1 by p1> from buffer
Buffer has 3 items:
  <item 1 by p2>
  <item 1 by p4>
  <item 1 by p3>

Adding <item 2 by p1> to buffer
Buffer has 4 items:
  <item 1 by p2>
  <item 1 by p4>
  <item 1 by p3>
  <item 2 by p1>

Consumer c removed <item 1 by p2> from buffer
Buffer has 3 items:
  <item 1 by p4>
  <item 1 by p3>
  <item 2 by p1>

Adding <item 2 by p2> to buffer
Buffer has 4 items:
  <item 1 by p4>
  <item 1 by p3>
  <item 2 by p1>
  <item 2 by p2>

Consumer c removed <item 1 by p4> from buffer
Buffer has 3 items:
  <item 1 by p3>
  <item 2 by p1>
  <item 2 by p2>

Adding <item 2 by p4> to buffer
Buffer has 4 items:
  <item 1 by p3>
  <item 2 by p1>
  <item 2 by p2>
  <item 2 by p4>

Stopping factory
Buffer has 4 items:
  <item 1 by p3>
  <item 2 by p1>
  <item 2 by p2>
  <item 2 by p4>