试过返回值是2147483647，也就是int的最大值。没有等待操作完成就猴急的返回了。 m.set(Integer.min(m.get(), r)... 这个操作也不是原子操作。
试着自己弄了一下：
public Integer run(){
        // 创建线程池
        ExecutorService executor = Executors.newFixedThreadPool(3);
        // 创建 CompletionService
        CompletionService<Integer> cs = new ExecutorCompletionService<>(executor);
        AtomicReference<Integer> m = new AtomicReference<>(Integer.MAX_VALUE);
        // 异步向电商 S1 询价
        cs.submit(()->getPriceByS1());
        // 异步向电商 S2 询价
        cs.submit(()->getPriceByS2());
        // 异步向电商 S3 询价
        cs.submit(()->getPriceByS3());
        // 将询价结果异步保存到数据库
        // 并计算最低报价
        for (int i=0; i<3; i++) {
            Integer r = logIfError(()->cs.take().get());
            executor.execute(()-> save(r));
            m.getAndUpdate(v->Integer.min(v, r));
        }
        return m.get();
    }
不知道可不可行

老师stampedLock的获取锁源码，老师能帮忙解惑下么？阻塞的读线程cowait是挂在写节点的下方么？老师能解惑下基于的理论模型
private long acquireWrite(boolean interruptible, long deadline) {
        WNode node = null, p;
        for (int spins = -1;;) { // spin while enqueuing
            long m, s, ns;
            //如果当前的state是无锁状态即100000000
            if ((m = (s = state) & ABITS) == 0L) {
                //设置成写锁
                if (U.compareAndSwapLong(this, STATE, s, ns = s + WBIT))
                    return ns;
            }
            else if (spins < 0)
                //当前锁状态为写锁状态，并且队列为空，设置自旋值
                spins = (m == WBIT && wtail == whead) ? SPINS : 0;
            else if (spins > 0) {
                //自旋操作，就是让线程在此自旋
                if (LockSupport.nextSecondarySeed() >= 0)
                    --spins;
            }
            //如果队列尾元素为空，初始化队列
            else if ((p = wtail) == null) { // initialize queue
                WNode hd = new WNode(WMODE, null);
                if (U.compareAndSwapObject(this, WHEAD, null, hd))
                    wtail = hd;
            }
            //当前要加入的元素为空，初始化当前元素，前置节点为尾节点
            else if (node == null)
                node = new WNode(WMODE, p);
            //队列的稳定性判断，当前的前置节点是否改变，重新设置
            else if (node.prev != p)
                node.prev = p;
            //将当前节点加入尾节点中
            else if (U.compareAndSwapObject(this, WTAIL, p, node)) {
                p.next = node;
                break;
            }
        }

        

我实际测试了第一段代码，确实是异步的，f1.get不会阻塞主线程。。。

public static void main(String[] args) {
        ExecutorService executor = Executors.newFixedThreadPool(3);
        Future<Integer> f1 = executor.submit(()->getPriceByS1());
        Future<Integer> f2 = executor.submit(()->getPriceByS2());
        Future<Integer> f3 = executor.submit(()->getPriceByS3());

        executor.execute(()-> {
            try {
                save(f1.get());
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (ExecutionException e) {
                e.printStackTrace();
            }
        });
        executor.execute(()-> {
            try {
                save(f2.get());
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (ExecutionException e) {
                e.printStackTrace();
            }
        });
        executor.execute(()-> {
            try {
                save(f3.get());
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (ExecutionException e) {
                e.printStackTrace();
            }
        });
    }

    private static Integer getPriceByS1() {
        try {
            Thread.sleep(10000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return 1;
    }
    private static Integer getPriceByS2() {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return 2;
    }
    private static Integer getPriceByS3() {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return 3;
    }
    private static void save(Integer i) {
        System.out.println("save " + i);
    }

重新发过，刚刚的代码有误！
1.for循环线程池执行属于异步导致未等比价结果就 return了，需要等待三次比价结果才能 return，可以用 CountDownLatch
2. m. set( Integer. min( m. get(), r))存在竞态条件，可以更改为
Integer o;
do{
o= m. get();
if(o<=r){ break;}
}
while(! m. compareAndSet( o, r));
3.还有一个小问题就是 try- catch捕获异常后的处理，提高程序鲁棒性

老师您好，为什么我写的这个用CompletionService创建四个线程计算从1加到n的程序在打印出最后的结果后没有退出呢？
public class TestCompletionService {
    private static long addRange(long start, long end){
        long sum = 0;
        for (long i = start; i <= end; i++) {
            sum += i;
        }
        return sum;
    }
    public static void main(String[] args) throws InterruptedException, ExecutionException {
        long n = 3000000000L;
        Long res = 0L;

        ExecutorService executor = Executors.newFixedThreadPool(4); //创建线程池
        CompletionService<Long> cs = new ExecutorCompletionService<>(executor);

        cs.submit(() -> addRange(1L, n >> 2));
        cs.submit(() -> addRange((n >> 2) + 1, n >> 1));
        cs.submit(() -> addRange((n >> 1) + 1, (n >> 2) * 3));
        cs.submit(() -> addRange((n >> 2) * 3 + 1, n));

        for (int i = 0; i < 4; i++) {
            res += cs.take().get();
        }
        System.out.println(res);
    }
}