- 浏览: 1237741 次
- 性别:
- 来自: 杭州
文章分类
- 全部博客 (193)
- ant/maven (6)
- algorithm (5)
- tomcat/weblogic/jboss (6)
- javascript/jquery (13)
- java (33)
- flex/flash (0)
- JPA/Hibernate/myBatis (18)
- java concurrent (7)
- test (2)
- windows/linux (6)
- java collection (7)
- design pattern (2)
- life/health (3)
- database (12)
- IDE (4)
- spring/ejb (20)
- html/css/ckeditor (7)
- jsp/servlet (3)
- java io (13)
- java security (4)
- jni (0)
- svn/git (2)
- english (2)
- java jmx (1)
- xml (1)
- struts/springmvc (9)
- middleware (2)
- cache (1)
- cglib (3)
最新评论
-
jlotusYo:
博主,真感谢。
Java 密码扩展无限制权限策略文件 -
senninha:
这个。。是api说明吧。。
ScheduledExecutorService 源码分析 -
zoutao2008:
请问大文件如何处理?按你这种方式的话,文件超过200M时就会报 ...
hessian系列之二:上传文件 -
lwj1113:
lwj1113 写道谢谢博主这么细致的demo;在系列五中通过 ...
myBatis系列之五:与Spring3集成 -
lwj1113:
谢谢博主这么细致的demo;在系列五中通过testng测试类跑 ...
myBatis系列之五:与Spring3集成
Java中,i++和++i都不是原子操作,多线程环境下需要使用synchronized关键字。JDK1.5的java.util.concurrent.atomic包提供了原子操作类,通过Unsafe类调native方法来实现。
这里以AtomicInteger为例:
内部存储
维护了一个整型值,其初始值为0。考虑到多线程操作,使用volatile来保证其可见性:
单独赋值操作
通过构造函数设置:
Setter:
延迟赋值:
获取和赋值复合操作:
Getter:
获取原值并设置新值:
获取原值并自增:
获取原值并自减:
获取原值并加上指定值:
delta可以为负值,实现getAndSubtract功能
自增并获取新值:
自减并获取新值:
加上指定值并获取新值:
同上,delta可以为负值,实现subtractAndGet功能
可以看出,上面的方法比较类似:循环地调用compareAndSet方法,一旦成功即返回。
看下compreAndSet方法:
同时,还提供了weakCompareAndSet方法,调用的unsafe方法和上面相同:
性能测试
1. 和synchronized比较,单线程执行1000w次自增操作:
输出:
Synch elapsed: 383ms
Atomic elapsed: 208ms (单线程环境下,AtomicInteger比同步的性能稍好一点)
2. 多线程多次操作:
这里使用100个线程,每个线程执行10w次自增操作,为了统计100个线程并发执行所耗费的时间,使用CountDownLatch来协调。
输出:
Synch elapsed: 1921ms, value=10000000
Atomic elapsed: 353ms, value=10000000 (AtomicInteger的性能是synchronized的5倍多)
当给value加上volatile修饰符时:
Synch elapsed: 2268ms, value=10000000 (volatile禁止代码重排序,一定程度上降低了性能)
Atomic elapsed: 337ms, value=10000000
当调用未同步的自增方法unSyncIncrease时:
Synch elapsed: 216ms, value=5852266 (非原子操作不加同步,导致结果错误)
Atomic elapsed: 349ms, value=10000000
这里以AtomicInteger为例:
内部存储
维护了一个整型值,其初始值为0。考虑到多线程操作,使用volatile来保证其可见性:
private volatile int value;
单独赋值操作
通过构造函数设置:
public AtomicInteger(int initialValue) { value = initialValue; }
Setter:
public final void set(int newValue) { value = newValue; }
延迟赋值:
public final void lazySet(int newValue) { unsafe.putOrderedInt(this, valueOffset, newValue); }
获取和赋值复合操作:
Getter:
public final int get() { return value; }
获取原值并设置新值:
public final int getAndSet(int newValue) { for (;;) { int current = get(); if (compareAndSet(current, newValue)) return current; } }
获取原值并自增:
public final int getAndIncrement() { for (;;) { int current = get(); int next = current + 1; if (compareAndSet(current, next)) return current; } }
获取原值并自减:
public final int getAndDecrement() { for (;;) { int current = get(); int next = current - 1; if (compareAndSet(current, next)) return current; } }
获取原值并加上指定值:
delta可以为负值,实现getAndSubtract功能
public final int getAndAdd(int delta) { for (;;) { int current = get(); int next = current + delta; if (compareAndSet(current, next)) return current; } }
自增并获取新值:
public final int incrementAndGet() { for (;;) { int current = get(); int next = current + 1; if (compareAndSet(current, next)) return next; } }
自减并获取新值:
public final int decrementAndGet() { for (;;) { int current = get(); int next = current - 1; if (compareAndSet(current, next)) return next; } }
加上指定值并获取新值:
同上,delta可以为负值,实现subtractAndGet功能
public final int addAndGet(int delta) { for (;;) { int current = get(); int next = current + delta; if (compareAndSet(current, next)) return next; } }
可以看出,上面的方法比较类似:循环地调用compareAndSet方法,一旦成功即返回。
看下compreAndSet方法:
public final boolean compareAndSet(int expect, int update) { return unsafe.compareAndSwapInt(this, valueOffset, expect, update); }
同时,还提供了weakCompareAndSet方法,调用的unsafe方法和上面相同:
public final boolean weakCompareAndSet(int expect, int update) { return unsafe.compareAndSwapInt(this, valueOffset, expect, update); }
性能测试
1. 和synchronized比较,单线程执行1000w次自增操作:
public class AtomicIntegerSynchTest { private int value; public AtomicIntegerSynchTest(int value) { this.value = value; } public synchronized int increase() { return value++; } public static void main(String[] args) { long start = System.currentTimeMillis(); AtomicIntegerSynchTest test = new AtomicIntegerSynchTest(0); for (int i = 0; i < 10000000; i++) { test.increase(); } long end = System.currentTimeMillis(); System.out.println("Synch elapsed: " + (end - start) + "ms"); long start2 = System.currentTimeMillis(); AtomicInteger atomicInt = new AtomicInteger(0); for (int i = 0; i < 10000000; i++) { atomicInt.incrementAndGet(); } long end2 = System.currentTimeMillis(); System.out.println("Atomic elapsed: " + (end2 - start2) + "ms"); } }
输出:
Synch elapsed: 383ms
Atomic elapsed: 208ms (单线程环境下,AtomicInteger比同步的性能稍好一点)
2. 多线程多次操作:
这里使用100个线程,每个线程执行10w次自增操作,为了统计100个线程并发执行所耗费的时间,使用CountDownLatch来协调。
public class AtomicIntegerMultiThreadTest { private /*volatile*/ int value; public AtomicIntegerMultiThreadTest(int value) { this.value = value; } public synchronized int increase() { return value++; } public int unSyncIncrease() { return value++; } public int get() { return value; } public static void main(String[] args) throws InterruptedException { long start = System.currentTimeMillis(); final CountDownLatch latch = new CountDownLatch(100); final AtomicIntegerMultiThreadTest test = new AtomicIntegerMultiThreadTest(0); for (int i = 0; i < 100; i++) { new Thread(new Runnable() { @Override public void run() { for (int i = 0; i < 100000; i++) { test.increase(); //test.unSyncIncrease(); } latch.countDown(); } }).start(); } latch.await(); long end = System.currentTimeMillis(); System.out.println("Synch elapsed: " + (end - start) + "ms, value=" + test.get()); long start2 = System.currentTimeMillis(); final CountDownLatch latch2 = new CountDownLatch(100); final AtomicInteger atomicInt = new AtomicInteger(0); for (int i = 0; i < 100; i++) { new Thread(new Runnable() { @Override public void run() { for (int i = 0; i < 100000; i++) { atomicInt.incrementAndGet(); } latch2.countDown(); } }).start(); } latch2.await(); long end2 = System.currentTimeMillis(); System.out.println("Atomic elapsed: " + (end2 - start2) + "ms, value=" + atomicInt.get()); } }
输出:
Synch elapsed: 1921ms, value=10000000
Atomic elapsed: 353ms, value=10000000 (AtomicInteger的性能是synchronized的5倍多)
当给value加上volatile修饰符时:
Synch elapsed: 2268ms, value=10000000 (volatile禁止代码重排序,一定程度上降低了性能)
Atomic elapsed: 337ms, value=10000000
当调用未同步的自增方法unSyncIncrease时:
Synch elapsed: 216ms, value=5852266 (非原子操作不加同步,导致结果错误)
Atomic elapsed: 349ms, value=10000000
发表评论
-
AtomicReferenceFieldUpdater 使用
2014-11-19 22:13 3180AtomicReferenceFieldUpdater位于ja ... -
LockSupport 分析
2014-08-03 21:26 0LockSupport 构造器是私有的,外界主要通过LockS ... -
死锁系列之一:模拟
2014-07-20 18:12 0死锁产生的原因是: 1. 多个线程以不同的顺序来锁共享资源 2 ... -
Java线程死锁检测
2014-07-20 12:55 0public class DeadlockDetector ... -
LinkedBlockingDeque 源码分析
2013-04-01 16:04 1975LinkedBlockingDeque是LinkedL ... -
ExecutorService 分析
2013-03-26 18:37 2312public interface ExecutorServ ... -
Exchanger 源码分析
2013-01-29 12:35 0private Object doExchange ... -
ConcurrentHashMap 源码分析
2013-01-29 10:34 0static final int MAX_SEGM ... -
Executors 源码分析
2012-11-06 16:11 0类图: 1. 在任务的方法里面调用ExecutorServ ... -
ScheduledExecutorService 源码分析
2013-03-27 18:08 3791public interface ScheduledExe ... -
3. 共享对象
2012-05-22 11:38 0本章讲述防止多个线程同时访问某个对象。 -
LockSupport 的使用
2012-04-23 16:36 01. park方法 public static ... -
AbstractQueuedSynchronizer(3)
2012-04-20 09:28 0final boolean transferAft ... -
java concurrent (1) - 传统线程互斥和通信
2012-04-19 13:40 1879线程互斥是一次只有一个线程执行某段代码,保证数据的一致性。线程 ... -
AbstractQueuedSynchronizer(4)
2012-04-13 12:58 2428Condition是一个条件功能的class,必须放在Lock ...
相关推荐
主要介绍了Java AtomicInteger类使用方法实例讲解,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
测试java.util.concurrent.atomic.AtomicInteger的类 与直接使用int做区别
AtomicInteger atomicInteger = new AtomicInteger(5); atomicInteger.compareAndSet(5, 2020) + \t current data is + atomicInteger.get()) /** * Atomically sets the value to the given updated value * if ...
主要介绍了Java AtomicInteger类的使用方法详解,文中有具体实例代码,具有一定参考价值,需要的朋友可以了解下。
NULL 博文链接:https://zcmor.iteye.com/blog/1535524
主要介绍了Java中对AtomicInteger和int值在多线程下递增操作的测试,本文得出AtomicInteger操作 与 int操作的效率大致相差在50-80倍上下的结论,需要的朋友可以参考下
利用ViewPager实现的广告轮播,没有触摸事件的时候可以定时轮播广告,有触摸事件实施触摸事件。自动轮播使用的是线程加AtomicInteger的方式实现。
AtomicInteger是java并发包下面提供的原子类,主要操作的是int类型的整型,通过调用底层Unsafe的CAS等方法实现原子操作。下面小编和大家一起学习一下
这个代码实现了一个简单的计数器,使用了Java的`AtomicInteger`类来保证多线程环境下的原子性操作。`AtomicInteger`是一个支持原子操作的整数类,它内部使用了CAS(Compare And Swap)算法来实现线程安全的操作。在...
AtomicInteger示例AtomicInteger用于原子增量计数器之类的应用程序。 简短的示例代码: public class AtomicIntegerExample { private final ExecutorService execService = Executors . newFixedThreadPool( 100 );...
包含了jsp的简单分页,有首页、尾页、上下页、设置页面数字等,有完整的注释、包、ppt等,mysql数据库的,对后台管理的删除有不错的参考价值,非常适合web初学者,改改就可以在多少场合运用。
NULL 博文链接:https://it-fan.iteye.com/blog/1183175
在多线程环境下,对于自增操作需要考虑线程安全问题,常见的解决方法包括使用synchronized关键字、AtomicInteger、LongAdder和LongAccumulator等。本文给出了使用这些方法实现自增的代码演示,并通过多线程测试比较...
线程基础,线程池,生命周期
空间预分配:对字符串进行增长操作时的优化,SDS API 会检查SDS当前空间是否符合修改条件,如果不符合 不但会分配修改所需空间还会分配给free属性额外的未使用空间 惰性空间释放:对字符串进行缩减操作时
kotlinx.atomicfu:在Kotlin中使用原子操作的惯用方式
volatile关键字的非原子性、volatile关键字的使用、AtomicInteger原子性操作、线程安全小例子:多个线程竞争问题、多个线程多个锁问题、创建一个缓存的线程池、多线程使用Vector或者HashTable的示例(简单线程同步...
用Java代码所写的简单计数器,功能:根据选票人投票,最后记录数据并用立方图显示结果
之后又改用了AtomicInteger,确实好用多了。每条线程的request请求相互独立,写操作也是相互独立,所有线程共同遍历一个数组,当遍历完成时跳出,判断完成原来打算使用futureTask.isDone()去判断,但是后来发现这...
19. 使用 ForkJoinPool 进行分叉和合并 20. 锁 Lock 21. 读写锁 ReadWriteLock 22. 原子性布尔 AtomicBoolean 23. 原子性整型 AtomicInteger 24. 原子性长整型 AtomicLong 25. 原子性引用型 AtomicReference