Java：跨多个线程共享变量

Question

背景：我正在并行运行自动化测试。多个浏览器在相同数量的线程中启动，即 1 个浏览器是 1 个线程，使用 pom.xml 中的分叉。

pom.xml 中的以下插件创建与线程（fork）计数相同数量的Parallel**IT.class。
所有这些类都是同时并行执行的。因此，似乎每当我创建 volatile variable 或 AtomicInteger 时，每个线程都会创建自己的这些，因此跨多个线程共享变量的概念不起作用。

                <plugin>
                        <artifactId>maven-failsafe-plugin</artifactId>
                        <version>${maven.failsafe.plugin}</version>
                        <configuration>
                            <systemPropertyVariables>
                                <webdriver.base.url>${webdriver.base.url}</webdriver.base.url>
                                                                </systemPropertyVariables>
                            <argLine>
                                -javaagent:${settings.localRepository}/org/aspectj/aspectjweaver/${aspectj.version}/aspectjweaver-${aspectj.version}.jar
                            </argLine>
                            <forkCount>5</forkCount>
                            <reuseForks>true</reuseForks>
                            <includes>
                                <include>**/Parallel*IT.class</include>
                            </includes>
                            <perCoreThreadCount>true</perCoreThreadCount>
                            <properties>
                                <property>
                                    <name>listener</name>
            <value>ru.yandex.qatools.allure.junit.AllureRunListener</value>
                                </property>
                            </properties>
                        </configuration>
                        <executions>
                            <execution>
                                <goals>
                                    <goal>integration-test</goal>
                                    <goal>verify</goal>
                                </goals>
                            </execution>
                        </executions>
                    </plugin>

我只希望 1 个线程访问“准备测试数据”功能并将 flag 设置为 false，当其他线程将 flag 视为 false 时，它们不会尝试准备测试数据。

我正在按照教程https://www.youtube.com/watch?v=WH5UvQJizH0 使用volatile 变量来实现synchronization。也许我犯了一些错误，但所有线程都在打印System.out.println("Preparing test data");

尝试一：易失性和同步性

volatile boolean flag = false;

    public synchronized void setFlagTofalse(){
        System.out.println("Inside sync block");
          this.flag = true;
    }
    // works before class only once
    private EventHandler<TestRunStarted> prepareTestData = event -> {
            if(flag==false) {
                System.out.println("Preparing test data");              
                setFlagTofalse();
            }
    };

尝试 2：原子和同步

AtomicInteger flag = new AtomicInteger(0);

    private EventHandler<TestRunStarted> prepareTestData = event -> {
        if(flag.get()==0) {
            System.out.println("Preparing test data");
            value.incrementAndGet();
        }

Answer 1

如果我是你，我会在访问标志变量时实现互斥锁。因此，在读取标志的值或更改其值之前，线程必须获取锁。这样他们就不会同时读取它或写入一个新值，而一个旧值直到被读取等等。

编辑：更多解释

@paul 解释一下锁的作用：它基本上是一个可以被线程抛来抛去的球。因此，如果您与一群人围成一圈，并且您拥有球权，那么轮到您谈论“X”了。然后，一旦你说完，你就把球放在圆圈的中间，它一直在那里，直到同一个人或其他人再次想要球并拿走它，或者等到它可用，然后可能会说“X”。在您的情况下，线程必须具有更改或读取变量标志的锁，所以您要做的是：

Mutex lock = new Mutex();
lock.aquire();
if ( flag == something ){
    //do something
}
mutex.release()

或者如果你正在改变标志。

lock.aquire();
flag = something;
lock.release();

如您所见，锁是在线程之间共享的。所以它是在管理线程的类中创建的，并传递给线程中启动的可运行对象或方法。

所以：

Mutex lock = new Mutex();
Runnable1 r1 = new Runnable1(lock);
Runnable2 r2 = new Runnable2(lock);
//use the lock in the methods of t1 and t2 that use your volitile var
Thread t1 = new Thread(r1);
Thread t2 = new Thread(r2);

t1.start();
t2.start();

//the join wait for completion of the runnable method in your class.
t1.join();
t2.join();

祝你好运:)

Answer 2

如果你做一个测试 (flag.get()==0) 和一个动作，你有两个同步这两个东西。只需将整个 prepareTestData 方法标记为同步？

Answer 3

您同步了错误的方法。你可以试试这样的：

volatile boolean flag = false;

public void setFlagTofalse(){
    System.out.println("Inside sync block");
    this.flag = true;
}
// works before class only once
private EventHandler<TestRunStarted> prepareTestData = event -> prepareData();

private synchronized void prepareData() {
    if(!flag) {
        System.out.println("Preparing test data");
        setFlagTofalse();
    }
    //prepare data here
}

Answer 4

“flag”和“lockObject”需要是“static”的，这样每个对象只有一个实例。虽然如果你有单例对象，那么你不必为“标志”使用“静态”，但“lockObject”应该是静态的。

另外，使用“prepareTestData”中的“lockObject”进行同步。这表明java只有一个线程应该访问超过这一点的代码。一旦一个线程进入，其他线程将在进入之前等待该线程返回。

private static Object lockObject = new Object();
private static Boolean flag = Boolean.FALSE;

private void prepareTestData() {
   synchronized(lockObject) { //This will keep other threads waiting
      if(!flag) {
          //prepare data
          flag = Boolean.TRUE;
       }
   }
}

希望这能回答你的问题。