一、ArrayList、HashSet、HashMap线程不安全
1、ArrayList
public static void main(String[] args) {
// List<String> arrayList = Arrays.asList("1", "2", "3");
List<String> arrayList = new ArrayList<>();
for (int i = 0; i < 30; i++) {
new Thread(() -> {
arrayList.add(UUID.randomUUID().toString().substring(0, 8));
System.out.println(arrayList);
}).start();
}
}
运行后出现报错:java.util.ConcurrentModificationException

1.导致原因
ArrayList是线程不安全的,add方法没有加synchronized关键字,所以add方法是线程不安全的,这时候对list操作,又要写又要读就导致了线程安全问题
2.解决方案
解决方案一:ArrayList的父类是Vector,而Vector是线程安全的。看源码可以得知其add方法是加了锁的,所以是线程安全。虽然他能够保证数据一致性,但是因为只能一个写或者一个读,导致它比较慢,性能差。
public static void main(String[] args) {
List<String> list = new Vector<>();
for (int i = 0; i <= 30; i++) {
new Thread(() -> {
list.add(UUID.randomUUID().toString().substring(0, 8));
System.out.println(list);
}, String.valueOf(i)).start();
}
}
解决方案二:使用Collections工具类,可以将一个线程不安全的ArrayList变成线程安全的。此方案小数据量的时候比较适合,大数据链参考以下方法。
public static void main(String[] args) {
List<String> list = Collections.synchronizedList(new ArrayList<>());
for (int i = 0; i <= 30; i++) {
new Thread(() -> {
list.add(UUID.randomUUID().toString().substring(0, 8));
System.out.println(list);
}, String.valueOf(i)).start();
}
}
解决方案三:可以使用JUC提供的CopyOnWriteArrayList,运用读写分离的思想,既能保证数据的一致性又能高性能。写的时候先进行复制,写的其实是一份新的复印件,原件可以进行集体的读。写完了之后unlock解锁,将新的复印件替换过去。
public static void main(String[] args) {
List<String> list = new CopyOnWriteArrayList<>();
for (int i = 0; i <= 30; i++) {
new Thread(() -> {
list.add(UUID.randomUUID().toString().substring(0, 8));
System.out.println(list);
}, String.valueOf(i)).start();
}
}
查看源码,得知add方法的源码,往一个容器中添加元素的时候,不是直接往当前容器Object[]添加,而是先将当前容器Object[]进行copy,复制出一个新的容器Object[] newElements,然后新的容器Object [] newElements中添加元素,添加元素之后,再将原容器的引用指向新的容器setArray(newElements);这样做的好处是可以对CopyWrite容器进行并发的读,而不需要加锁,因为当前容器不会添加任何元素,所以CopyOnWrite容器也是一种读写分离得思想。
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();
}
}
2、Set
public static void main(String[] args) {
Set<String> set = new HashSet<>();
for (int i = 0; i <= 30; i++) {
new Thread(() -> {
set.add(UUID.randomUUID().toString().substring(0, 8));
System.out.println(set);
}, String.valueOf(i)).start();
}
}
运行后也出现报错:java.util.ConcurrentModificationException
一、解决方案同理:
//方案一:
Set<String> set = Collections.synchronizedSet(new HashSet<>());
//方案二:
Set<String> set = new CopyOnWriteArraySet<>();
二、HashSet的底层
HashSet的底层是HashMap,那为什么HashMap的put方法是两个值,而HashSet是add一个值呢,因为查看HashSet的源码可以得知,add方法实际上就是调用了HashMap的put方法,key就是add进去的值,而value永远都是一个Object类型的常量,也就是说所有HashSet的value都不重要
public HashSet() {
map = new HashMap<>();
}
3、Map
public static void main(String[] args) {
Map<String,String> map = new HashMap<>();
for (int i = 0; i <= 30; i++) {
new Thread(() -> {
map.put(Thread.currentThread().getName(),UUID.randomUUID().toString().substring(0, 8));
System.out.println(map);
}, String.valueOf(i)).start();
}
}
运行后也出现报错:java.util.ConcurrentModificationException

一、解决方案同理:
//方案一:
Map<String,String> map = Collections.synchronizedMap(new HashMap<>());
//方案二:
Map<String,String> map = new ConcurrentHashMap<>();
二、HashMap的底层
数组+链表+红黑树
散列表底层就是一个数组基础上做得完善,散列值通过散列函数,将key值转换成散列值存储在数组中,但是有时候会出现散列冲突的情况,也就是不同的key经过散列函数计算后生成了同一个散列值,这时候如果想要存储在数组中,发现存储空间就已经被占据了,于是采用一种链表法来解决散列冲突的问题,即在数组中存储一个“槽”,每个槽后面跟着一条链表,不同key得到相同的散列值,都存储在这条链表下,当链表长度不断的增长,直到长度到8,这条单向链表就会变成一条红黑树。
二、CountDownLatch
1、目的:五个同学加一个班长,同学们先走,班长最后走锁门
public class CountDownLatchDemo {
public static void main(String[] args) {
for (int i = 0; i < 6; i++) {
new Thread(() -> {
System.out.println(Thread.currentThread().getName() + "离开教室");
}, String.valueOf(i)).start();
}
System.out.println(Thread.currentThread().getName()+"班长关门走人");
}
}

2、解决方法
public class CountDownLatchDemo {
public static void main(String[] args) throws Exception{
CountDownLatch countDownLatch = new CountDownLatch(6);
for (int i = 0; i < 6; i++) {
new Thread(() -> {
System.out.println(Thread.currentThread().getName() + "离开教室");
countDownLatch.countDown();
}, String.valueOf(i)).start();
}
countDownLatch.await();
System.out.println(Thread.currentThread().getName()+"班长关门走人");
}
}

3、原理:
CountDownLatch主要有两个方法,当一个或多个线程用await方法时,这些线程会阻塞。其他线程调用countDown方法会将计数器减一(调用countDown方法的线程不会被阻塞),当计数器变为0时,因await方法阻塞的线程会被唤醒,继续执行。
三、CyclicBarrier
1、目的:收集七颗龙珠,然后才可以召唤神龙
public class CyclicBarrierDemo {
public static void main(String[] args) {
CyclicBarrier cyclicBarrier = new CyclicBarrier(7, () -> {
System.out.println("******召唤神龙");
});
for (int i = 1; i < 8; i++) {
final int tem = i;
new Thread(() -> {
System.out.println(Thread.currentThread().getName() + ":收集到第" + tem + "个龙珠");
try {
cyclicBarrier.await();
} catch (InterruptedException e) {
e.printStackTrace();
} catch (BrokenBarrierException e) {
e.printStackTrace();
}
}, String.valueOf(i)).start();
}
}
}

四、Semaphore
1、目的:三个车位,七个车在抢,每个车停三秒钟
public class SemaphoreDemo {
public static void main(String[] args) {
Semaphore semaphore = new Semaphore(3);
for (int i = 0; i < 7; i++) {
new Thread(() -> {
try {
semaphore.acquire();
System.out.println(Thread.currentThread().getName() + "停车成功");
Thread.sleep(3000);
System.out.println(Thread.currentThread().getName() + "离开了车位");
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
semaphore.release();
}
}, String.valueOf(i)).start();
}
}
}
2、结果

3、原理
在信号量的基础上定义两种操作:
acquire(获取):当一个线程调用acquire操作时,它要么通过成功获取信号量(信号量减1),要么一直等下去,直到有线程释放信号量,或超时。
release(释放):实际上会将信号量的值加一,然后唤醒等待的线程。
信号量主要用于两个目的,一个是用于多个共享资源的互斥作用,另一个是用于并发线程数的控制。如果将信号量设置为1,实际上也就相当于是给方法加synchornized。
五、ReadWriteLock
1、目的:多个线程同时读一个资源没有任何问题,所以为了满足并发量,读取共享资源应该可以同时进行 ,但是,如果有一个线程想去写公共资源,就不应该再有其他线程对他进行读或者写,读和写是否可以同时进行由我们自己来进行控制
读——读能共存
读——写不能共存
写——写不能共存
2、优化前
public class ReadWriteDemo {
public static void main(String[] args) {
MyCatch myCatch = new MyCatch();
for (int i = 0; i < 5; i++) {
final int temInt = i;
new Thread(() -> {
try {
myCatch.put(temInt + "", temInt + "");
} catch (InterruptedException e) {
e.printStackTrace();
}
}, String.valueOf(i)).start();
}
for (int i = 0; i < 5; i++) {
final int temInt = i;
new Thread(() -> {
myCatch.get(temInt + "");
}, String.valueOf(i)).start();
}
}
}
class MyCatch {
HashMap<String, Object> map = new HashMap<>();
// private ReadWriteLock readWriteLock = new ReentrantReadWriteLock();
public void put(String key, Object value) throws InterruptedException {
// readWriteLock.writeLock().lock();
System.out.println(Thread.currentThread().getName() + "写入数据" + key);
map.put(key, value);
Thread.sleep(300);
System.out.println(Thread.currentThread().getName() + "写入完成" + key);
// readWriteLock.writeLock().unlock();
}
public void get(String key) {
System.out.println(Thread.currentThread().getName() + "读取数据");
map.get(key);
System.out.println(Thread.currentThread().getName() + "读取完成");
}
}
运行结果如下所示,在0线程进行写入数据时,还没有写完,1线程就进来写数据了,违背了数据库的ACID,原子性,要么全部成功要么全部失败

3、优化后
将注释掉的部分取消,开始写的时候进行了加锁,写完了之后释放锁,而读的时候则不加锁,运行结果如下

六、BlockingQueue
1、简介:
在多线程领域:所谓阻塞,就是在某些情况下会挂起线程(即阻塞),一旦条件满足,被挂起的线程又会自动唤起,使用BlockingQueue好处是我们不需要关心什么时候需要阻塞线程,什么时候需要唤醒线程,因为这一切BlockingQueue都给办了。在concurrent包发布以前,在多线程环境下,程序员都需要自己去控制这些细节,尤其还要兼顾效率和线程安全,而这会给我们的程序带来不小的复杂度。
2、图解



如上所示,和常用的List,Set一样,Queue也是一个实现Collection的接口,Blocking实现Queue...
3、实现类
(重要)ArrayBlockingQueue:由数组结构组成的有界阻塞队列
(重要)LinkedBlockingQueue:由链表结构组成的有界(但大小默认值为integer.MAX_VALUE)阻塞队列
PriorityBlockingQueue:支持优先级排序的无界阻塞队列
DelayQueue:使用优先级队列实现的延迟无界阻塞队列
(重要)SynchronousQueue:不存储元素的阻塞队列,也即单个元素的队列
LinkedTransferQueue:由链表组成的无界阻塞队列
LinkedBlockingDeque:由链表组成的双向阻塞队列。
4、核心方法

public class BlockQueueDemo {
public static void main(String[] args) {
//====================第一组=====================
BlockingQueue<String> blockingQueue = new ArrayBlockingQueue<>(3);
System.out.println("add:" + blockingQueue.add("a"));//true
System.out.println("add:" + blockingQueue.add("b"));//true
System.out.println("add:" + blockingQueue.add("c"));//true
//Exception in thread "main" java.lang.IllegalStateException: Queue full
// System.out.println(blockingQueue.add("d"));//加了以上报错
System.out.println("remove:" + blockingQueue.remove());
System.out.println("remove:" + blockingQueue.remove());
System.out.println("remove:" + blockingQueue.remove());
//Exception in thread "main" java.util.NoSuchElementException
// System.out.println("remove" + blockingQueue.remove());//加了以上报错
//拿到的是队列中第一个元素,因为阻塞队列中已经没有数据了,所以会报错
//Exception in thread "main" java.util.NoSuchElementException
// System.out.println("element:" + blockingQueue.element());
// System.out.println("element:" + blockingQueue.element());
// System.out.println("element:" + blockingQueue.element());
//====================第二组=====================
BlockingQueue<String> blockingQueue2 = new ArrayBlockingQueue<>(2);
System.out.println("offer:" + blockingQueue2.offer("1"));//true
System.out.println("offer:" + blockingQueue2.offer("2"));//true
System.out.println("offer:" + blockingQueue2.offer("3"));//false
System.out.println("poll:" + blockingQueue2.poll());//1
System.out.println("poll:" + blockingQueue2.poll());//2
System.out.println("poll:" + blockingQueue2.poll());//null
//====================第三组=====================
BlockingQueue<String> blockingQueue3 = new ArrayBlockingQueue<>(2);
try {
blockingQueue3.put("a");
blockingQueue3.put("b");
//运行到这里会一直阻塞,直到put数据或者响应中断推出
// blockingQueue3.put("c");
System.out.println("take:" + blockingQueue3.take());
System.out.println("take:" + blockingQueue3.take());
//当队列为空时,试图从队列里take元素,对列会一直阻塞消费者线程直到队列可用
// System.out.println("take:" + blockingQueue3.take());
} catch (InterruptedException e) {
e.printStackTrace();
}
//====================第四组=====================
BlockingQueue<String> blockingQueue4 = new ArrayBlockingQueue<>(2);
try {
blockingQueue4.offer("a", 1, TimeUnit.SECONDS);
blockingQueue4.offer("b", 1, TimeUnit.SECONDS);
//阻塞队列实际已满,队列会阻塞1s后退出此线程
blockingQueue4.offer("c", 3, TimeUnit.SECONDS);
System.out.println("poll:" + blockingQueue4.poll(1, TimeUnit.SECONDS));
System.out.println("poll:" + blockingQueue4.poll(1, TimeUnit.SECONDS));
//阻塞队列实际为空,队列会阻塞1s后退出此线程
System.out.println("poll:" + blockingQueue4.poll(3, TimeUnit.SECONDS));
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
网友评论