- CAS
- JUC 常用类
- 1.ConcurrentHashMap
- 2.CopyOnWriteArrayList
- 3.CopyOnWriteArraySet
- 4.辅助类 CountDownLatch
- 5.辅助类 CyclicBarrier
CAS(Compare-And-Swap) ：比较并交换，该算法是硬件对于并发操作的支持.适用于低并发的情况下
CAS 是乐观锁的一种实现方式，他采用的是自旋锁的思想，是一种轻量级的锁机制。
CAS 包含了三个操作数：
①内存值 V ;
②预估值 A (比较时,从内存中再次读到的值) ;
③更新值 B (更新后的值).
当且仅当预期值 A==V，将内存值 V=B，否则什么都不做。
优点:
这种做法的效率高于加锁,当判断不成功不能更新值时,不会导致线程阻塞,继续获得 cpu 执行权,继续判断执行
缺点:
CAS 使用自旋锁的方式，由于该方式会不断循环判断，因此不会类似 synchronize 线程阻塞导致线程切换。但是不断的自旋，会导致 CPU 的消耗，在并发量大的时候(高并发)容易导致 CPU 跑满。
可能会产生ABA问题.
ABA 问题:
ABA 问题，即某个线程将内存值由 A 改为了 B，再由 B 改为了 A。当另外一个 线程使用预期值去判断时，预期值与内存值相同，误以为该变量没有被修改过而 导致的问题。
ABA问题的解决
解决 ABA 问题的主要方式，通过使用类似添加版本号的方式，来避免 ABA 问题。 如原先的内存值为（A，1），线程将（A，1）修改为了（B，2），再由（B，2） 修改为（A，3）。此时另一个线程使用预期值（A，1）与内存值（A，3）进行 比较，只需要比较版本号 1 和 3，即可发现该内存中的数据被更新过了。
JUC 常用类Java 5.0 在 java.utilconcurrent 包中提供了多种并发容器类来改进同步容器的性能.
1.ConcurrentHashMapConcurrentHashMap 同步容器类是 Java 5 增加的一个线程安全的哈希表。对与多线程的操作，介于 HashMap 与 Hashtable 之间。内部采用“锁分段”机制(jdk8 弃用了分段锁，使用 cas+synchronized)替代 Hashtable 的独占锁。进而提高性能。
放弃分段锁的原因:
1.加入多个分段锁浪费内存空间。
2.生产环境中， map 在放入时竞争同一个锁的概率非常小，分段锁反而会造成更新等操作的长时间等待。
jdk8 放弃了分段锁而是用了 Node 锁，减低锁的粒度，提高性能，并使用 CAS 操作来确保 Node 的一些操作的原子性，取代了锁。
put 时首先通过 hash 找到对应链表过后，查看是否是第一个 Node，如果是， 直接用 cas 原则插入，无需加锁。
然后， 如果不是链表第一个 Node， 则直接用链表第一个 Node 加锁，这里加的锁是 synchronized。
HashMap:
import java.util.HashMap;
import java.util.Random;
public class HashmapDemo {
public static void main(String[] args) {
HashMap map = new HashMap<>();
//模拟多个线程对HashMap操作
for (int i = 0; i < 20; i++) {
new Thread(
() -> {
map.put(Thread.currentThread().getName(), new Random().nextInt());
System.out.println(map);
}
).start();
}
}
}
运行结果:( ConcurrentModificationException 并发修改异常,HashMap是线程不安全的)
Hashtable
import java.util.Hashtable;
import java.util.Random;
public class HashtableDemo {
public static void main(String[] args) {
// Map map = Collections.synchronizedMap(new HashMap<>());
Hashtable map = new Hashtable<>();
//模拟多个线程对Hashtable操作
for (int i = 0; i < 20; i++) {
new Thread(
() -> {
map.put(Thread.currentThread().getName(), new Random().nextInt());
System.out.println(map);
}
).start();
}
}
}
运行结果:
Hashtable的方法用synchronized 修饰的,因此是线程安全的
锁直接加在方法上面,锁粒度比较大,效率比较低,用在低并发情况下可以 --> 独占锁
ConcurrentHashMap:
import java.util.Random;
import java.util.concurrent.ConcurrentHashMap;
public class ConcurrentHashMapDemo {
public static void main(String[] args) {
// Map map = Collections.synchronizedMap(new HashMap<>());
ConcurrentHashMap map = new ConcurrentHashMap<>();
//模拟多个线程对ConcurrentHashMap操作
for (int i = 0; i < 20; i++) {
new Thread(
() -> {
map.put(Thread.currentThread().getName(), new Random().nextInt());
System.out.println(map);
}
).start();
}
}
}
运行也是没有问题的,支持并发操作.
总结:
ConcurrentHashMap采用锁分段机制,并没有将整个hash表锁住, jdk8之后没有使用分段锁(给每个位置创建一个锁标志对象).
采用的是CAS思想+synchronized来实现
插入时,检测hash表对应位置是否是第一个节点, 如果是采用CAS机制(循环检查) 向第一个位置插入数据.
如果此位置已经有值,那么就以第一个Node对象为锁标志进行加锁,使用的是synchronized实现.
2.CopyOnWriteArrayListArrayList 是线程不安全的,在高并发情况下可能会出现问题, Vector 是线程安全的
但是在很多应用场景中，读操作可能会远远大于写操作。由于读操作根本不会修 改原有的数据，因此如果每次读取都进行加锁操作，其实是一种资源浪费。我们 应该允许多个线程同时访问 List 的内部数据，毕竟读操作是线程安全的。
JDK 中提供了 CopyOnWriteArrayList 类，将读取的性能发挥到极致，取是完 全不用加锁的，并且更厉害的是：写入也不会阻塞读取操作，只有写入和写入之 间需要进行同步等待，读操作的性能得到大幅度提升。
ArrayList:
import java.util.ArrayList;
import java.util.Random;
public class ArrayListDemo {
public static void main(String[] args) {
ArrayList list = new ArrayList();
for (int i = 0; i < 20; i++) {
new Thread(
() -> {
list.add(new Random().nextInt());
System.out.println(list);
}
).start();
}
}
}
运行会报错; 并发情况下不能使用ArrayList;不能同时有两个线程对其操作
Vector:
import java.util.Random;
import java.util.Vector;
public class VectorDemo {
public static void main(String[] args) {
Vector vector = new Vector();
for (int i = 0; i < 20; i++) {
new Thread(
() -> {
vector.add(new Random().nextInt());
System.out.println(vector);
}
).start();
}
}
}
运行结果没有报错.
CopyOnWriteArrayList
import java.util.Random;
import java.util.concurrent.CopyOnWriteArrayList;
public class CopyOnWriteArrayListDemo {
public static void main(String[] args) {
CopyOnWriteArrayList list = new CopyOnWriteArrayList();
for (int i = 0; i < 20; i++) {
new Thread(
() -> {
list.add(new Random().nextInt());
System.out.println(list);
}
).start();
}
}
}
运行也是没有问题的.
CopyOnWriteArrayList 类的所有可变操作（add，set 等等）都是通过创建底层数组的新副本来实现的。当 List 需要被修改的时候，并不直接修改原有数组 对象，而是对原有数据进行一次拷贝，将修改的内容写入副本中。写完之后，再将修改完的副本替换成原来的数据，这样就可以保证写操作不会影响读操作了。
public boolean add(E e) {
final ReentrantLock lock = this.lock;
lock.lock();
try {
Object[] elements = getArray();
int len = elements.length;
Object[] newElements = Arrays.copyOf(elements, len + 1);
newElements[len] = e;
setArray(newElements);
return true;
} finally {
lock.unlock();
}
}
3.CopyOnWriteArraySet
CopyOnWriteArraySet 的实现基于 CopyOnWriteArrayList,不能存储重复数据.
import java.util.Random;
import java.util.concurrent.CopyOnWriteArraySet;
public class CopyOnWriteArraySetDemo {
public static void main(String[] args) {
CopyOnWriteArraySet set = new CopyOnWriteArraySet();
//模拟多个线程对其操作
for (int i = 0; i < 20; i++) {
new Thread(
() -> {
set.add(new Random().nextInt());
System.out.println(set);
}
).start();
}
}
}
4.辅助类 CountDownLatch
CountDownLatch这个类使一个线程等待其他线程各自执行完毕后再执行。是通过一个计数器来实现的，计数器的初始值是线程的数量。每当一个线程执行完毕后，计数器的值就-1，当计数器的值为 0 时，表示所有线程都执行完毕，然后在闭锁上等待的线程就可以恢复工作了。
import java.util.concurrent.CountDownLatch;
public class CountDownLatchDemo {
public static void main(String[] args) throws InterruptedException {
CountDownLatch downLatch = new CountDownLatch(6);//计数
for (int i = 0; i <6 ; i++) {
new Thread(
()->{
System.out.println(Thread.currentThread().getName());
downLatch.countDown();//计数器减一操作
}
).start();
}
downLatch.await();//关闭计数
System.out.println("main线程执行");
}
}
当我们把CountDownLatch 注释了的话,运行后输出语句不一定最后执行,具有随机性.
但是当我们加上CountDownLatch 后,设置一个大小,这时我们可以保证输出语句最后执行
但是要注意,当我们如果设置的大小比线程数大,则会导致计数器无法减到0;会导致线程阻塞!
5.辅助类 CyclicBarrierCyclicBarrier是一个同步辅助类，让一组线程到达一个屏障时被阻塞，直到最 后一个线程到达屏障时，屏障才会开门
import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;
public class CyclicBarrierDemo {
public static void main(String[] args) {
CyclicBarrier c = new CyclicBarrier(5, ()->{
System.out.println("大家都到齐了 该我执行了");
});
for (int i = 0; i < 5; i++) {
new Thread(
()->{
System.out.println(Thread.currentThread().getName());
try {
c.await();//加一计数器
} catch (InterruptedException e) {
e.printStackTrace();
} catch (BrokenBarrierException e) {
e.printStackTrace();
}
}
).start();
}
}
}
