在Java语言中,基本类型的赋值操作是原子操作,但是++i
和i++
操作并不是线程安全的,它们并不是原子操作
tp1 = i; //1
tp2 = tp1 + 1; //2
i = tp2; //3
通过反编译代码我们可以大致了解此操作分为3个操作步骤:第一步,读取i
;第二步,加1
;第三步:写回内存(--i
和i--
同理)
多线程的情况下
如果有两个线程m
和n
要执行i++
操作,因为重排序的影响,代码执行顺序可能会发生改变。
如果代码的执行顺序是m1→m2→m3→n1→n2→n3
,那么结果是没问题的,
如果代码的执行顺序是m1→n1→m2→n2→m3→n3
,很明显结果就会出错。
下面做个测试,有两个线程,每个线程都是for
循环1e
次做++,按照正常逻辑结果应该是2e
int/Integer
型数据:
public class Test {
private static Integer count = 0;
public static void main(String[] args) throws Exception {
test1();
}
static void test1() throws Exception{
Long starTime = System.currentTimeMillis();
Runnable runnable = () -> {
for (int i = 0; i < 100000000; i++){
Test.count++;
}
};
Thread t1 = new Thread(runnable);
Thread t2 = new Thread(runnable);
t1.start();
t2.start();
t1.join();
t2.join();
System.out.println(count);
long endTime = System.currentTimeMillis();
System.out.println("程序运行了:"+(endTime - starTime)+"毫秒");
}
}
结果:count<2e 平均需要2500ms
使用volatile
关键字
public class Test {
private static volatile Integer count = 0;
public static void main(String[] args) throws Exception {
test1();
}
static void test1() throws Exception{
Long starTime = System.currentTimeMillis();
Runnable runnable = () -> {
for (int i = 0; i < 100000000; i++){
Test.count++;
}
};
Thread t1 = new Thread(runnable);
Thread t2 = new Thread(runnable);
t1.start();
t2.start();
t1.join();
t2.join();
System.out.println(count);
long endTime = System.currentTimeMillis();
System.out.println("程序运行了:"+(endTime - starTime)+"毫秒");
}
}
结果:count<2e 平均需要5600ms
因为volatile
并不能保证原子性,只能保证可见性
使用synchronized
关键字
public class Test {
private static Integer count = 0;
public static void main(String[] args) throws Exception {
test1();
}
static void test1() throws Exception{
Long starTime = System.currentTimeMillis();
Runnable runnable = () -> {
synchronized (Test.class){
for (int i = 0; i < 100000000; i++){
Test.count++;
}
}
};
Thread t1 = new Thread(runnable);
Thread t2 = new Thread(runnable);
t1.start();
t2.start();
t1.join();
t2.join();
System.out.println(count);
long endTime = System.currentTimeMillis();
System.out.println("程序运行了:"+(endTime - starTime)+"毫秒");
}
}
结果:count=2e 平均需要1800ms
AtomicInteger
AtomicInteger是对int
类型的一个封装,提供原子性的访问和更新操作,其原子性操作的实现是基于CAS(compare-and-swap
)技术。
Java的并发原子包里面提供了很多可以进行原子操作的类
使用AtomicInteger
整型原子类
public class Test {
private static AtomicInteger count = new AtomicInteger(0);
public static void main(String[] args) throws Exception {
test1();
}
static void test1() throws Exception{
Long starTime = System.currentTimeMillis();
Runnable runnable = () -> {
for (int i = 0; i < 100000000; i++){
count.incrementAndGet();
//count.getAndIncrement();
}
};
Thread t1 = new Thread(runnable);
Thread t2 = new Thread(runnable);
t1.start();
t2.start();
t1.join();
t2.join();
System.out.println(count.get());
long endTime = System.currentTimeMillis();
System.out.println("程序运行了:"+(endTime - starTime)+"毫秒");
}
}
结果:count=2e 平均需要3300ms
也就是说AtomicInteger
是线程安全的。
效率方面使用synchronized
关键字最高,程序的运行时间在每台电脑上都不同,至于测试方法方面如果有错或改进的方面可以评论交流
说明:为什么要在测试中使用线程类的join()
main()
是主线程,在main()
中创建了thread线程,在main()
中调用了thread.join()
,那么等thread
结束后再执行main()
代码。
简单来说:在很多情况下,主线程生成并起动了子线程,如果子线程里要进行大量的耗时的运算,主线程往往将于子线程之前结束,但是如果主线程处理完其他的事务后,需要用到子线程的处理结果,也就是主线程需要等待子线程执行完成之后再结束,这个时候就要用到join()
方法了。
深入了解可以参考
https://blog.csdn.net/u010983881/article/details/80257703
基于源码去分析AtomicInteger
实现线程安全
AtomicInteger
的内部属性
// setup to use Unsafe.compareAndSwapInt for updates
private static final Unsafe unsafe = Unsafe.getUnsafe();
private static final long valueOffset;
static {
try {
valueOffset = unsafe.objectFieldOffset
(AtomicInteger.class.getDeclaredField("value"));
} catch (Exception ex) { throw new Error(ex); }
}
private volatile int value;
1.Unsafe
是Java
提供的获得对对象内存地址访问的类,注释已经清楚的写出了,它的作用就是在更新操作时提供“比较并替换”的作用。
2.valueOffset
这个是指类中相应字段在该类的偏移量,用来记录value
本身在内存的编译地址的,主要是为了在更新操作在内存中找到value
的位置,方便比较。
3.静态初始化块,这个块的作用即是求出value
这个字段的偏移量。具体的方法使用的反射的机制得到value
的Field
对象,再根据objectFieldOffse
t这个方法求出value
这个变量内存中在该对象中的偏移量。
4.volatile
关键字保证了在多线程中value的值是可见的,任何一个线程修改了value
值,会将其立即写回内存当中
在实现自增的操作中,使用到了AtomicInteger
的incrementAndGet()
方法,
其实getAndIncrement()
这个方法都是可以的
public final int getAndIncrement() {
return unsafe.getAndAddInt(this, valueOffset, 1);
}
public final int incrementAndGet() {
return unsafe.getAndAddInt(this, valueOffset, 1) + 1;
}
Unsafe
会利用value
字段的内存地址偏移,直接完成操作。
getAndIncrement( )
:以原子方式将当前值加 1,相当于线程安全的i++
操作
incrementAndGet( )
:以原子方式将当前值加 1, 相当于线程安全的++i
操作
拓展:
getAndDecrement( )
:以原子方式将当前值减 1, 相当于线程安全的i--
操作
decrementAndGet ( )
:以原子方式将当前值减 1,相当于线程安全的--i
操作
addAndGet( )
: 以原子方式将给定值与当前值相加,
实际上就是等于线程安全的i =i+delta
操作
getAndAdd( )
:以原子方式将给定值与当前值相加,
相当于线程安全的t=i
;i+=delta
;return t
;操作
通过源码分析可知,incrementAndGet()
和getAndIncrement()
都调用了
Unsafe
类中的 getAndAddInt()
方法
public final int getAndAddInt(Object var1, long var2, int var4) {
int var5;
do {
var5 = this.getIntVolatile(var1, var2);
} while(!this.compareAndSwapInt(var1, var2, var5, var5 + var4));
return var5;
}
因为getAndIncrement()
和incrementAndGet()
需要返回数值,所以getAndAddInt()
需要添加失败重试逻辑。
getAndAddInt
调用了Unsafe
的native
方法:getIntVolatile()
和compareAndSwapInt()
public final native boolean compareAndSwapInt(Object var1, long var2, int var4, int var5);
public native int getIntVolatile(Object var1, long var2);
getAndAddInt()
做了什么
在do-while
循环中先取得当前值,然后通过CAS
判断当前值是否和current
一致,如果一致意味着值没被其他线程修改过,把当前值设置为当前值+var4
,,如果不相等程序进入信的CAS
循环。(乐观锁的体现)
如何体现乐观锁?
所谓 CAS
,表现为一组指令,当利用CAS
执行试图进行一些更新操作时。会首先比较当前数值,如果数值未变,代表没有其它线程进行并发修改,则成功更新。如果数值改变,则可能出现不同的选择,要么进行重试,要么就返回是否成功。也就是所谓的“乐观锁”。
总结
atomic
这个包里面提供了一组原子变量类。其基本的特性就是在多线程环境下,当有多个线程同时执行这些类的实例包含的方法时,具有排他性,即当某个线程进入方法,执行其中的指令时,不会被其他线程打断,而别的线程就像自旋锁一样,一直等到该方法执行完成,才由JVM从等待队列中选择一个另一个线程进入,这只是一种逻辑上的理解。实际上是借助硬件的相关指令来实现的,不会阻塞线程(或者说只是在硬件级别上阻塞了)。可以对基本数据、数组中的基本数据、对类中的基本数据进行操作。原子变量类相当于一种泛化的volatile
变量,能够支持原子的和有条件的读-改-写操作。
其内部实现不是简单的使用synchronized
,而是一个更为高效的方式
CAS (compare and swap)
+ volatile
和native
方法,从而避免了synchronized
的高开销,执行效率大为提升。使用非阻塞算法实现并发控制,在高并发程序中非常适合
推荐
由于atomic
只提供了int
,long
和boolean
的原子操作类,那么其他的基本类型,
如byte
,char
,float
,double
如何实现原子操作呢,还有原子更新数组,原子更新引用和原子更新属性
具体可以参考文章
https://www.cnblogs.com/senlinyang/p/7856339.html