dev 契约锁

P15GEN2\59518

2024-05-29 d4210c7c4b04abde20037ea8aa0f54ef8a2649aa

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
package foundation.engine;
 
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
 
import foundation.monitor.Progressor;
 
 
public abstract class Engine implements Runnable {
    
    protected static Logger logger;
    private Object lock;
    private String operator;
    private Object[] args;
    protected EngineState state;
    protected Progressor progressor;
 
    
    static {
        logger = LogManager.getLogger(Engine.class);
    }
    
    
    public Engine() {
        this.lock = new Object();
        this.state = EngineState.Idle;
        this.progressor = new Progressor();;
    }
    
    public boolean exec(String operator, Object... args) throws Exception {
        if (state == EngineState.Idle) {
            synchronized (lock) {
                if (state == EngineState.Idle) {
                    this.state = EngineState.Working;
                    
                    try {
                        this.operator = operator;
                        this.args = args;
                        
                        sameThreadRun(operator, args);
                        
                        Thread thread = new Thread(this);
                        thread.start();
                        return false;                        
                    }
                    catch (Exception e) {
                        state = EngineState.Idle;
                        throw e;
                    }
                }
                else {
                    return false;
                }
            }
        }
        else {
            return false;
        }
    }
    
    public boolean syncExec(String operator, Object... args) throws Exception {
        if (state == EngineState.Idle) {
            synchronized (lock) {
                if (state == EngineState.Idle) {
                    this.state = EngineState.Working;
                    
                    try {
                        this.operator = operator;
                        this.args = args;
                        
                        sameThreadRun(operator, args);
                        newThreadRun(operator, args);
                        
                        state = EngineState.Idle;
                        return false;                        
                    }
                    catch (Exception e) {
                        state = EngineState.Idle;
                        throw e;
                    }
                }
                else {
                    return false;
                }
            }
        }
        else {
            return false;
        }
    }
    
    @Override
    public void run() {
        try {
            newThreadRun(operator, args);
        }
        finally {
            state = EngineState.Idle;
        }
    }
 
    protected abstract void sameThreadRun(String operator, Object... args) throws Exception;
    
    protected abstract void newThreadRun(String operator, Object... args);
 
    public boolean isEquals(Object obj, String operator) {
        if (obj == null) {
            return false;
        }
        
        String code = String.valueOf(obj);
        return code.equalsIgnoreCase(operator);
    }
    
    public EngineState getState() {
        return state;
    }
 
    public void setStatus(EngineState state) {
        this.state = state;
    }
 
    public boolean isWorking() {
        return EngineState.Working == state;
    }
    
    public boolean isIdle() {
        return EngineState.Idle == state;
    }
 
    public Progressor getProgressor() {
        return progressor;
    }
    
}