十一种方法实现亿级数据++
项目需求：实现多线程达到数据的亿级自增，并且尽可能让时间缩短 ,要求：
(1)速度要快
(2)安全性要高
第1种方式
package com.example.currency03;
import java.util.concurrent.atomic.AtomicLong;
/**
* 1· 运用Thread、AtomicLong、线程join实现
*/
public class Counter1 {
public static AtomicLong inc = new AtomicLong();
public void increase() {
// 数据加一
inc.getAndIncrement();
}public static void count() throws InterruptedException {
final Counter1 c1 = new Counter1();
Threadth;
long t1 = System.currentTimeMillis();
for(int i = 0;
i < 1000;
i++) {
th = new Thread(() -> {
for(int j = 0;
j < 100000;
j++) {
c1.increase();
}
});
th.start();
th.join();
}
long t2 = System.currentTimeMillis();
System.out.println("Counter1 , "+String.format("结果：%s,耗时(ms)：%s", inc, (t2 - t1)));
}public static void main(String[] args) throws InterruptedException {
for (int i = 0;
i < 10;
i++) {
inc.set(0);
count();
}
}
}
耗费时间如下：
文章图片
第2种方式
package com.example.currency03;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
/**
* 2、运用thread、reentrantlock、线程join
*/
public class Counter2 {
public static Integer inc = 0;
Lock lock = new ReentrantLock();
public void increase() {
lock.lock();
try {
inc++;
} finally {
lock.unlock();
}
}
public static void count() throws InterruptedException {
final Counter2 c2 = new Counter2();
Thread th;
Long t1 = System.currentTimeMillis();
for(int i = 0;
i < 1000;
i++) {
th = new Thread(() -> {
for(int j = 0;
j < 100000;
j++) {
c2.increase();
}
});
th.start();
th.join();
}
long t2 = System.currentTimeMillis();
System.out.println("Counter2 , "+String.format("结果：%s,耗时(ms)：%s", inc, (t2 - t1)));
}public static void main(String[] args) throws InterruptedException {
for (int i = 0;
i < 10;
i++) {
inc = 0;
count();
}
}
}
耗费时间如下：
文章图片
第3种方式
package com.example.currency03;
/**
* 3、运用thread、synchronized、线程join
*/
public class Counter3 {
public static Integer inc = 0;
public synchronized void increase() {
inc++;
}
public static void count() throws InterruptedException {
final Counter3 c3 = new Counter3();
Thread th;
long t1 = System.currentTimeMillis();
for (int i = 0;
i < 1000;
i++) {
th = new Thread(() -> {
for(int j = 0;
j < 100000;
j++) {
c3.increase();
}
});
th.start();
th.join();
}
long t2 = System.currentTimeMillis();
System.out.println("Counter3, "+String.format("结果：%s,耗时(ms)：%s", inc, (t2 - t1)));
}public static void main(String[] args) throws InterruptedException {
for (int i = 0;
i < 10;
i++) {
inc = 0;
count();
}}
}
耗费时间如下：
文章图片
第4种方式
package com.example.currency03;
import java.util.concurrent.atomic.AtomicLong;
/**
* 4、运用thread、AtomicLong、线程状态TERMINATED
*/
public class Counter4 {
public static AtomicLong inc = new AtomicLong();
public void crease() {
inc.getAndIncrement();
}
public static void count() throws InterruptedException {
final Counter4 c4 = new Counter4();
long t1 = System.currentTimeMillis();
Threadth = null;
for(int i = 0;
i < 1000;
i++) {
th = new Thread(() -> {
for(int j = 0;
j < 100000;
j++) {
c4.crease();
}
});
th.start();
while(th.getState()!=Thread.State.TERMINATED){
Thread.sleep(1);
}
}
long t2 = System.currentTimeMillis();
System.out.println("Counter4, "+String.format("结果：%s,耗时(ms)：%s", inc, (t2 - t1)));
}public static void main(String[] args) throws InterruptedException {
for (int i = 0;
i < 10;
i++) {
inc.set(0);
count();
}
}}
耗费时间如下：
文章图片
第5种方式
package com.example.currency03;
import java.util.concurrent.atomic.AtomicLong;
/**
* 5、运用Thread、AtomicLong、线程isAlive等实现
*/
public class Counter5 {
public static AtomicLong inc = new AtomicLong();
public void increase() {
inc.getAndIncrement();
}
public static void count() throws InterruptedException {
final Counter5 c5 = new Counter5();
Threadth = null;
long t1 = System.currentTimeMillis();
for(int i = 0;
i < 1000;
i++) {
th = new Thread(() -> {
for(int j = 0;
j < 100000;
j++) {
c5.increase();
}
});
th.start();
while(th.isAlive()){
Thread.sleep(1);
}}
long t2 = System.currentTimeMillis();
System.out.println("Counter5, "+String.format("结果：%s,耗时(ms)：%s", inc, (t2 - t1)));
}public static void main(String[] args) throws InterruptedException {
for (int i = 0;
i < 10;
i++) {
inc.set(0);
count();
}}
}
耗费时间如下：
文章图片
第6种方式
package com.example.currency03;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutionException;
/**
* 6、运用Thread、synchronized、线程CountDownLatch等实现
*/
public class Counter6 {
public static int inc = 0;
public synchronized static void increase() {
inc++;
}
public static void count() throws InterruptedException {
int threadCount = 1000;
long t1 = System.currentTimeMillis();
CountDownLatch countDownLatch = new CountDownLatch(threadCount);
for(int i = 0;
i < threadCount;
i++) {
new Thread(() -> {
try {
for (int j = 0;
j < 100000;
j++) {
increase();
}
} finally {
countDownLatch.countDown();
}}).start();
}
countDownLatch.await();
long t2 = System.currentTimeMillis();
System.out.println("Counter6, "+String.format("结果：%s,耗时(ms)：%s", inc, (t2 - t1)));
}
public static void main(String[] args) throws ExecutionException, InterruptedException {
for (int i = 0;
i < 10;
i++) {
inc = 0;
count();
}
}}
耗费时间如下：
文章图片
第7种方式
package com.example.currency03;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.atomic.AtomicLong;
/**
* 7、运用Thread、AtomicLong、线程CountDownLatch等实现
*/
public class Counter7 {
public static AtomicLong inc = new AtomicLong(0);
public static void increase() {
inc.getAndIncrement();
}
public static void count() throws InterruptedException {
int threadCount = 1000;
long t1 = System.currentTimeMillis();
CountDownLatch countDownLatch = new CountDownLatch(threadCount);
for(int i = 0;
i < threadCount;
i++) {
new Thread(() -> {
try {for(int j = 0;
j < 100000;
j++) {
increase();
}} finally {
countDownLatch.countDown();
}
}).start();
}
countDownLatch.await();
long t2 = System.currentTimeMillis();
System.out.println("Counter7, "+String.format("结果：%s,耗时(ms)：%s", inc, (t2 - t1)));
}public static void main(String[] args) throws ExecutionException, InterruptedException {
for (int i = 0;
i < 10;
i++) {
inc.set(0);
count();
}
}
}
耗费时间如下：
文章图片
第8种方式
package com.example.currency03;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.atomic.LongAdder;
/**
* 8、运用Thread、LongAddr、线程CountDownLatch等实现
*/
public class Counter8 {
public static LongAdder longAdder = new LongAdder();
public static void increase() {
longAdder.increment();
}public static void count() throws InterruptedException {
int threadCount = 1000;
long t1 = System.currentTimeMillis();
CountDownLatch countDownLatch = new CountDownLatch(threadCount);
for (int i = 0;
i < threadCount;
i++) {
new Thread(() -> {
try {
for (int j = 0;
j < 100000;
j++) {
increase();
}} finally {
countDownLatch.countDown();
}
}).start();
}
countDownLatch.await();
long t2 = System.currentTimeMillis();
System.out.println("Counter8, " + String.format("结果：%s,耗时(ms)：%s", longAdder.sum(), (t2 - t1)));
}public static void main(String[] args) throws ExecutionException, InterruptedException {
for (int i = 0;
i < 10;
i++) {
longAdder.reset();
count();
}
}
}耗费时间如下：
文章图片
第9种方式
package com.example.currency03;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.atomic.LongAccumulator;
/**
* 9、运用Thread、LongAccumulator、线程CountDownLatch等实现
*/
public class Counter9 {
private static LongAccumulator inc = new LongAccumulator((x, y) -> x + y, 0L);
public static void incr() {
inc.accumulate(1);
}public static void count() throws InterruptedException {
int threadCount = 1000;
long t1 = System.currentTimeMillis();
CountDownLatch countDownLatch = new CountDownLatch(threadCount);
for(int i = 0;
i < threadCount;
i++) {
new Thread(() -> {
try {
for(int j = 0;
j < 100000;
j++) {
incr();
}
} finally {
countDownLatch.countDown();
}}).start();
}
countDownLatch.await();
long t2 = System.currentTimeMillis();
System.out.println("Counter9, "+String.format("结果：%s,耗时(ms)：%s", inc.longValue(), (t2 - t1)));
}public static void main(String[] args) throws ExecutionException, InterruptedException {
for (int i = 0;
i < 10;
i++) {
inc.reset();
count();
}
}}
耗费时间如下：
文章图片
第10种方式
package com.example.currency03;
import java.util.concurrent.atomic.LongAdder;
/**
* 10、运用Thread、LongAdder、线程join的实现
*/
public class Counter10 {
public static LongAdder inc = new LongAdder();
publicvoid increase() {
inc.increment();
}public static void main(String[] args) throws InterruptedException {
for (int i = 0;
i < 10;
i++) {
inc.reset();
count();
}}private static void count() throws InterruptedException {
final Counter10 test = new Counter10();
Threadth;
long t1 = System.currentTimeMillis();
for(int i=0;
i<1000;
i++){
th= new Thread(() -> {
for(int j = 0;
j < 100000;
j++) {
test.increase();
}
});
th.start();
th.join();
}long t2 = System.currentTimeMillis();
System.out.println("Counter10 , "+String.format("结果：%s,耗时(ms)：%s", inc, (t2 - t1)));
}}
耗费时间如下：
文章图片
第11种方式
package com.example.currency03;
import java.util.concurrent.atomic.LongAccumulator;
/**
* 运用Thread、LongAccumulator、线程join的实现
*/
public class Counter11 {
static LongAccumulator inc = new LongAccumulator((x, y) -> x + y, 0L);
publicvoid increase() {
inc.accumulate(1);
}public static void main(String[] args) throws InterruptedException {
for (int i = 0;
i < 10;
i++) {
inc.reset();
count();
}}private static void count() throws InterruptedException {
final Counter11 test = new Counter11();
Threadth;
long t1 = System.currentTimeMillis();
for(int i=0;
i<1000;
i++){
th= new Thread(() -> {
for(int j = 0;
j < 100000;
j++) {
test.increase();
}
});
th.start();
th.join();
}long t2 = System.currentTimeMillis();
System.out.println("Counter11 , "+String.format("结果：%s,耗时(ms)：%s", inc, (t2 - t1)));
}}
耗费时间如下：
文章图片
【十一种方法实现亿级数据++】GITHUB
推荐阅读
- 《真与假的困惑》???|《真与假的困惑》??? ——致良知是一种伟大的力量
- 三十年后的广场舞大爷
- 午门传说
- 一百二十三夜，请嫁给我
- 迷失的世界（二十七）
- 对抗抑郁最好的方法
- 怎样用黑谜速冻膜去黑头，|怎样用黑谜速冻膜去黑头， 最有效的去黑头的方法看这!
- 二十年后的家乡
- 移动端h5调试方法
- 研学让生活更美好