Почему .now()? (Objectify)

Question

Почему я должен когда-либо загружать объект Objectify асинхронно? А что означает асинхронная загрузка?

Согласно Objectify documentation about loading, следующий способ загрузки Субъект является асинхронным:

// Simple key fetch, always asynchronous 
Result<Thing> th = ofy().load().key(thingKey); 

И если я хочу нагрузки выполнять синхронно, то я должен сделать это:

Thing th = ofy().load().key(thingKey).now(); // added .now() 

Для меня, асинхронный означает, что действие будет выполнено позже в какое-то неопределенное время. Для экономии асинхронность имеет смысл, поскольку для работы хранилища данных может потребоваться некоторое время, чтобы закончить самостоятельно, не блокируя код приложения.

Но с нагрузкой асинхронность означает, что нагрузка будет проходить в другое время? Как это возможно в Java? Я думал, что переменная Result<Thing> th должна быть обновлена, когда заканчивается выполнение строки кода Result<Thing> th = ofy().load().key(thingKey);.

В качестве новичка мне понадобилось много времени, чтобы понять это (см., Например, Objectify error "You cannot create a Key for an object with a null @Id" in JUnit).

Поэтому у меня есть несколько вопросов:

1] Почему я всегда хочу, чтобы загрузить объект объективизации асинхронно?

2] Что означает асинхронная загрузка?

3] Какова концептуальная связь между now() для загрузки и now() для экономии?

Синхронный нагрузки (source)

Thing th = ofy().load().key(thingKey).now(); 

Синхронный Сохранить (source)

ofy().save().entity(thing1).now(); 

4] Почему не синхронное поведение по умолчанию для сохранения и загрузки?

Answer 1

Ответ Облако службы поддержки Google, чтобы поддержать случай 05483551:

«Асинхронный» в контексте Java означает, что использование «Futures» или будущее подобных конструкций. Будущее в java [1] - это объект, который представляет операцию, которая необязательно должна выполняться и завершаться к моменту начала следующей строки в текущем потоке.

Вызов асинхронной функции в Java немедленно вернет Будущее, представляя обещание, что фоновый «поток» будет работать при вычислении/сетевом вызове, в то время как следующая строка кода продолжает выполняться, не нуждаясь в этом результате все же. Когда метод .get() вызывается в объекте Future, возвращается либо результат, полученный вовремя, либо поток будет ждать, пока результат не будет получен, передав выполнение следующей строке после вызова .get() только когда это произойдет.

В Objectify фьючерсы были исключены, и вместо этого был определен интерфейс Результата [2] по причинам, связанным с выбросами, которые делали болезненными для развития на основе фьючерсов. Однако они работают почти одинаково. Если у обычного Future есть метод .get(), интерфейс Результата (реализованный несколькими различными конкретными классами, в зависимости от того, какой вызов Objectify вы делаете) имеет .now(), который извлекает результат или ждет поток до тех пор, пока он не будет доступен ,

Причина, по которой вы можете загрузить объект асинхронно, - это когда у вас есть обработчик запроса или метод API, который нуждается в Entity позже в функции, но также имеет и другие вычисления, не связанные с Entity. Вы можете начать загрузку для объекта в первой строке, получить результат, а затем вызвать только вызов .now() в результате, как только ваш другой несвязанный код завершит свое выполнение. Если вы дождались момента, когда вы вызываете .now(), чтобы инициировать загрузку, вы можете использовать метод обработчика ответа/API, просто ожидающий результата, вместо того, чтобы делать полезные вычисления.

Наконец, концептуальная связь между .now() для загрузки и .now() для сохранения заключается в том, что обе операции происходят в фоновом режиме и только окончательно принудительно ждут поток выполнения, когда вызывается .now() на объекте-объекте Result-interface, который возвращается вызовом save() или load().

Надеюсь, это помогло объяснить асинхронные конструкции в Java Objectify для вас. Если у вас есть дополнительные вопросы или проблемы, не стесняйтесь включать их в свой ответ, и я буду рад помочь.

С уважением,

Ник технические решения Представитель Облачная платформа поддержки

[1] http://docs.oracle.com/javase/7/docs/api/java/util/concurrent/Future.html

[2] http://objectify-appengine.googlecode.com/svn/trunk/javadoc/com/googlecode/objectify/Result.html

Answer 2

Google Cloud Datasore был разработан, чтобы дать пользователю положительный реляционный и нереляционный опыт, по существу, лучший из обоих миров. Google datastore - это база данных NoSQL, которая предлагает возможную согласованность для улучшения масштабируемости, но также дает вам возможность выбирать сильную консистенцию.

Данная статья от Google, Balancing Strong and Eventual Consistency with Google Cloud Datastore, поможет вам ответить на некоторые из ваших вопросов. В нем объясняется возможная модель согласованности, которая является ключом к пониманию того, как хранилище данных работает под капотом по отношению к вашему вопросу.

Answer 3

Асинхронные операции запускают сетевую выборку на бэкэнд, а затем позволяют продолжить выполнение кода. Преимущество асинхронных операций является то, что вы можете запустить некоторые из них параллельно:

Result<Thing> th1 = ofy().load().key(thingKey1); 
Result<Thing> th2 = ofy().load().key(thingKey2); 
Result<Thing> th3 = ofy().load().key(thingKey3); 
th1.now(); 
th2.now(); 
th3.now(); 

Это выполняется значительно быстрее, чем вызов now() сразу каждый раз. Обратите внимание, что это плохой пример, потому что вы, вероятно, будете использовать пакетный get (который также распараллеливает операцию), но вы можете одновременно запускать несколько запросов, сохранять, удалять и т. Д.

now() всегда заставляет синхронно завершать, блокировать до конца.