class Item(object): def __init__(self, name, value): super(Item, self).__init__() self._name = name self._value = value self.wrlock = Lock() @property def name(self): return self._name #Item的属性,相当于read @property def value(self): self.wrlock.acquire_read() print("acquire") res = self._value self.wrlock.release() print("release") return res @value.setter def value(self, value): self.write(value) def read(self): pass def write(self, value): self.wrlock.acquire_write() print("acquire write") self._value = value time.sleep(3) self.wrlock.release() print("release") def withdraw(self, value): time.sleep(2) self.wrlock.acquire_write() self._value = str(int(self.value) - int(value)) time.sleep(1) self.wrlock.release()
class HttpServer(BaseParameterServer): """HttpServer Flask HTTP server. Defines two routes, `/parameters` to GET current parameters held by this server, and `/update` which can be used to POST updates. """ def __init__(self, model, optimizer, mode, port=4000, debug=True, threaded=True, use_reloader=True): """Initializes and HTTP server from a serialized Keras model, elephas optimizer, a parallelisation mode and a port to run the Flask application on. In hogwild mode no read- or write-locks will be acquired, in asynchronous mode this is the case. :param model: Serialized Keras model :param optimizer: Elephas optimizer :param mode: parallelization mode, either `asynchronous` or `hogwild` :param port: int, port to run the application on :param debug: boolean, Flask debug mode :param threaded: boolean, Flask threaded application mode :param use_reloader: boolean, Flask `use_reloader` argument """ self.master_network = dict_to_model(model) self.mode = mode self.master_url = None self.optimizer = optimizer self.port = port if is_running_in_notebook(): self.threaded = False self.use_reloader = False self.debug = False else: self.debug = debug self.threaded = threaded self.use_reloader = use_reloader self.lock = Lock() self.pickled_weights = None self.weights = self.master_network.get_weights() self.server = Process(target=self.start_flask_service) def start(self): self.server.start() self.master_url = determine_master(self.port) def stop(self): self.server.terminate() self.server.join() def start_flask_service(self): """Define Flask parameter server service. This HTTP server can do two things: get the current model parameters and update model parameters. After registering the `parameters` and `update` routes, the service will get started. """ app = Flask(__name__) self.app = app @app.route('/') def home(): return 'Elephas' @app.route('/parameters', methods=['GET']) def handle_get_parameters(): if self.mode == 'asynchronous': self.lock.acquire_read() self.pickled_weights = pickle.dumps(self.weights, -1) pickled_weights = self.pickled_weights if self.mode == 'asynchronous': self.lock.release() return pickled_weights @app.route('/update', methods=['POST']) def handle_update_parameters(): delta = pickle.loads(request.data) if self.mode == 'asynchronous': self.lock.acquire_write() if not self.master_network.built: self.master_network.build() def base_constraint(a): return a constraints = [base_constraint for _ in self.weights] self.weights = self.optimizer.get_updates(self.weights, constraints, delta) if self.mode == 'asynchronous': self.lock.release() return 'Update done' # self.app.run(host='0.0.0.0', debug=self.debug, port=self.port, # threaded=self.threaded, use_reloader=self.use_reloader) from werkzeug.serving import run_simple run_simple(self.master_url.split(':')[0], self.port, self.app)