Java在高并发场景下实现点赞计数器

更新时间：2023年06月28日 16:01:57 作者：SSPo

点赞计数器的本质就是对某个变量在高并发情况下的修改，这篇文章主要为大家介绍了Java实现点赞计数器的示例代码，感兴趣的小伙伴可以了解一下

1. Synchronized 关键字

package concurrent;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.atomic.AtomicLong;
import java.util.concurrent.atomic.LongAccumulator;
import java.util.concurrent.atomic.LongAdder;
class ClickResource{
    int number = 0;
    public synchronized void clickBySynchronized(){number++;}
}
// 100个线程, 每个线程点赞 100万 次, 求准确率和效率
public class AccumulatorCompareDemo {
    public static final int _1w = 10000;
    public static final int threadNumber = 100;
    public static void main(String[] args) throws InterruptedException {
        ClickResource clickResource = new ClickResource();
        long startTime  = System.currentTimeMillis();
        CountDownLatch countDownLatch1 = new CountDownLatch(threadNumber);
        for (int i = 0; i < threadNumber; i++) {
            new Thread(()->{
                try {
                    for (int j = 0; j < 100*_1w; j++) {
                        clickResource.clickBySynchronized();
                    }
                }finally {
                    countDownLatch1.countDown();
                }
            },String.valueOf(i)).start();
        }
        countDownLatch1.await();
        long endTime  = System.currentTimeMillis();
        System.out.println("所用时间="+(endTime-startTime)+"ms"+"    最终点赞次数="+clickResource.number);
    }
}
// synchronized       悲观锁
// 所用时间=2258ms    最终点赞次数=100000000

2. 使用 AtomicLong 原子类

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.atomic.AtomicLong;
import java.util.concurrent.atomic.LongAccumulator;
import java.util.concurrent.atomic.LongAdder;
class ClickResource{
    int number = 0;
    AtomicLong atomicLong = new AtomicLong(0);
    public void clickByAtomicLong(){atomicLong.getAndIncrement();}
}
// 100个线程, 每个线程点赞 100万 次, 求准确率和效率
public class AccumulatorCompareDemo {
    public static final int _1w = 10000;
    public static final int threadNumber = 100;
    public static void main(String[] args) throws InterruptedException {
        ClickResource clickResource = new ClickResource();
        long startTime  = System.currentTimeMillis();
        CountDownLatch countDownLatch = new CountDownLatch(threadNumber);
        for (int i = 0; i < threadNumber; i++) {
            new Thread(()->{
                try {
                    for (int j = 0; j < 100*_1w; j++) {
                        clickResource.clickByAtomicLong();
                    }
                }finally {
                    countDownLatch.countDown();
                }
            },String.valueOf(i)).start();
        }
        countDownLatch.await();
        long endTime  = System.currentTimeMillis();
        System.out.println("所用时间="+(endTime-startTime)+"ms"+"    最终点赞次数="+clickResource.atomicLong);
    }
}
// CAS - 轻量级锁 - 调用 Unsafe 类的 cas 方法 - 底层操作系统原子指令 
// 所用时间=1177ms    最终点赞次数=100000000

3.使用 LongAdder 类

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.atomic.AtomicLong;
import java.util.concurrent.atomic.LongAccumulator;
import java.util.concurrent.atomic.LongAdder;
class ClickResource{
    int number = 0;
    LongAdder longAdder = new LongAdder();
    public void clickByLongAdder(){longAdder.increment();}
}
// 100个线程, 每个线程点赞 100万 次, 求准确率和效率
public class AccumulatorCompareDemo {
    public static final int _1w = 10000;
    public static final int threadNumber = 100;
    public static void main(String[] args) throws InterruptedException {
        ClickResource clickResource = new ClickResource();
        long startTime  = System.currentTimeMillis();
        CountDownLatch countDownLatch = new CountDownLatch(threadNumber);
        CountDownLatch countDownLatch2 = new CountDownLatch(threadNumber);
        CountDownLatch countDownLatch3 = new CountDownLatch(threadNumber);
        CountDownLatch countDownLatch4 = new CountDownLatch(threadNumber);
        for (int i = 0; i < threadNumber; i++) {
            new Thread(()->{
                try {
                    for (int j = 0; j < 100*_1w; j++) {
                        clickResource.clickByLongAdder();
                    }
                }finally {
                    countDownLatch.countDown();
                }
            },String.valueOf(i)).start();
        }
        countDownLatch.await();
        long endTime  = System.currentTimeMillis();
        System.out.println("所用时间="+(endTime-startTime)+"ms"+"    最终点赞次数="+clickResource.longAdder);
    }
}
//所用时间=141ms    最终点赞次数=100000000

4. 使用 LongAccumulator 类

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.atomic.AtomicLong;
import java.util.concurrent.atomic.LongAccumulator;
import java.util.concurrent.atomic.LongAdder;
class ClickResource{
    int number = 0;
    LongAccumulator longAccumulator = new LongAccumulator((x,y)->x+y,0);
    public void clickByLongAccumulator(){longAccumulator.accumulate(1);}
}
// 100个线程, 每个线程点赞 100万 次, 求准确率和效率
public class AccumulatorCompareDemo {
    public static final int _1w = 10000;
    public static final int threadNumber = 100;
    public static void main(String[] args) throws InterruptedException {
        ClickResource clickResource = new ClickResource();
        long startTime  = System.currentTimeMillis();
        CountDownLatch countDownLatch = new CountDownLatch(threadNumber);
        for (int i = 0; i < threadNumber; i++) {
            new Thread(()->{
                try {
                    for (int j = 0; j < 100*_1w; j++) {
                        clickResource.clickByLongAccumulator();
                    }
                }finally {
                    countDownLatch.countDown();
                }
            },String.valueOf(i)).start();
        }
        countDownLatch.await();
        long endTime  = System.currentTimeMillis();
        System.out.println("所用时间="+(endTime-startTime)+"ms"+"    最终点赞次数="+clickResource.longAccumulator);
    }
}
// 所用时间=150ms    最终点赞次数=100000000

LongAccumulator 和 LongAdder 底层调用的方法相同，主要区别是，LongAdder只能初始为0，且只能做加法操作，LongAccumulator 能初始成任何数

需要注意的是：

LongAdder 和 LongAccumulator 并不保证最终获取的数据是完全准确无误的，也许会有少许偏差，但在高并发的点赞场景下牺牲少量的数据精确性来保证高性能是完全能接受的

以上就是Java在高并发场景下实现点赞计数器的详细内容，更多关于Java点赞计数器的资料请关注脚本之家其它相关文章！

您可能感兴趣的文章:

SpringBoot自定义Starter与自动配置实现方法详解
在Spring Boot官网为了简化我们的开发，已经提供了非常多场景的Starter来为我们使用，即便如此，也无法全面的满足我们实际工作中的开发场景，这时我们就需要自定义实现定制化的Starter
2023-02-02
通过Maven下载依赖Jar包的流程分享
本文主要介绍了Maven下载依赖Jar包的详细流程,包括输入Maven仓库的官方地址、搜索依赖Jar包、选择版本、复制和粘贴Maven依赖到pom文件中下载依赖Jar包
2025-02-02
浅谈JavaAPI 中 <E> 与 <T> 的含义
下面小编就为大家带来一篇浅谈JavaAPI 中 <E> 与 <T> 的含义。小编觉得挺不错的，现在就分享给大家，也给大家做个参考。一起跟随小编过来看看吧
2017-10-10
聊聊springboot 整合 hbase的问题
这篇文章主要介绍了springboot 整合 hbase的问题，文中给大家提到配置linux服务器hosts及配置window hosts的相关知识,需要的朋友可以参考下
2021-11-11
Spring使用@Filter注解创建自定义过滤器
Spring 中鲜为人知但非常有用的注解之一是 @Filter,它支持自定义过滤器,下面我们就来深入研究一下如何使用 Spring 的 @Filter 注解来创建自定义过滤器吧
2023-11-11
Java类的加载连接和初始化实例分析
这篇文章主要介绍了Java类的加载连接和初始化,结合具体实例形式分析了java类的加载、连接、初始化相关原理与实现技巧,需要的朋友可以参考下
2019-07-07
浅析JAVA中toString方法的作用
以下是对在JAVA中toString方法的作用进行了详细的分析介绍，需要的朋友可以参考下
2013-07-07
Java调用C++程序的实现方式
这篇文章主要介绍了Java调用C++程序的实现方式，具有很好的参考价值，希望对大家有所帮助。如有错误或未考虑完全的地方，望不吝赐教
2022-02-02
$解决maven clean报错:Failed to delete xxxxx\target\xxxx.jar$
解决maven clean报错:Failed to delete xxxxx\t
这篇文章主要介绍了解决maven clean报错:Failed to delete xxxxx\target\xxxx.jar问题,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不吝赐教
2024-08-08
Eclipse中引入com.sun.image.codec.jpeg包报错的完美解决办法
Java开发中对图片的操作需要引入 com.sun.image.codec.jpeg,但有时引入这个包会报错，利用下面的操作可以完成解决这个问题
2018-02-02