将对象添加到列表时的Java并发问题

Question

I have a question which seems very strange, probably because my lack of some specific knowledge.

I have a simple class TestCon and a test class TestTest:

import java.util.*;
import java.util.concurrent.*;

public class TestCon {
    private volatile static TestCon def = null;
    private volatile static List<TestCon> list = Collections.synchronizedList(new ArrayList<TestCon>());

    public static synchronized TestCon getInstance() {
        if (def == null) {
            def = new TestCon();
            list.add(def);
        }
        return def;
    }
    private synchronized static TestCon addtolist(){
        return  new TestCon();
    }
    public static synchronized int getSize() {
        return list.size();
    }

    public synchronized void destroy() {
        def = null;
        list.clear();
    }
}


import org.testng.annotations.Test;
import org.testng.*;

public class TestTest {


  @Test(threadPoolSize=50, invocationCount=15000)
  public void test_getInstance() {
      TestCon tst=TestCon.getInstance();
      Assert.assertNotNull(tst);
      Assert.assertEquals(TestCon.getSize(), 1); //line 1
      tst.destroy(); //line 2
  }
}

So my question is why the test occasionally fails at //line 1 (the list size is 0 but expected 1). If I add synchronization into the testing method - everything is fine. If I comment line 2 again test succeeds.

Answer 1

While your TestCon class is not rendering an explicit race condition, your test is containing one. While the getInstance , getSize and destroy methods are atomic, any composition of these methods is not.

Looking at your code:

@Test(threadPoolSize = 50, invocationCount = 15000)
public void test_getInstance() {
  TestCon tst = TestCon.getInstance();
  Assert.assertNotNull(tst); // (1)
  Assert.assertEquals(TestCon.getSize(), 1); // (2)
  tst.destroy(); // (3)
}

Assume that you have two threads that end up at line (1) together. Then thread one moves through to line (3) successfully. This means, the list is now empty. After this thread, thread two moves and checks the list size at (2) and finds the list empty: The test fails.

Answer 2

synchronized is just protecting the code block that follows it (method body or a block of statements inside a method).

That means that other synchronized blocks which lock the same entity (the class in your case since you're using synchronized methods) can't execute at the same time but it doesn't "order" the individual blocks.

What you see is:

• [Thread 1] TestCon tst=TestCon.getInstance();
• [Thread 2] tst.destroy(); //line 2 tst.destroy(); //line 2
• [Thread 1] Assert.assertEquals(TestCon.getSize(), 1); //line 1 Assert.assertEquals(TestCon.getSize(), 1); //line 1

This is because your code only ever creates a single TestCon which all threads use.

Instead, you need to make sure that each thread gets their own TestCon . Look at ThreadLocal for a field which has a different value for each thread.