Google App Engine JDO会产生持续的延迟 [英] Google App Engine JDO makePersistent latency

问题描述

我无法弄清楚Google App Engine JDO的实施有问题。文档（ http：//代码。 google.com/intl/sv-SE/appengine/docs/java/datastore/jdo/creatinggettinganddeletingdata.html ）指出对makePersistent（）的调用是同步的，直到保存对象才会返回并且索引更新。但我的经历不同。

我想将（makePersistent）对象保存到数据存储中。保存完成后，我希望能够立即从数据存储中读取（查询执行）。我知道我不必获取它（因为我已经在内存中拥有该对象），但重点是我希望下一个请求能够从数据存储中检索数据。如果第二个请求足够快，那么这不适用于当前的实现。

我注意到的一件奇怪事情是，如果我试图从数据存储器在循环（代码如下）中几次返回非常快（通常<10ms）。但是如果我跳过循环，而是在makePersistent和查询执行之间运行Thread.sleep（..）5000毫秒，则不确定是否找到该对象。这些解决方案都不是我想要的。我希望能够在没有睡眠或循环之间的情况下立即获取数据。

访问下面的DataStoreTestServlet的代码和结果如您所见，包括等待查找数据的循环。再次，我不想要循环。

有人知道我错过了什么吗？我想它必须是某种东西。这个实现不适合我:)。

我使用appengine-java-sdk-1.6.0。这是本地（开发服务器）和部署在Google服务器上的问题。

这是访问servlet的结果。

 创建用户：
 User [password = password，userName = user1321190966416]花了18ms，2个循环
 User [password = password， username = user1321190966438]花了15ms，6个循环
用户[password = password，userName = user1321190966456]花了2ms，1个循环
用户[password = password，userName = user1321190966460]花了10ms ，5循环
用户[密码=密码，用户名= user1321190966472]花了0ms，1个循环
用户[密码=密码，用户名= user1321190966472]花了0ms，1个循环（s） 
 User [password = password，userName = user1321190966472]花了16ms，1个循环
用户[password = password，userName = user1321190966488]花了0ms，2个循环
 User [密码=密码，userName = user1321190966488]花了0ms，1个循环
用户[密码=密码，userName = user1321190966488]花了16ms，1个循环
  

代码和配置。

jdoconfig.xml

 <？xml version =1.0encoding =utf-8？> 
< jdoconfig xmlns =http://java.sun.com/xml/ns/jdo/jdoconfigxmlns：xsi =http://www.w3.org/2001/XMLSchema-instancexsi ：noNamespaceSchemaLocation = http://java.sun.com/xml/ns/jdo/jdoconfig > 
< persistence-manager-factory name =transactions-optional> 
< property name =javax.jdo.PersistenceManagerFactoryClassvalue =org.datanucleus.store.appengine.jdo.DatastoreJDOPersistenceManagerFactory/> 
< property name =javax.jdo.option.ConnectionURLvalue =appengine/> 
< property name =javax.jdo.option.NontransactionalReadvalue =true/> 
< property name =javax.jdo.option.NontransactionalWritevalue =true/> 
< property name =javax.jdo.option.RetainValuesvalue =true/> 
< property name =datanucleus.appengine.autoCreateDatastoreTxnsvalue =true/> 
< property name =datanucleus.appengine.datastoreReadConsistencyvalue =STRONG/> 
< / persistence-manager-factory> 
< / jdoconfig> 
  

PMF.java

  import javax.jdo.JDOHelper; 
 import javax.jdo.PersistenceManagerFactory; 
 
 public final class PMF {
 private static final PersistenceManagerFactory pmfInstance = JDOHelper.getPersistenceManagerFactory（transactions-optional）; 
 
 private PMF（）{$​​ b $ b} 
 
 public static PersistenceManagerFactory get（）{
 return pmfInstance; 
 
 
 $ / code $ / pre 
 $ b $ User.java 
 
 
  import javax.jdo.annotations.IdentityType; 
 import javax.jdo.annotations.PersistenceCapable; 
 import javax.jdo.annotations.Persistent; 
 import javax.jdo.annotations.PrimaryKey; 
 
 @PersistenceCapable（identityType = IdentityType.APPLICATION）
 public class User {
 @PrimaryKey 
 @Persistent 
 private String userName; 
 
 @Persistent 
私人字符串密码; 
 $ b public User（String userName，String password）{
 super（）; 
 this.setUserName（userName）; 
 this.setPassword（password）; 
} 
 
 public String getUserName（）{
 return userName; 
} 
 
 public String getPassword（）{
 return password; 
} 
 
 public void setUserName（String userName）{
 this.userName = userName; 
} 
 
 public void setPassword（String password）{
 this.password = password; 
 
 $ b $ public String toString（）{
 returnUser [password =+ password +，userName =+ userName +]; 
 
 
 $ / code $ / pre 
 
 DataStoreTestServlet.java 
 
 
  import java.io.IOException; 
 import java.util.List; 
 import javax.jdo.PersistenceManager; 
 import javax.jdo.Query; 
 import javax.servlet.http.HttpServlet; 
 import javax.servlet.http.HttpServletRequest; 
 import javax.servlet.http.HttpServletResponse; 
 
 @SuppressWarnings（serial）
 public class DataStoreTestServlet extends HttpServlet {$ b $ public void doGet（HttpServletRequest req，HttpServletResponse resp）throws IOException {
 StringBuffer sb = new的StringBuffer（）; 
 sb.append（Created users：\\\
）; 
 
 for（int i = 0; i <10; i ++）{
 String uniqueName =user+ System.currentTimeMillis（）; 
用户用户=新用户（唯一名称，密码）; 
 save（user）; 
 
 User userFromDS = null; 
 long startTime = System.currentTimeMillis（）; 
长循环= 0; 
 while（userFromDS == null）{
 userFromDS = get（uniqueName）; 
 loop ++; 
 if（userFromDS！= null）{
 long endTime = System.currentTimeMillis（）; 
 sb.append（userFromDS.toString（）+took+（endTime  -  startTime）+ms，+ loop +loop（s）\\\
）; 
} 
} 
} 
 resp.setContentType（text / plain）; 
 resp.getWriter（）。println（sb.toString（））; 
} 
 
 public Object save（Object obj）{
 PersistenceManager pm = PMF.get（）。getPersistenceManager（）; 
 Object savedObject = null; 
尝试{
 savedObject = pm.makePersistent（obj）; 
} finally {
 pm.close（）; 
} 
 return savedObject; 
} 
 
 public User get（String userName）{
 User user = null; 
列表<用户> users = null; 
 PersistenceManager pm = PMF.get（）。getPersistenceManager（）; 
 Query query = pm.newQuery（User.class）; 
 query.setFilter（userName == nameParam）; 
 query.declareParameters（String nameParam）; 
尝试{
 users =（List< User>）query.execute（userName）; 
 if（users！= null&& users.size（）> 0）{
 user = users.get（0）; 
} 
} finally {
 query.closeAll（）; 
 pm.close（）; 
} 
返回用户; 
} 
} 
  
 
 
解决方案
在你的jdoconfig.xml文件中加入： 
 
 
 < property name =datanucleus.appengine.datastoreReadConsistencyvalue =STRONG/ > 
  
增加表现;应用引擎数据存储最终一致。这意味着当你制作新的物体或改变现有的物体时，它不会马上显示;可以在查找时间中提高性能。与此相反的是STRONG一致性，意味着每个请求都是使用数据存储中的最新数据制作的。
 
 
 
现在，根据此应用程序引擎文档 STRONG一致是默认设置，您必须明确设置最终的一致性。但是，从我观察到的，你必须设置STRONG一致性，EVENTUAL是默认的（错误也许？）。因此，请尝试将上述内容添加到您的jdoconfig xml中，如果您观察到我做过的同样的事情，那么我可能会打开一个针对应用引擎的错误，假设此问题尚未打开。
 
 
 
您必须记住的一件事是，如果您设置STRONG一致性，那么您将会受到性能影响。我只是设置它，因为我的界面有些部分被搞乱了，因为我会用一些不太新鲜的数据来构建它的一部分，并且在相同的请求中，另一部分会用新的数据构建;使我的界面不一致。这可能是解决问题的一种广泛方法;但它的工作原理：）。
 
I have a problem with the Google App Engine JDO implementation that I cannot figure out. The documentation (http://code.google.com/intl/sv-SE/appengine/docs/java/datastore/jdo/creatinggettinganddeletingdata.html) states "The call to makePersistent() is synchronous, and doesn't return until the object is saved and indexes are updated." but my experience differs. 

I want to save (makePersistent) an object into the datastore. When the save is complete I want to be able to fetch it (Query execute) from the datastore immediately. I know that I don't have to fetch it (because I already have the object in memory) but the point is that I want the next request to be able to retrieve the data from the datastore. That is not working with the current implementation if the second request is fast enough.

One strange thing I've noticed is that if I'm trying to fetch the object from the datastore a couple of times in a loop (code below) the object is returned really quick (usually < 10ms). But if I skip the loop and instead run Thread.sleep(..) for 5000 ms between makePersistent and query execute it's not certain that the object is found. None of these solutions are what I want. I want to be able to fetch the data right away without a sleep or loop in between.

The code and the result from accessing the DataStoreTestServlet below is as you can see including the loop that is "waiting" for the data to be found. Again, I don't want the loop.

Does anyone know what I'm missing? I guess it has to be something. This implementation doesn't feel right to me :). 

I'm using appengine-java-sdk-1.6.0. This is an issue both locally (development server) and when deployed on the Google servers.

Here's the result from accessing the servlet.
Created users:
User [password=password, userName=user1321190966416] took 18ms, 2 loop(s)
User [password=password, userName=user1321190966438] took 15ms, 6 loop(s)
User [password=password, userName=user1321190966456] took 2ms, 1 loop(s)
User [password=password, userName=user1321190966460] took 10ms, 5 loop(s)
User [password=password, userName=user1321190966472] took 0ms, 1 loop(s)
User [password=password, userName=user1321190966472] took 0ms, 1 loop(s)
User [password=password, userName=user1321190966472] took 16ms, 1 loop(s)
User [password=password, userName=user1321190966488] took 0ms, 2 loop(s)
User [password=password, userName=user1321190966488] took 0ms, 1 loop(s)
User [password=password, userName=user1321190966488] took 16ms, 1 loop(s)
The code and configuration.

jdoconfig.xml
<?xml version="1.0" encoding="utf-8"?>
<jdoconfig xmlns="http://java.sun.com/xml/ns/jdo/jdoconfig" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="http://java.sun.com/xml/ns/jdo/jdoconfig">
<persistence-manager-factory name="transactions-optional">
<property name="javax.jdo.PersistenceManagerFactoryClass" value="org.datanucleus.store.appengine.jdo.DatastoreJDOPersistenceManagerFactory"/>
<property name="javax.jdo.option.ConnectionURL" value="appengine"/>
<property name="javax.jdo.option.NontransactionalRead" value="true"/>
<property name="javax.jdo.option.NontransactionalWrite" value="true"/>
<property name="javax.jdo.option.RetainValues" value="true"/>
<property name="datanucleus.appengine.autoCreateDatastoreTxns" value="true"/>
<property name="datanucleus.appengine.datastoreReadConsistency" value="STRONG" />
</persistence-manager-factory>
</jdoconfig>
PMF.java
import javax.jdo.JDOHelper;
import javax.jdo.PersistenceManagerFactory;

public final class PMF {
    private static final PersistenceManagerFactory pmfInstance = JDOHelper.getPersistenceManagerFactory("transactions-optional");

    private PMF() {
    }

    public static PersistenceManagerFactory get() {
        return pmfInstance;
    }
}
User.java
import javax.jdo.annotations.IdentityType;
import javax.jdo.annotations.PersistenceCapable;
import javax.jdo.annotations.Persistent;
import javax.jdo.annotations.PrimaryKey;

@PersistenceCapable(identityType = IdentityType.APPLICATION)
public class User {
    @PrimaryKey
    @Persistent
    private String userName;

    @Persistent
    private String password;

    public User(String userName, String password) {
        super();
        this.setUserName(userName);
        this.setPassword(password);
    }

    public String getUserName() {
        return userName;
    }

    public String getPassword() {
        return password;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public String toString() {
        return "User [password=" + password + ", userName=" + userName + "]";
    }
}
DataStoreTestServlet.java
import java.io.IOException;
import java.util.List;
import javax.jdo.PersistenceManager;
import javax.jdo.Query;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

@SuppressWarnings("serial")
public class DataStoreTestServlet extends HttpServlet {
    public void doGet(HttpServletRequest req, HttpServletResponse resp) throws IOException {
        StringBuffer sb = new StringBuffer();
        sb.append("Created users:\n");

        for (int i = 0; i < 10; i++) {
            String uniqueName = "user" + System.currentTimeMillis();
            User user = new User(uniqueName, "password");
            save(user);

            User userFromDS = null;
            long startTime = System.currentTimeMillis();
            long loop = 0;
            while (userFromDS == null) {
                userFromDS = get(uniqueName);
                loop++;
                if (userFromDS != null) {
                    long endTime = System.currentTimeMillis();
                    sb.append(userFromDS.toString() + " took " + (endTime - startTime) + "ms, " + loop + " loop(s)\n");
                }
            }
        }
        resp.setContentType("text/plain");
        resp.getWriter().println(sb.toString());
    }

    public Object save(Object obj) {
        PersistenceManager pm = PMF.get().getPersistenceManager();
        Object savedObject = null;
        try {
            savedObject = pm.makePersistent(obj);
        } finally {
            pm.close();
        }
        return savedObject;
    }

    public User get(String userName) {
        User user = null;
        List<User> users = null;
        PersistenceManager pm = PMF.get().getPersistenceManager();
        Query query = pm.newQuery(User.class);
        query.setFilter("userName == nameParam");
        query.declareParameters("String nameParam");
        try {
            users = (List<User>) query.execute(userName);
            if (users != null && users.size() > 0) {
                user = users.get(0);
            }
        } finally {
            query.closeAll();
            pm.close();
        }
        return user;
    }
}

解决方案
Try adding this in your jdoconfig.xml:
<property name="datanucleus.appengine.datastoreReadConsistency" value="STRONG" />
To increase performance; the app engine datastore is "eventually consistent".  This means that when you make new objects or alter existing ones, it doesn't show up right away; allowing for performance gains in lookup times.  The opposite of this is "STRONG" consistency, meaning every request is made using the most recent data in the datastore.

Now, according to the app engine documentation for this STRONG consistent is the default, and you have to explicitly set eventual consistency.  But, from what I've observed, you have to set STRONG consistency and EVENTUAL is the default (bug maybe?).  So try adding the above to your jdoconfig xml and if you observe the same thing I did then I'll probably open a bug against app engine, assuming one hasn't been opened already for this issue.

The one thing you're going to have to keep in mind is that if you set STRONG consistency, you're going to take a performance hit.  I only set it because there were parts of my interface that were getting messed up because I would build a piece of it with not so fresh data, and during the same request another piece would get built with fresh data; making my interface inconsistent.  This might be a broad approach to fixing the problem; but it works :).

                        
这篇关于Google App Engine JDO会产生持续的延迟的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！