- 浏览: 1248554 次
- 性别:
- 来自: 杭州
文章分类
- 全部博客 (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 3237AtomicReferenceFieldUpdater位于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 2017LinkedBlockingDeque是LinkedL ... -
ExecutorService 分析
2013-03-26 18:37 2372public 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 3890public 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 1919线程互斥是一次只有一个线程执行某段代码,保证数据的一致性。线程 ... -
AbstractQueuedSynchronizer(4)
2012-04-13 12:58 2483Condition是一个条件功能的class,必须放在Lock ...
相关推荐
Java AtomicInteger类使用方法实例讲解 Java AtomicInteger类是Java语言中的一种高效的原子操作类,主要用于在高并发环境下的高效程序处理。AtomicInteger类提供了一种线程安全的加减操作接口,能够帮助开发者简化...
在某些场景下,使用AtomicInteger比使用synchronized块或Lock更有优势,因为它避免了线程阻塞,减少了上下文切换的开销。 在实际应用中,我们可以用AtomicInteger来实现分布式系统中的序列号生成,或者作为并发缓存...
Java AtomicInteger类的使用方法详解 Java AtomicInteger类是Java中提供的一种原子操作的Integer类,通过线程安全的方式操作加减。它可以在高并发情况下使用,提供原子操作来进行Integer的使用。 Atomicinteger类...
测试java.util.concurrent.atomic.AtomicInteger的类 与直接使用int做区别
本文将详细介绍 AtomicInteger 的工作原理、使用方法以及如何在实际项目中应用它。 AtomicInteger 是Java并发编程中实现原子操作的重要工具。它通过 Unsafe 类提供的硬件级别的原子操作和 volatile 关键字保证了操作...
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 ...
测试中,作者创建了两个线程安全的场景:一个是使用`AtomicInteger`,另一个是使用普通的`int`变量。在每个场景中,都创建了100个线程,每个线程执行10000600次递增操作。通过`CountDownLatch`来协调线程的启动和...
Java并发之AtomicInteger源码分析 AtomicInteger是Java并发包下面提供的原子类,主要操作的是int类型的整型,通过调用底层Unsafe的CAS等方法实现原子操作。下面是对AtomicInteger的源码分析。 1. 什么是原子操作...
由于多个线程可能同时更新这个索引(例如,定时器和用户触摸事件),所以使用AtomicInteger保证了在多线程环境下的数据一致性。通过原子操作`incrementAndGet()`或`decrementAndGet()`,可以实现自动轮播时索引的...
在这里,我们可以看到 AtomicInteger 使用了 CAS 操作来实现乐观锁。compareAndSet 方法就是使用 CAS 操作来更新变量的值。如果更新成功,那么返回 true,否则返回 false。 在 Java 中,java.util.concurrent 包...
乐观锁一般是通过cas(compareand swap)的思想来实现,例如一些原子类AtomicInteger使用自旋来原子更新。 四、共享锁和排他锁 共享锁也称读锁或S锁。如果事务对数据A加上共享锁后,则其他事务只能对A再加共享锁,...
本文将深入探讨如何使用`AtomicInteger`来实现一个简单的计数器,并解释为什么它能在多线程环境下保证原子性操作的安全性。 #### 二、Java Memory Model简介 Java Memory Model (JMM) 是Java虚拟机(JVM)的一个核心...
AtomicInteger示例AtomicInteger用于原子增量计数器之类的应用程序。 简短的示例代码: public class AtomicIntegerExample { private final ExecutorService execService = Executors . newFixedThreadPool( 100 );...
1. **基础原理**:分页的基本思路是通过SQL查询获取当前页的数据,通常会使用LIMIT或OFFSET关键字来限制返回的记录数。配合着页码和每页记录数,可以计算出要查询的范围。 2. **实现方式**:在JSP中,通常会创建一...
- **多维数组**:二维数组及其使用。 5. **字符串**: - **String类**:不可变性、常用方法如concat、substring、indexOf、replace等。 - **StringBuilder与StringBuffer**:可变字符串,线程安全与非安全的区别...
然而,对于自动加一的操作,直接使用volatile可能不足以保证原子性,因此通常推荐使用AtomicInteger。 4. 数据库操作: 如果投票系统是分布式的,可能需要将投票数据存储在数据库中。在这种情况下,可以使用数据库...
原子变量操作:展示如何使用AtomicInteger等原子类进行线程安全的变量操作。 锁机制:包括ReentrantLock、ReadWriteLock等锁的使用示例。 技术架构 Java:作为后端开发的主要语言,Java提供了强大的多线程支持和...
线程基础,线程池,生命周期
空间预分配:对字符串进行增长操作时的优化,SDS API 会检查SDS当前空间是否符合修改条件,如果不符合 不但会分配修改所需空间还会分配给free属性额外的未使用空间 惰性空间释放:对字符串进行缩减操作时
例如,AtomicInteger类提供了如compareAndSet、getAndIncrement等原子操作方法,这些方法内部都使用了CAS算法。 AtomicInteger类的使用示例: ```java AtomicInteger atomicInteger = new AtomicInteger(0); // ...