关于无国籍战略的困惑

Question

In Strategy design pattern, stateless strategies are mentioned. Could anyone please help me to understand it by answering following question:

1. What is this stateless strategy ?
2. What problem does it solve and how ?
3. Where to use & not use this ?
4. Dis(a)dvantages for same

And I will highly appreciate if all this could be explained by giving an example.

Answer 1

What is this stateless strategy?

A stateless strategy is one where one "run" of the strategy does not affect another.

Here are two strategies for picking true or false :

public final class FlipStrategy {

    private boolean lastPick;

    public boolean pick() {

        lastPick = !lastPick;

        return lastPick;
    }
}

and...

public final class RandomStrategy {

    public boolean pick() {

        return (new Random()).nextBoolean();
    }
}

FlipStrategy is a stateful-strategy. The result you get depends on previous results.

RandomStrategy is a stateless-strategy. The results you get are independent of each-other.

What problem does it solve and how?

Stateless-strategies...

• can be safely shared without one user altering the results of another
• are (typically) thread-safe, allowing them to be shared between threads
• have less memory overhead, since one instance can be reused multiple times
• can be created on an ad-hoc basis, which can make program architecture simpler

Where to use & not use this?

It is not always possible to use a stateless-strategy. Imagine a strategy for a bouncer - it must remember how many people have already gone in to decide if more should be allowed.

Otherwise, stateless-strategies are better.

Sometimes, you can turn a stateful-strategy into a stateless one using a "context" object. A context object encodes all state relevant to a strategy into a parameter.

In our previous example, the context might be:

public final class Context { 

    private final boolean lastPick;

    public boolean getLastPick() {
         return lastPick;
    }

    public Context(final boolean lastPick) {

        this.lastPick = lastPick;
    }

    // hashCode etc... 
}

Now FlipStrategy can be implemented in a stateless way:

public final class FlipStrategy {

    public boolean pick(final Context context) {

        return !context.getLastPick();
    }
}

The context object is also an arguably cleaner design. The last pick is a property of the world, not the strategy, so it should not be a member of it.