CareerCup

package com.home.careercup;

public class Doubleton {
    private Doubleton() {
    }

    private static int call = 0;
    private static Doubleton[] instances = new Doubleton[]{
            new Doubleton(), new Doubleton()
    };

    public static Doubleton getInstance() {
        return instances[call++ % 2];
    }

    public static void main(String[] args) {
        Doubleton d1 = Doubleton.getInstance();
        Doubleton d2 = Doubleton.getInstance();
        for (int i=0;i<10;i++){
            if ( i%2 ==0)
                System.out.println(d1 == Doubleton.getInstance());
            else
                System.out.println(d2 == Doubleton.getInstance());

        }
    }
}

Makarand, I believe your code is faulty, and gravely so. Read more about :
[ journaldev.com/171/thread-safety-in-java-singleton-classes-with-example-code ]

public class Doubleton {

private static volatile Doubleton _instance1;
private static volatile Doubleton _instance2;

private static int count = 0;

private Doubleton() {

}

public static Doubleton getInstance() {
if (count++ % 2 == 0) {
if (_instance1 == null) {

synchronized (Doubleton.class) {
if (_instance1 == null) {
_instance1 = new Doubleton();
}
}
}

return _instance1;
} else {
if (_instance2 == null) {

synchronized (Doubleton.class) {
if (_instance2 == null) {
_instance2 = new Doubleton();
}
}
}

return _instance2;

}
}
}

@NoOne I notice that the variable 'call' needs protection. So making getInstance() synchronized should fix this. Thanks for pointing this out.

#include <iostream>
#include <vector>
#include <stdio.h>

class multiTon
{
private:

static std::vector<multiTon *> obj;

int id;

static int counter;

public:

multiTon(int Identity)
{
id = Identity;
}

~multiTon()
{
}

static multiTon * getInstance()
{
return obj[counter++ % 2];
}

int getId()
{
return id;
}
};

int multiTon::counter = 0;
std::vector<multiTon *> multiTon::obj {new multiTon(0), new multiTon(1)};

int main()
{
printf ("%d \n",multiTon::getInstance()->getId());
printf ("%d \n",multiTon::getInstance()->getId());
printf ("%d \n",multiTon::getInstance()->getId());
printf ("%d \n",multiTon::getInstance()->getId());
printf ("%d \n",multiTon::getInstance()->getId());
}

#include <iostream>
#include <vector>
#include <stdio.h>

class multiTon
{
    private:
    
    static std::vector<multiTon *> obj;
    
    int id;
    
    static int counter;
    
    public:
    
    multiTon(int Identity)
    {
        id = Identity;
    }
    
    ~multiTon()
    {
    }
    
    static multiTon * getInstance()
    {
        return obj[counter++ % 2];
    }
    
    int getId()
    {
        return id;
    }
};

int multiTon::counter = 0;
std::vector<multiTon *> multiTon::obj {new multiTon(0), new multiTon(1)};

int main()
{
    printf ("%d \n",multiTon::getInstance()->getId());
    printf ("%d \n",multiTon::getInstance()->getId());
    printf ("%d \n",multiTon::getInstance()->getId());
    printf ("%d \n",multiTon::getInstance()->getId());
    printf ("%d \n",multiTon::getInstance()->getId());
}

#include <iostream>
#include <vector>
#include <stdio.h>

class multiTon
{
    private:
    
    static std::vector<multiTon *> obj;
    
    int id;
    
    static int counter;
    
    public:
    
    multiTon(int Identity)
    {
        id = Identity;
    }
    
    ~multiTon()
    {
    }
    
    static multiTon * getInstance()
    {
        return obj[counter++ % 2];
    }
    
    int getId()
    {
        return id;
    }
};

int multiTon::counter = 0;
std::vector<multiTon *> multiTon::obj {new multiTon(0), new multiTon(1)};

int main()
{
    printf ("%d \n",multiTon::getInstance()->getId());
    printf ("%d \n",multiTon::getInstance()->getId());
    printf ("%d \n",multiTon::getInstance()->getId());
    printf ("%d \n",multiTon::getInstance()->getId());
    printf ("%d \n",multiTon::getInstance()->getId());
}

package designpattern;

public class DoubleTon {

final static private DoubleTon instance1=new DoubleTon();
final static private DoubleTon instance2=new DoubleTon();

static private int counter=0;

private DoubleTon(){

}

static public DoubleTon getInstance(){

counter++;
if(counter%2==0){
System.out.println("instance1");
return instance1;
}

return instance2;

}
}

Isn't this the same an object-pool (generalization of a connection pool)?

public class Car {

    private static Car instance = null;

    private Car() {}

    public static Car getInstance() {
        if (instance == null) {
            synchronized(Car.class) {
                if (instance == null) {
                    instance = new Car();
                }
            }
        }
        return instance;
    }
}

public class Car {

    private static Car instance = null;

    private Car() {}

    public static Car getInstance() {
        if (instance == null) {
            synchronized(Car.class) {
                if (instance == null) {
                    instance = new Car();
                }
            }
        }
        return instance;
    }
}

public class Car {

    private static Car instance = null;

    private Car() {}

    public static Car getInstance() {
        if (instance == null) {
            synchronized(Car.class) {
                if (instance == null) {
                    instance = new Car();
                }
            }
        }
        return instance;
    }
}

public class Car {

private static Car instance = null;

private Car() {}

public static Car getInstance() {
if (instance == null) {
synchronized(Car.class) {
if (instance == null) {
instance = new Car();
}
}
}
return instance;
}
}