函数代替静态实用方法

Question

    private static Function<String, String> fnPrependString = (s) -> {
        return "prefix_" + s;
    };

现在的问题是，我是否可以创建这些函数一次，并像助手方法一样重用它们。

一个威胁是线程安全。我用一个简单的测试来检查这个JUnit测试：

package com.me.expt.lt.test;

import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertTrue;

import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
import java.util.function.Consumer;
import java.util.function.Function;

import org.junit.jupiter.api.Test;

import com.vmlens.api.AllInterleavings;

public class TestFunctionThreadSafety {
    private static Function<String, String> fnPrepend = (s) -> {
        System.out.println(s);
        return new StringBuffer("prefix_").append(s).toString();
    };

    @Test
    public void testThreadSafety() throws InterruptedException {
        try (AllInterleavings allInterleavings = new AllInterleavings(
                TestFunctionThreadSafety.class.getCanonicalName());) {
            ConcurrentMap<String, Integer> resultMap = new ConcurrentHashMap<String, Integer>();
            while (allInterleavings.hasNext()) {
                int runSize = 5;
                Thread[] threads = new Thread[runSize];
                ThreadToRun[] ttrArray = new ThreadToRun[runSize];
                StringBuffer sb = new StringBuffer("0");
                for (int i = 0; i < runSize; i++) {
                    if (i > 0)
                        sb.append(i);
                    ttrArray[i] = new ThreadToRun();
                    ttrArray[i].setS(sb.toString());
                    threads[i] = new Thread(ttrArray[i]);
                }
                for (int j = 0; j < runSize; j++) {
                    threads[j].start();
                }
                for (int j = 0; j < runSize; j++) {
                    threads[j].join();
                }
                System.out.println(resultMap);
                StringBuffer newBuffer = new StringBuffer("0");
                for (int j = 0; j < runSize; j++) {
                    if(j>0)
                        newBuffer.append(j);
                    assertEquals("prefix_" + newBuffer, ttrArray[j].getResult(), j + " fails");
                }
            }
        }
    }

    private static class ThreadToRun implements Runnable {
        private String s;
        private String result;

        public String getS() {
            return s;
        }

        public void setS(String s) {
            this.s = s;
        }

        public String getResult() {
            return result;
        }

        @Override
        public void run() {
            this.result = fnPrepend.apply(s);
        }

    }

}

我用的是VMLENS。我可以通过更改runsize变量来优化测试，这样可以检查随机性。目的是查看这些使用相同函数的多个线程是否因为并发访问而混淆了它们的输入。测试没有返回任何阴性结果。请对测试是否符合目标做出评论。

上面使用函数 的结果是否也可以应用于供应商 和消费者 ？

对函数和字节码的更多熟悉可能会帮助我回答这些问题。但是像这样的知识交流论坛可能会让我更快地得到答案，这些问题可能会引发读者更多的想法。

提前谢了。拉胡尔

Answer 1

作为一个用户，我真的不认为您需要花这么长的时间来证明JVM关于lambdas的保证。基本上，它们就像JVM的任何其他方法一样，没有特殊的内存或可见性影响：）

下面是一个较短的函数定义：

private static Function<String, String> fnPrepend = s -> "prefix_" + s;

this.result=fnprepend.application(s)；

java prettyprint-override">  // Available as normal static method
  public static String fnPrepend(String s) {
    return "prefix_" + s;
  }
  
  // Takes a generic Function
  public static void someMethod(UnaryOperator<String> prefixer) {
    ...
  }

  // Coerce the static method to a function
  someMethod(Util::fnPrepend);