AtomicInteger 的使用

Atomic 原子的  Automatic自动的

1.synchronized(同步锁)：以时间换取安全，效率低下

2.ThreadLocal：以空间换取时间，比较消耗资源，安全

3.单例模式用双重锁比价好，线程安全且效率还行

4.线程的挂起有wait(被动，需要外界唤起)，sleep（主动，不释放资源），当然，叫挂起好像有点不太合适，我这里只是说这个意思。唤起有：notify(他是随机唤起的)，一般用nofityAll(唤起所有其他线程)，更底层的可以用LocalSupport，可以控制线程的等待与开启（好像是synchronized的底层实现，具体我也没有去研究源码）

5.Thread类，Runnable接口（Thread的底层实现，有时候不能用thread可以用runnable），Callable接口（有返回值）　　

6.原子类（AtomicInteger等），用来解决多线程问题，因为其具有原子性（也就是说转换为汇编语言是一句，机器一次只会执行一个这种语句）

7.线程安全的类：hashtable，enumeration，statck，vector，stringbuffer等

1、为什么使用AtomicInteger

• 1. AtomicReference等原子类的类，主要用于在高并发环境下的高效程序处理,来帮助我们简化同步处理.
• 2. 在Java语言中，++i和i++操作并不是线程安全的，在使用的时候，不可避免的会用到synchronized关键字。而AtomicInteger则通过一种线程安全的加减操作接口。

---

AtomicInteger介绍

 

 内部使用非公平锁 保证线程安全

AtomicInteger是一个提供原子操作的Integer类，通过线程安全的方式操作加减。

---

AtomicInteger使用场景

AtomicInteger提供原子操作来进行Integer的使用，因此十分适合高并发情况下的使用。

获取和赋值

atomicInteger.get(); //获取当前值
atomicInteger.set(999); //设置当前值


getAndAdd()方法与AddAndGet方法

AtomicInteger atomicInteger = new AtomicInteger(123);
System.out.println(atomicInteger.get());  --123
System.out.println(atomicInteger.getAndAdd(10)); --123 获取当前值，并加10
System.out.println(atomicInteger.get()); --133
System.out.println(atomicInteger.addAndGet(10)); --143 获取加10后的值，先加10
System.out.println(atomicInteger.get()); --143


getAndDecrement()和DecrementAndGet()方法

AtomicInteger atomicInteger = new AtomicInteger(123);
System.out.println(atomicInteger.get());   --123
System.out.println(atomicInteger.getAndDecrement()); --123 获取当前值并自减
System.out.println(atomicInteger.get());  --122
System.out.println(atomicInteger.decrementAndGet()); --121 先自减再获取减1后的值
System.out.println(atomicInteger.get()); --121

getAndIncrement() 计数方法

 

 

CAS，悲观锁，乐观锁

不锁定资源，也能同步线程！

用到的技术就是CAS！

假如一个女神有一块牌子，0代表可以进行约会，1代表已经在进行约会，

有舔狗一号，舔狗二号，舔狗一号率先冲到女神这，并且把牌子改为1，

舔狗二号只能等等咯，就来回踱步进行自旋，不断通过CAS看看女神是否可以进行约会，

达到一定的时间，耐心耗尽就会离开。

但是这样也会有一些问题，如果有多个线程同时看到牌子为0，同时都更改为1，这样就尴尬了

所以CAS必须保证原子性！

但是如何保证原子性呢？难不成使用synchronized？那不是还是用到了锁嘛！

实际上CPU指令集提供了对CAS的支持，保证上层调用时是原子性的！

悲观锁（互斥锁 即synchronized） ，上篇文章都是在将悲观锁。

乐观锁，乐观锁并没有用到锁，它是一种无锁的同步机制。

现在提出一个需求，三个线程将数字累加到1000

加上synchronized(main.class)互斥锁可以保证同步

但是不加锁如何保证线程的同步呢？

使用AutomaticInteger类，其底层就是用的CAS机制，

里面有一个循环，默认是10次，进行十次CAS还没有等到就不再进行自旋。

自旋的次数其实可以通过启动参数来配置

CAS是英文单词CompareAndSwap的缩写，中文意思是：比较并替换。CAS需要有3个操作数：内存地址V，旧的预期值A，即将要更新的目标值B。

CAS指令执行时，当且仅当内存地址V的值与预期值A相等时，将内存地址V的值修改为B，否则就什么都不做。整个比较并替换的操作是一个原子操作。

如果在这段期间它的值曾经被改成了B，后来又被改回为A，那CAS操作就会误认为它从来没有被改变过。这个漏洞称为CAS操作的“ABA”问题。Java并发包为了解决这个问题，提供了一个带有标记的原子引用类“AtomicStampedReference”，它可以通过控制变量值的版本来保证CAS的正确性。

因此，在使用CAS前要考虑清楚“ABA”问题是否会影响程序并发的正确性，如果需要解决ABA问题，改用传统的互斥同步可能会比原子类更高效。