Java线程安全的计数器简单实现代码示例

前几天工作中一段业务代码需要一个变量每天从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();
    }
  }
}

总结

以上就是本文关于java线程安全的计数器简单实现代码示例的内容，希望对大家有所帮助，感兴趣的朋友可以参阅：java线程安全基础概念解析、 、java线程安全与非线程安全解析等。有什么问题可以随时留言，欢迎大家一起交流讨论。感谢朋友们对网站的支持！