내 코드 스레드를 안전하게 만드는 방법은 무엇입니까?

Question

SomeModel 클래스의 인스턴스를 생성하는 정적 메서드를 사용하는 Factory 클래스가 주어지면 다중 스레드 환경에서 실행됩니다.

1. 시작
2. 정지
3. createSomeModel

와에있는 state 필드 :

1. 는
2. 는
을 시작 단열성이 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 
    } 
} 

내 요구 사항은 다음과 같습니다 :

3. 는
4. 는
5. 는

여기 Factory 클래스의 현재 디자인의 shutting_failed 종료

시작 starting_failed create 메소드는 호출 할 수 있습니다 때 state==started 및 start 메서드는 state==shutted || state == shutting_failed 및일 때만 호출 할 수 있습니다.메서드는 state==started|| state == starting_failed 일 때만 호출 할 수 있습니다.

이것이 스레드 동기화 문제와 관련이 있다는 것을 알고 있지만 스레드 지식에 대한 확신이 없습니다. 도와주세요.

Answer 1

이 메서드는 메서드 생성을 동기화하지 않으므로 병목 현상이 발생하지 않습니다. 그리고 당신이 멈추고있는 동안에는 새로운 사형 집행을 허용하지 않습니다. 경쟁 조건을 피하기 위해 "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(); 
    } 
} 

Answer 2

나는 정적 방법을 전혀 사용하지 말 것을 제안합니다.

대신에 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 3

동기화 할 필요가 없습니다. State에는 volatile 또는 AtomicReference를 사용하십시오. 휘발성을 사용하는 샘플 예제를 제공하고 있습니다. 기본 유형을 사용하는 것이 가장 좋으므로 다른 상태에 대해 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 {} 
}