我的项目需要：实现多线程达到数据的亿级自增，并且尽可能让工夫缩短 ,要求：
(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(); Thread th; 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(); Thread th = 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(); Thread th = 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(); public void 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(); Thread th; 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); public void 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(); Thread th; 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