Google App Engine：对内存缓存的并发访问进行单元测试

Question

你们能告诉我一种在 Google App Engine 上模拟对 memcache 的并发访问的方法吗？我正在尝试使用 LocalServiceTestHelpers 和线程，但没有任何运气。每次我尝试在一个线程中访问 Memcache 时，都会收到此错误：

ApiProxy$CallNotFoundException: The API package 'memcache' or call 'Increment()' was not found

我猜是GAE SDK的测试库试图模仿真实环境，因此只为一个线程（运行测试的线程）设置环境，其他线程看不到。

这是一段可以重现问题的代码

package org.seamoo.cache.memcacheImpl;

import org.testng.Assert;
import org.testng.annotations.AfterMethod;
import org.testng.annotations.BeforeMethod;
import org.testng.annotations.Test;

import com.google.appengine.api.memcache.MemcacheService;
import com.google.appengine.api.memcache.MemcacheServiceFactory;
import com.google.appengine.tools.development.testing.LocalMemcacheServiceTestConfig;
import com.google.appengine.tools.development.testing.LocalServiceTestHelper;

public class MemcacheTest {
 LocalServiceTestHelper helper;

 public MemcacheTest() {
  LocalMemcacheServiceTestConfig memcacheConfig = new LocalMemcacheServiceTestConfig();
  helper = new LocalServiceTestHelper(memcacheConfig);
 }

 /**
  * 
  */
 @BeforeMethod
 public void setUp() {
  helper.setUp();
 }

 /**
  * @see LocalServiceTest#tearDown()
  */
 @AfterMethod
 public void tearDown() {
  helper.tearDown();
 }

 @Test
 public void memcacheConcurrentAccess() throws InterruptedException {
  final MemcacheService service = MemcacheServiceFactory.getMemcacheService();
  Runnable runner = new Runnable() {

   @Override
   public void run() {
    // TODO Auto-generated method stub
    service.increment("test-key", 1L, 1L);
    try {
     Thread.sleep(200L);
    } catch (InterruptedException e) {
     // TODO Auto-generated catch block
     e.printStackTrace();
    }
    service.increment("test-key", 1L, 1L);
   }
  };

  Thread t1 = new Thread(runner);
  Thread t2 = new Thread(runner);
  t1.start();
  t2.start();
  while (t1.isAlive()) {
   Thread.sleep(100L);
  }
  Assert.assertEquals((Long) (service.get("test-key")), new Long(4L));
 }
}

Answer 1

您是在尝试测试您的应用还是 App Engine 的内存缓存实现？ memcache 在并发读取和写入下的语义很好理解 - 您最好简单地模拟可能发生的条件，以验证您的应用程序处理它们是否正常。

Answer 2

问题在于线程是如何设置的，可以使用 SDK 中提供的 ThreadManager 解决：

private final LocalServiceTestHelper helper =
        new LocalServiceTestHelper(new LocalDatastoreServiceTestConfig());

@Before
public void setUp() throws Exception {
    helper.setUp();
}

@After
public void tearDown() throws Exception {
    helper.tearDown();
}

AtomicInteger threadsRemaining = new AtomicInteger(NUM_USERS);
AtomicInteger numFailingThreads = new AtomicInteger(0);

@Test
public void testManyUsers() throws Exception {


    ArrayList<TestUser> testUsers = new ArrayList<TestUser>();

    // Create something to test in parallel (in this case a "user")
    for (int i = 0; i < NUM_USERS; ++i) {
        testUsers.add(new TestUser());
    }

    // Fork off a thread for each user
    runInParallel(testUsers);

    // Wait for threads to complete.
    while (threadsRemaining.intValue() != 0) {
        Thread.sleep(10); // TODO: Clean up with callbacks or whatever. 
    }

    assertEquals(numFailingThreads.intValue(), 0);
}

private void runInParallel(final ArrayList<TestUser> testUsers) {


    for (final TestUser u : testUsers) {

        Runnable myTask = new Runnable() {

            @Override
            public void run() {
                try {

                    // The user tries to kill my server

                } catch (Exception e) {

                    // The user triggered badness in my server

                    e.printStackTrace();
                    numFailingThreads.incrementAndGet();
                }
                threadsRemaining.decrementAndGet();
            }
        };

        ThreadFactory threadFactory = ThreadManager.currentRequestThreadFactory();

        Thread t = threadFactory.newThread(myTask);

        t.start();
    }


}

Answer 3

GAE 不支持用户线程。我认为你试图过度复杂化。

您可以对此进行测试的一种方法是创建一个外部线程客户端并生成您希望远程访问 GAE 的任意数量的线程。如果它在您的本地盒子上运行，只需指向那里。

Answer 4

我猜的测试库 GAE SDK 试图模仿真实的 环境，从而设置 只有一个线程的环境（ 运行测试的线程） 其他线程看不到。

这个猜测大致正确：因为 GAE 本身从不在一个进程中运行多个线程，因此 SDK 也同样如此 - 所以我不清楚为什么要测试在 GAE 中不可能发生的多线程访问.