如何使我的代码线程安全？

Question

给定一个带有静态方法的Factory 类为SomeModel 类创建实例，它将在多线程环境中运行。这个Factory有三个方法：

1. 开始
2. 停止
3. createSomeModel

还有一个state 字段，位于：

1. 已关闭
2. 开始
3. starting_failed
4. 开始
5. 关闭
6. shutting_failed

这是Factory 类的当前设计：

public class Factory {

    enum State{
        shutted, starting, starting_failed, started, shutting, shutting_failed
    }

    State state;

    public static void start(){
        // can only be invoked when state=shutted
    }

    public static void stop(){
        // can only be invoked when state=started
    }

    public static void restart(){
        stop();
        start();
    }

    public static SomeModel create(){
        // can only be invoked when state=started
    }
}

我的要求是：create方法只能在state==started时调用，start方法只能在state==shutted || state == shutting_failed时调用，stop方法只能在state==started|| state == starting_failed时调用。

我知道这与线程同步问题有关，但我对自己的线程知识没有信心。请帮帮我。

Answer 1

我建议你根本不要使用静态方法。

相反，创建Factory 类的对象并让所有方法为synchronized。

public enum State{
    shutted, starting, starting_failed, started, shutting, shutting_failed;
}

public class Factory {
    private State state;

    public synchronized void start(){
        if(state != State.shutted) {
            throw new RuntimeException("Can only be invoked when state=shutted");
        }
        // do task
    }

    public synchronized void stop(){
        if(state != State.started) {
            throw new RuntimeException("Can only be invoked when state=started");
        }
        // do task
    }

    public synchronized void restart(){
        stop();
        start();
    }
}

希望这会有所帮助。

Answer 2

无需同步。对状态使用 volatile 或 AtomicReference。 我正在给出使用 volatile 的示例。最好与原始类型一起使用，因此必须为不同的状态添加 int 值。虽然您可以使用枚举的序数，但这样就有点清楚了。否则，您可以使用 AtomicReference。

public class Factory {
    private static volatile int factoryState;

    public synchronized void updateFactoryState(State newState, State ... expectedStates){
        for (State state : expectedStates)
            if(factoryState == State.shutted.getStateVal()){
                factoryState = newState.getStateVal();
        }
    }

    public void start(){
        try{
            updateFactoryState(State.starting, State.shutted, State.shutting_failed);
            System.out.println("steps to start the factory");
            //someExpensiveStartupMethod();
        }catch (Exception e){
            updateFactoryState(State.starting_failed, State.starting);
        }
        updateFactoryState(State.started, State.starting);
    }

    public void stop(){
        try{
            updateFactoryState(State.shutting, State.started, State.starting_failed);
            System.out.println("steps to stop the factory");
            //someExpensiveStopFactoryMethod();
        }catch (Exception e){
            updateFactoryState(State.shutting_failed, State.shutting);
        }
        updateFactoryState(State.shutted, State.shutting);
    }

    public void restart(){
        stop();
        start();
    }
    public static SomeModel create(){
        if(factoryState == State.started.getStateVal()) {
            System.out.println("Create Model");
        }   else{
            throw new RuntimeException("Can not create Model.Factory not in started state.");
        }
        return null;
    }

    enum State{
        shutted(0), starting(1), starting_failed(2), started(3), shutting(4), shutting_failed(5);
        private final int stateVal;

        State(int i) {
            stateVal = i;
        }

        public int getStateVal() {
            return stateVal;
        }
    }

    class SomeModel {}
}

Answer 3

这个方法不同步 create 方法，所以这不会是一个瓶颈。当你停下来时，不要让执行新的创建。 双重检查“if state == started”对于避免竞争条件是必要的。

可能有比使用 Thread.sleep 等待所有创建模型完成更好的解决方案，但我看不出如何轻松完成。

希望对你有帮助。

enum State{
    shutted, starting, starting_failed, started, shutting, shutting_failed
}

private Factory() {
    // singleton: no more than 1 instances allowed
}

public static Factory getInstance() {
    return instance;
}

private static final Factory instance = new Factory();
private final AtomicInteger threadsCreatingModel = new AtomicInteger();
private volatile State state;


public synchronized void start(){
    if(state != State.shutted) {
        throw new RuntimeException("Can only be invoked when state=shutted");
    }
    state = State.starting;
    // TODO: task
}

public synchronized void stop() throws InterruptedException {
    if(state != State.started) {
        throw new RuntimeException("Can only be invoked when state=started");
    }
    state = State.shutting;

    // wait all threads that are creating SomeModel
    while (threadsCreatingModel.intValue() > 0) {
        Thread.sleep(500);
    }
    // TODO: task
}

public SomeModel create(){
    if(state == State.started) {
        threadsCreatingModel.incrementAndGet();
        if(state == State.started) {
            // TODO: task   
        }
        threadsCreatingModel.decrementAndGet();
    }
}