MyInterface instance = new MyInterfaceSingleton(...);
container.bind(MyInterface.class, instance); 
...
MyInterface instance = container.get(MyInterface.class);

container.bind(MyInterface.class, new MyInterfaceMock());

container.bindFactory(MyInterface.class, new MyInterfaceFactory()); // на каждое обращение к get возвращает новый объект

ACL acl = ...
// создает один объект на нить, возвращает объект с контролем доступа в ACL
container.bind(MyInterface.class, new MyInterfaceFactory(), ThreadPolicy.LOCAL, acl);

K>2) Приведите хотя бы пару примеров где РЕАЛЬНО помогает реализация данного паттерна?
Там, где гарантированно должен существовать только один экземпляр класса.

B>MyInterface instance = new MyInterfaceSingleton(...);
B>container.bind(MyInterface.class, instance); 
B>...
B>MyInterface instance = container.get(MyInterface.class);
B>

B>container.bind(MyInterface.class, new MyInterfaceMock());
B>

IMyInterface instance = mocks.CreateMock<IMyInterface>();
Expect.Call(instance.SomeProperty).Return("Some property value");

WH>Но ее API такое что

HANDLE StartJpeg();
void StopJpeg(HANDLE hLibrary);
void SaveJpeg(HANDLE hLibrary, string path, LPVOID lpData);
void LoadJpeg(HANDLE hLibrary, string path, LPVOID * lplpData);

class JpegReader
{
   void LoadJpeg(string path, LPVOID * lplpData);
}

class JpegWriter
{
   void SaveJpeg(string path, LPVOID lpData);
}

WH>А может ты просто не видел действительно хороших?

public class UpdaterForm : System.Windows.Forms.Form
{
    private static UpdaterForm pInstance;
    ...
    public static UpdaterForm GetInstance()
    {
        if (pInstance == null || pInstance.IsDisposed)
            pInstance = new UpdaterForm();
        else
        {
            // Форма "мигает" чтобы пользователь видел что она уже открыта
            pInstance.WindowState = FormWindowState.Minimized;
            pInstance.WindowState = FormWindowState.Normal;
        }
        return pInstance;
    }

    private UpdaterForm()
    {
        InitializeComponent();
    }
    ...
}

    UpdaterForm p = UpdaterForm.GetInstance();
    p.MdiParent = MDIParent;
    p.Show();

kuj>В том, что не надо делать new.

    public abstract class HomeBase
    {
        private static HomeBase instanceBase;
        protected internal static HomeBase InstanceBase
        {
            internal get
            {
                return instanceBase;
            }
            set
            {
                instanceBase = value;
            }
        }

        public abstract string[] GetLanguageCodes();

        //тут может быть много абстрактных и не авбстрактных методов
    }

    public class Home : HomeBase
    {
        private Home()
        {
        }

        private static Home instance = new Home();
        public static Home Instance
        {
            get
            {
                return instance;
            }
        }

        public void Init()
        {
            InstanceBase = this;
        }

        public override string[] GetLanguageCodes()
        {
            throw new NotImplementedException();
        }

        //...
    }

Home.Instance.Init();

kuj>IMyInterface instance = mocks.CreateMock<IMyInterface>();
kuj>Expect.Call(instance.SomeProperty).Return("Some property value");
kuj>

public class MyClass
{
   public void DoSomething()
   {
      ...
      PrinterSpoolerSingleton.Print();
      ...
   }
}

    <component name="daemon-logger" type="logger:logger">
      <level>DEBUG</level>
      <file>../daemon.log</file>
    </component>
...

WH>Не придется.

struct Container
{
    public Service1 x;
    public Service2 y;
}

void Action(Container container);

void Action(Service1 x, Service2 y);

struct Container
{
    public Service1 x;
    public Service2 y;
    public Service11 x1;
    public Service21 y1;
    public Service12 x2;
    public Service22 y2;
}

void Action(Container container);

void Action(Service1 x, Service2 y, Service11 x1, Service21 y1, Service12 x2, Service22 y2);

DateTime dt = DateTime.Now;
string date = dt.Year.ToString() + "/" + dt.Month.ToString().PadRight(2, '0') + "/" + dt.Day.ToString().PadRight(2, '0');

         +------+         +---------+
         |Device|---->----|Collector|
         +------+         +---------+

         +------+         +-----+         +---------+
         |Device|---->----|Relay|---->----|Collector|
         +------+         +-----+         +---------+

         +------+     +-----+            +-----+     +---------+
         |Device|-->--|Relay|-->--..-->--|Relay|-->--|Collector|
         +------+     +-----+            +-----+     +---------+

         +------+         +-----+         +---------+
         |Device|---->----|Relay|---->----|Collector|
         |      |-\       +-----+         +---------+
         +------+  \
                    \      +-----+         +---------+
                     \-->--|Relay|---->----|Collector|
                           +-----+         +---------+

         +------+         +---------+
         |Device|---->----|Collector|
         |      |-\       +---------+
         +------+  \
                    \      +-----+         +---------+
                     \-->--|Relay|---->----|Collector|
                           +-----+         +---------+

         +------+         +-----+            +---------+
         |Device|---->----|Relay|---->-------|Collector|
         |      |-\       +-----+         /--|         |
         +------+  \                     /   +---------+
                    \      +-----+      /
                     \-->--|Relay|-->--/
                           +-----+

1. Сначала ты не знаешь, что нельзя делать то-то
2. Потом знаешь, что нельзя делать то-то
3. Потом ты понимаешь, что иногда таки можно делать то-то
4. Ну а потом ты понимаешь, что помимо того-то существует еще шестьдесять шесть способов добиться желаемого, и все из них практически равноправны.
5. Когда тебя спрашивают "как мне добиться желаемого", ты быстро перебираешь в уме эти шестьдесять шесть способов, прикидываешь то общее, что в них есть, вздыхаешь и говоришь: "вообще-то, главное — гармония."
6. На вопрос обиженных учеников: "а как ее добиться?", ты говоришь: "никогда не делайте то-то".

A>class JpegReader
A>{
A>   void LoadJpeg(string path, LPVOID * lplpData);
A>}

A>class JpegWriter
A>{
A>   void SaveJpeg(string path, LPVOID lpData);
A>}
A>

    namespace Img = CensoredNamespace;

    boost::intrusive_ptr<Img::ImageManager> manager = new Img::ImageManager();
    manager->addProvider(new Img::ImageProviderJpeg(), 10);
    manager->addProvider(new Img::ImageProviderPng(), 10);
    manager->addProvider(new Img::ImageProviderGif(), 10);
    manager->addProvider(new Img::ImageProviderUnknown(new Img::ImageProviderPng()), 0);

    Img::ImagePtr image = manager->loadFromFile(fileName);
    
    image = Img::resize(image, 100, 100);

    manager->saveToFile(image, resizedFileName);

In other words, ULP configuration would not be available at the 'user' level, it would be a system service.