Java Sequence Generator示例

水深无声 2023-02-15 05:14 8阅读 0赞

一个示例，向您展示如何创建线程安全序列生成器。

## 1. SequenceGenerator ##

SequenceGenerator.java

package com.mkyong.concurrency.examples.sequence.generator;
    
    public interface SequenceGenerator {
        long getNext();
    }

1.1首先尝试直接读取，添加，写入值。 下面的方法不是线程安全的，多个线程可能同时获得相同的值。

UnSafeSequenceGenerator.java

package com.mkyong.concurrency.examples.sequence.generator;
    
    public class UnSafeSequenceGenerator implements SequenceGenerator {
    
        private long value = 1;
    
        @Override
        public long getNext() {
            return value++;
        }
    
    }

1.2要解决此问题，请将`getNext()`作为`synchronized`方法。

SyncSequenceGenerator.java

package com.mkyong.concurrency.examples.sequence.generator;
    
    public class SyncSequenceGenerator implements SequenceGenerator {
    
        private long value = 1;
    
        @Override
        public synchronized long getNext() {
            return value++;
        }
    }

1.3更好的解决方案是使用`concurrent.atomic` `AtomicLong`类，例如`AtomicLong`

AtomicSequenceGenerator.java

package com.mkyong.concurrency.examples.sequence.generator;
    
    import java.util.concurrent.atomic.AtomicLong;
    
    public class AtomicSequenceGenerator implements SequenceGenerator {
    
        private AtomicLong value = new AtomicLong(1);
    
        @Override
        public long getNext() {
            return value.getAndIncrement();
        }
    }

## 2.并发访问 ##

模拟并发访问环境以测试上述序列生成器。

2.1。 `Callable`任务，可访问序列10次。

PrintSequenceCallable.java

package com.mkyong.concurrency.examples.sequence;
    
    import com.mkyong.concurrency.examples.sequence.generator.SequenceGenerator;
    
    import java.util.ArrayList;
    import java.util.List;
    import java.util.concurrent.Callable;
    
    public class PrintSequenceCallable implements Callable<List<Long>> {
    
        private SequenceGenerator sequenceGenerator;
    
        public PrintSequenceCallable(SequenceGenerator sequenceGenerator) {
            this.sequenceGenerator = sequenceGenerator;
        }
    
        @Override
        public List<Long> call() throws Exception {
    
            List<Long> ids = new ArrayList<>();
    
            for (int i = 1; i <= 10; i++) {
                Thread.sleep(100); //take a nap
                ids.add(sequenceGenerator.getNext());
            }
    
            return ids;
    
        };
    
    }

2.2启动3个线程以测试序列生成器。

Main.java

package com.mkyong.concurrency.examples.sequence;
    
    import com.mkyong.concurrency.examples.sequence.generator.SequenceGenerator;
    import com.mkyong.concurrency.examples.sequence.generator.UnSafeSequenceGenerator;
    
    import java.util.List;
    import java.util.concurrent.*;
    
    public class Main {
    
        public static void main(String[] args) {
    
            SequenceGenerator sequenceGenerator = new UnSafeSequenceGenerator();
            //SequenceGenerator sequenceGenerator = new SyncSequenceGenerator();
            //SequenceGenerator sequenceGenerator = new AtomicSequenceGenerator();
    
            ExecutorService executor = Executors.newCachedThreadPool();
    
            try {
    
    			// simulate 3 threads concurrent access the sequence generator
                Callable<List<Long>> task1 = new PrintSequenceCallable(sequenceGenerator);
                Callable<List<Long>> task2 = new PrintSequenceCallable(sequenceGenerator);
                Callable<List<Long>> task3 = new PrintSequenceCallable(sequenceGenerator);
    
                Future f1 = executor.submit(task1);
                Future f2 = executor.submit(task2);
                Future f3 = executor.submit(task3);
    
                System.out.println(f1.get());
                System.out.println(f2.get());
                System.out.println(f3.get());
    
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (ExecutionException e) {
                e.printStackTrace();
            } finally {
                executor.shutdown();
            }
    
        }
    
    }

输出量

2.2.1 `UnSafeSequenceGenerator` – `UnSafeSequenceGenerator`竞态条件，多个线程获得相同的值，这不是我们想要的。

[3, 5, 6, 7, 8, 10, 12, 15, 16, 17]
    [2, 4, 6, 7, 8, 9, 13, 15, 16, 17]
    [1, 4, 6, 7, 8, 11, 14, 15, 16, 17]

2.2.2 `SyncSequenceGenerator` –线程安全。

[3, 6, 8, 10, 14, 17, 21, 24, 27, 29]
    [1, 4, 9, 12, 15, 18, 20, 22, 25, 30]
    [2, 5, 7, 11, 13, 16, 19, 23, 26, 28]

2.2.3 `AtomicSequenceGenerator` –线程安全。

[3, 6, 8, 12, 13, 18, 19, 22, 27, 29]
    [2, 5, 7, 10, 14, 17, 20, 24, 26, 30]
    [1, 4, 9, 11, 15, 16, 21, 23, 25, 28]

两个`synchronized`和`AtomicLong`能够创建一个线程安全的序列发生器。 但是， `synchronized`方法很昂贵，会增加性能成本，建议的方法是使用`concurrent.atomic`类。原子类（例如`AtomicLong`是为并发设计的。

## 下载源代码 ##

> $ git clone [https://github.com/mkyong/java-concurrency.git][https_github.com_mkyong_java-concurrency.git]

## 参考文献 ##

1.  [同步方法][Link 1]
2.  [原子变量][Link 2]
3.  [为什么在Java中同步昂贵？][Java]
4.  [比赛条件][Link 3]

标记： [原子][Link 4] [并发][Link 5] [Java][Java 1] [竞态条件][Link 6] [序列已][Link 7] [同步][Link 8]

> 翻译自: [https://mkyong.com/java/java-sequence-generator-examples/][https_mkyong.com_java_java-sequence-generator-examples]

[https_github.com_mkyong_java-concurrency.git]: https://github.com/mkyong/java-concurrency.git
[Link 1]: https://docs.oracle.com/javase/tutorial/essential/concurrency/syncmeth.html
[Link 2]: https://docs.oracle.com/javase/tutorial/essential/concurrency/atomicvars.html
[Java]: https://stackoverflow.com/questions/1671089/why-are-synchronize-expensive-in-java
[Link 3]: https://en.wikipedia.org/wiki/Race_condition
[Link 4]: https://mkyong.com/tag/atomic/
[Link 5]: https://mkyong.com/tag/concurrency/
[Java 1]: https://mkyong.com/tag/java/
[Link 6]: https://mkyong.com/tag/race-condition/
[Link 7]: https://mkyong.com/tag/sequence/
[Link 8]: https://mkyong.com/tag/synchronized/
[https_mkyong.com_java_java-sequence-generator-examples]: https://mkyong.com/java/java-sequence-generator-examples/