一个线程安全的计数器实现(java),可以让一个变量每天从1开始递增

前几天工作中一段业务代码需要一个变量每天从1开始递增。为此自己简单的封装了一个线程安全的计数器,可以让一个变量每天从1开始递增。当然了,如果项目在运行中发生重启,即便日期还是当天,还是会从1开始重新计数。所以把计数器的值存储在数据库中会更靠谱,不过这不影响这段代码的价值,现在贴出来,供有需要的人参考。
package com.hikvision.cms.rvs.common.util;



import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicReferenceFieldUpdater;

/**
 * Created by lihong10 on 2017/8/9.
 * 一个循环计数器,每天从1开始计数,隔天重置为1。
 * 可以创建一个该类的全局对象,然后每次使用时候调用其get方法即可,可以保证线程安全性
 */
public class CircularCounter {

    private static final AtomicReferenceFieldUpdater<CircularCounter, AtomicInteger> valueUpdater =
            AtomicReferenceFieldUpdater.newUpdater(CircularCounter.class, AtomicInteger.class, "value");
    //保证内存可见性
    private volatile String key;
    //保证内存可见性
    private volatile AtomicInteger value;
    private static final String DATE_PATTERN = "yyyy-MM-dd";


    public CircularCounter() {
        /**
         * 这里将key设置为getCurrentDateString() + "sssssssssss" 是为了测试addAndGet()方法中日期发生变化的情况
         * 正常使用应该将key初始化为getCurrentDateString()
         */
        this.key = getCurrentDateString() + "sssssssssss";
        this.value = new AtomicInteger(0);
    }


    /**
     * 获取计数器加1以后的值
     *
     * @return
     */
    public Integer addAndGet() {

        AtomicInteger oldValue = value;
        AtomicInteger newInteger = new AtomicInteger(0);

        int newVal = -1;
        String newDateStr = getCurrentDateString();
        //日期一致,计数器加1后返回
        if (isDateEquals(newDateStr)) {
            newVal = add(1);
            return newVal;
        }

        //日期不一致,保证有一个线程重置技术器
        reSet(oldValue, newInteger, newDateStr);
        this.key = newDateStr;
        //重置后加1返回
        newVal = add(1);
        return newVal;
    }

    /**
     * 获取计数器的当前值
     * @return
     */
    public Integer get() {
        return value.get();
    }

    /**
     * 判断当前日期与老的日期(也即key成员变量记录的值)是否一致
     *
     * @return
     */
    private boolean isDateEquals(String newDateStr) {
        String oldDateStr = key;
        if (!isBlank(oldDateStr) && oldDateStr.equals(newDateStr)) {
            return true;
        }

        return false;
    }


    /**
     * 如果日期发生变化,重置计数器,也即将key设置为当前日期,并将value重置为0,重置后才能接着累加,
     */
    private void reSet(AtomicInteger oldValue, AtomicInteger newValue, String newDateStr) {
        if(valueUpdater.compareAndSet(this, oldValue, newValue)) {
            System.out.println("线程" + Thread.currentThread().getName() + "发现日期发生变化");
        }
    }

    /**
     * 获取当前日期字符串
     *
     * @return
     */
    private String getCurrentDateString() {
        Date date = new Date();
        String newDateStr = new SimpleDateFormat(DATE_PATTERN).format(date);
        return newDateStr;
    }

    /**
     * 计数器的值加1。采用CAS保证线程安全性
     *
     * @param increment
     */
    private int add(int increment) {
       return value.addAndGet(increment);
    }

    public static boolean isBlank(CharSequence cs) {
        int strLen;
        if(cs != null && (strLen = cs.length()) != 0) {
            for(int i = 0; i < strLen; ++i) {
                if(!Character.isWhitespace(cs.charAt(i))) {
                    return false;
                }
            }

            return true;
        } else {
            return true;
        }
    }

    public static void test() {
        CircularCounter c = new CircularCounter();
        AtomicInteger count = new AtomicInteger(0);
        List<Thread> li = new ArrayList<Thread>();
        int size = 10;
        CountDownLatch latch1 = new CountDownLatch(1);
        CountDownLatch latch2 = new CountDownLatch(size);
        for (int i = 0; i < size; i++) {
            Thread t = new Thread(new CounterRunner(c, latch1, latch2, count), "thread-" + i);
            li.add(t);
            t.start();
        }
        System.out.println("start");
        latch1.countDown();

        try {
            latch2.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(count.get());
        System.out.println(c.get());
        if(count.get() == c.get()) {
            System.out.println("该计数器是线程安全的!!!");
        }

    }

    public static void main(String... args) {
        for(int i = 0; i < 15; i++) {
            test();
        }
    }


}


/**
 * 测试使用的Runnable对象
 */
class CounterRunner implements Runnable {
    private CircularCounter counter;
    private CountDownLatch latch1;
    private CountDownLatch latch2;
    private AtomicInteger count;

    public CounterRunner(CircularCounter counter, CountDownLatch latch1, CountDownLatch latch2, AtomicInteger count) {
        this.latch1 = latch1;
        this.latch2 = latch2;
        this.counter = counter;
        this.count = count;
    }

    @Override
    public void run() {

        try {
            latch1.await();
            System.out.println("****************");

            for (int i = 0; i < 20; i++) {
                counter.addAndGet();
                count.addAndGet(1);
            }
            latch2.countDown();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
  • 4
    点赞
  • 18
    收藏
    觉得还不错? 一键收藏
  • 4
    评论
当涉及到多线程编程时,有许多不同的方法可以实现。下面是一个简单的Java多线程示例,展示了一个存取代码的例子: ```java public class ThreadExample { private int count = 0; public static void main(String[] args) { ThreadExample example = new ThreadExample(); example.startThread(); } public void startThread() { Thread thread1 = new Thread(new Runnable() { @Override public void run() { for (int i = 0; i < 1000000; i++) { increment(); } } }); Thread thread2 = new Thread(new Runnable() { @Override public void run() { for (int i = 0; i < 1000000; i++) { increment(); } } }); thread1.start(); thread2.start(); try { thread1.join(); thread2.join(); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("Count: " + count); } public synchronized void increment() { count++; } } ``` 在这个例子中,我们创建了一个名为`ThreadExample`的类,其中包含了一个私有的`count`变量。我们创建了两个线程,每个线程都会递增`count`变量的值1000000次。这里使用`synchronized`关键字来确保在多线程环境下对`increment()`方法的访问是同步的,避免了竞态条件(race condition)的发生。 在`startThread()`方法中,我们启动了这两个线程,并使用`join()`方法等待它们完成。最后,我们打印出最终的`count`值。 请注意,这只是一个简单的示例,用于说明多线程编程的基本概念。在实际开发中,您可能需要更复杂的同步机制来处理共享资源的访问。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 4
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值