基于 “不可变类” 实现一个线程安全的 Integer 计数器

最新推荐文章于 2024-10-18 10:18:26 发布

Young.Chen

最新推荐文章于 2024-10-18 10:18:26 发布

阅读量581

点赞数

CC 4.0 BY-SA版权

分类专栏： Java Tech Java 并发编程文章标签： Immutable 不可变

本文链接：https://blog.youkuaiyun.com/chen_kkw/article/details/88043529

Java Tech 同时被 2 个专栏收录

13 篇文章

订阅专栏

Java 并发编程

5 篇文章

订阅专栏

本文介绍如何通过创建不可变类ImmutableIntegerCounter实现线程安全的计数器。不可变类的特性确保在多线程环境下，每次操作都返回新的对象，避免了同步和锁带来的性能问题，确保数据一致性。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

写在前面

众所周知，java.lang.String 类没有任何强制同步的代码，但它是线程安全的，原因在于它是不可变类，每次对其操作都是返回一个新的 String 对象。合理使用不可变对象可以达到 lock-free 的效果。

不可变对象最核心的地方在于不给外部修改共享资源的机会，从而避免多线程情况下由于争抢共享资源导致的数据不一致，又是 lock-free 的，避免了用锁带来的性能损耗。

ImmutableIntegerCounter

// final 修饰，不能继承
public final class ImmutableIntegerCounter {

    // final 修饰，不允许其他线程对其更改
    private final int initial;

    public ImmutableIntegerCounter(int initial) {
        this.initial = initial;
    }

    public ImmutableIntegerCounter(ImmutableIntegerCounter counter, int i) {
        this.initial = counter.getInitial() + i;
    }

    // 每次调用 increment 都会新构造一个 ImmutableIntegerCounter
    public ImmutableIntegerCounter increment(int i) {
        return new ImmutableIntegerCounter(this, i);
    }

    public int getInitial() {
        return initial;
    }
}

测试

import org.junit.Before;
import org.junit.Test;

import java.util.concurrent.TimeUnit;
import java.util.stream.IntStream;

public class ImmutableIntegerCounterTest {

    private ImmutableIntegerCounter integerCounter = null;

    @Before
    public void init() {
        integerCounter = new ImmutableIntegerCounter(0);
    }

    @Test
    public void incrementTest() throws InterruptedException {

        IntStream.range(0, 3).forEach(i -> new Thread(() -> {
            int increment = 1;
            while(true) {
                int oldValue = integerCounter.getInitial();
                int result = integerCounter.increment(increment).getInitial();
                System.out.println(oldValue + "+" + increment + "=" + result);
                assert (oldValue + increment) == result;
                increment++;
                try {
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }).start());

        TimeUnit.SECONDS.sleep(10);

    }
}

输出结果

三个线程的输出结果均是正确的

0+1=1
0+1=1
0+1=1
0+2=2
0+2=2
0+2=2
0+3=3
0+3=3
0+3=3
0+4=4
0+4=4
0+4=4

Process finished with exit code 130 (interrupted by signal 2: SIGINT)