前几天工作中一段业务代码需要一个变量每天从1开始递增。为此自己简单的封装了一个线程安全的计数器，可以让一个变量每天从1开始递增。当然了，如果项目在运行中发生重启，即便日期还是当天，还是会从1开始重新计数。所以把计数器的值存储在数据库中会更靠谱，不过这不影响这段代码的价值，现在贴出来，供有需要的人参考。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
|
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线程安全的计数器简单实现代码示例的内容，希望对大家有所帮助，有什么问题可以随时留言，欢迎大家一起交流讨论。感谢朋友们对服务器之家网站的支持！
原文链接：http://blog.csdn.net/nmgrd/article/details/77015206