ArrayList是线程不安全，请编码写一个不安全的案例并给出解决方案！
import java.util.*;
import java.util.concurrent.CopyOnWriteArrayList;
/**
* 集合类不安全的问题
*/
import java.util.*;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.concurrent.CopyOnWriteArraySet;
/**
* 集合类不安全的问题
*/
public class ContainerNotSafeDemo {
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();
}
}
private static void setNotSafe() {
// Set<String> set = Collections.synchronizedSet(new HashSet<>());
Set<String> set = new CopyOnWriteArraySet<>();
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();
}
}
private static void listNotSafe() {
// List<String> list = new ArrayList<>();
// List<String> list = new Vector<>();
// List<String> list = Collections.synchronizedList(new ArrayList<>());
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();
}
}
}
故障现象
java.util.ConcurrentModificationException导致原因
并发争抢修改导致【入场签名】
一方正在写入，另一方过来干扰，导致数据不一致异常。
解决方案
1、new Vector<>()
2、Collections.synchronizedList(new ArrayList<>());
3、写时复制
Copyonwrite容器即写时复制的容器。往一个容器添加元素的时候，不直接往当前容器object[]添加，而是先将当前容器object[]进行copy，复制出一个新的容器object[] newElements，然后新的容器object[] newElements里添加元素，添加完元素之后,再将原容器的引用指向新的容器 setArray(newElements);这样做的好处是可以Copyonwrite容器进行并发的读而不需要加锁，因为当前容器不会添加任何元素。所以Copyonwrite容器也是一种读写分离的思想，读和写不同的容器
/**
* Appends the specified element to the end of this list.
*
* @param e element to be appended to this list
* @return {@code true} (as specified by {@link Collection#add})
*/
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();
}
}
//栈管运行，堆管存储
公平锁/非公平锁/可重入锁/递归锁/自旋锁谈谈你的理解？请手写一个自旋锁
【公平锁】指多个线程按照申请锁的顺序来获取锁，类似排队打饭，先来后到；
【非公平锁】指多个线程获取锁的顺序并不是按照申请锁的顺序，有可能后申请的线程比先申请的线程优先获取锁
在高并发的情况下，有可能会造成优先级反转或者饥饿现象
公平锁 / 非公平锁【两者的区别】
并发包中ReentrantLock的创建可以指定构造函数的boolean类型来得到公平锁或非公平锁，默认是非公平锁
关于两者区别:
公平锁:Threads acquire a fair lock in the order in which they requested it。公平锁，就是很公平，在并发环境中，每个线程在获取锁时会先查看此锁维护的等待队列，如果为空，或者当前线程是等待队列的第一个，就占有锁，否则就会加入到等待队列中，以后会按照FIFO的规则从队列中取到自己
非公平锁: a nonfair lock permits barging: threads requesting a lock can jump ahead of the queue of waiting threads if the lock happens to be available when it is requested.
非公平锁比较粗鲁，上来就直接尝试占有锁，如果尝试失败，就再采用类似公平锁那种方式。
【非公平锁的优点在于吞吐量比公平锁大】
可重入锁【也叫递归锁】
指的是同一线程外层函数获得锁之后 ，内层递归函数仍然能获取该锁的代码,在同一个线程在外层方法获取锁的时候，在进入内层方法会自动获取锁。
即是说，线程可以进入任何一个它已经拥有的锁所同步着的代码块。
ReentrantLock/Synchronized就是一个典型的可重入锁【典型】
可重入锁最大的作用是避免死锁【作用】
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
/**
* @author smartaotao
* 可重入锁
* 指的是同一线程外层函数获得锁之后 ，内层递归函数仍然能获取该锁的代码,
* 在同一个线程在外层方法获取锁的时候，在进入内层方法会自动获取锁。
*/
public class ReenterLockDemo {
public static void main(String[] args) {
Phone phone = new Phone();
new Thread(() -> {
try {
phone.sendSMS();
} catch (Exception e) {
e.printStackTrace();
}
}, "t1").start();
new Thread(() -> {
try {
phone.sendSMS();
} catch (Exception e) {
e.printStackTrace();
}
}, "t2").start();
System.out.println("------------------------------------------");
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
Thread t3 = new Thread(phone, "t3");
Thread t4 = new Thread(phone, "t4");
t3.start();
t4.start();
}
}
class Phone implements Runnable{
public synchronized void sendSMS() throws Exception{
System.out.println(Thread.currentThread().getName() + "\t invoked sendSMS()");
sendEmail();
}
public synchronized void sendEmail() throws Exception{
System.out.println(Thread.currentThread().getName() + "\t ### invoked sendEmail() ###");
}
/******************************************************************************************/
Lock lock = new ReentrantLock();
@Override
public void run() {
get();
}
public void get(){
lock.lock();
try {
System.out.println(Thread.currentThread().getName() + "\t invoked get()");
set();
}finally {
lock.unlock();
}
}
public void set(){
lock.lock();
try {
System.out.println(Thread.currentThread().getName() + "\t invoked set()");
}finally {
lock.unlock();
}
}
}
自旋锁
【自旋锁(spinlock)】
是指尝试获取锁的线程不会立即阻塞，而是采用循坏的方式去尝试获取锁，这样的好处是减少线程上下文切换的消耗，缺
点是循环会消耗CPU
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicReference;
/**
* @author smartaotao
* 实现一个自旋锁
* 自旋锁好处: 循环比较获取直到成功为止，没有类似wat的阻塞
* 通过CAs操作完成自旋锁，A线程先进来调用myLock 方法自已持有锁5秒钟，
* B随后进来后发现当前有线程持有锁，不是null，所以只能通过自旋等待，直到A释放锁后B随后抢到。
*/
public class SpinLockDemo {
// 原子引用线程
AtomicReference<Thread> atomicReference = new AtomicReference<>();
public void myLock(){
Thread thread = Thread.currentThread();
System.out.println(Thread.currentThread().getName() + "\t come in hhh");
while (atomicReference.compareAndSet(null, thread)){
}
}
public void myUnlock(){
Thread thread = Thread.currentThread();
atomicReference.compareAndSet(thread, null);
System.out.println(Thread.currentThread().getName() + "\t invoked myUnlock");
}
public static void main(String[] args) {
SpinLockDemo spinLockDemo = new SpinLockDemo();
new Thread(() -> {
spinLockDemo.myLock();
// 暂停一会线程
try {
TimeUnit.SECONDS.sleep(5);
}catch (InterruptedException e){
e.printStackTrace();
}
spinLockDemo.myUnlock();
}, "T1").start();
try {
TimeUnit.SECONDS.sleep(1);
}catch (InterruptedException e){
e.printStackTrace();
}
new Thread(() -> {
spinLockDemo.myLock();
try {
TimeUnit.SECONDS.sleep(1);
}catch (InterruptedException e){
e.printStackTrace();
}
spinLockDemo.myUnlock();
}, "T2").start();
}
}
独占锁(写锁)/共享锁(读锁)/互斥锁
【独占锁】:指该锁一次只能被一个线程所持有。对ReentrantLock和Synchronized而言都是独占锁
【共享锁】: 指该锁可被多个线程所持有。
对ReentrantReadWriteLock其读锁是共享锁，其写锁是独占锁。
读锁的共享锁可保证并发读是非常高效的，读写，写读 ，写写的过程是互斥的。
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.ReentrantReadWriteLock;
/**
* @author smartaotao
* 多个线程同时读一个贷源类没有任何问题，所以为了满足并发量，读取共享资源应该可以同时进行。
* 但是如果有一个线程想去写共享资源来，就不应该再有其它线程可以对该资源进行读或写
* 小总结:
* 读- 读能共存
* 读- 写不能共存
* 号 写不能共存
*/
public class ReadWriteLockDemo {
public static void main(String[] args) {
MyCache myCache = new MyCache();
for (int i = 0; i < 5; i++) {
final int tmp = i;
new Thread(() -> {
myCache.put(tmp + "", tmp + "");
}, String.valueOf(i)).start();
}
for (int i = 0; i < 5; i++) {
final int tmp = i;
new Thread(() -> {
myCache.get(tmp + "");
}, String.valueOf(i)).start();
}
}
}
// 资源类
class MyCache{
private volatile Map<String, Object> map = new HashMap<>();
private ReentrantReadWriteLock readWriteLock = new ReentrantReadWriteLock();
public void put(String key, Object value){
readWriteLock.writeLock().lock();
try {
System.out.println(Thread.currentThread().getName() + "\t 正在写入： " + key);
try {
TimeUnit.MILLISECONDS.sleep(300);
} catch (InterruptedException e) {
e.printStackTrace();
}
map.put(key, value);
System.out.println(Thread.currentThread().getName() + "\t 写入完成： ");
}catch (Exception e){
e.printStackTrace();
}finally {
readWriteLock.writeLock().unlock();
}
// System.out.println(Thread.currentThread().getName() + "\t 正在写入： " + key);
// try {
// TimeUnit.MILLISECONDS.sleep(300);
// } catch (InterruptedException e) {
// e.printStackTrace();
// }
// map.put(key, value);
// System.out.println(Thread.currentThread().getName() + "\t 写入完成： ");
}
// 读可以共享
public void get(String key){
readWriteLock.readLock().lock();
try {
System.out.println(Thread.currentThread().getName() + "\t 正在读取： " + key);
try {
TimeUnit.MILLISECONDS.sleep(300);
} catch (InterruptedException e) {
e.printStackTrace();
}
Object result = map.get(key);
System.out.println(Thread.currentThread().getName() + "\t 读取完成： " + result);
}catch (Exception e){
e.printStackTrace();
}finally {
readWriteLock.readLock().unlock();
}
// System.out.println(Thread.currentThread().getName() + "\t 正在读取： " + key);
// try {
// TimeUnit.MILLISECONDS.sleep(300);
// } catch (InterruptedException e) {
// e.printStackTrace();
// }
// Object result = map.get(key);
// System.out.println(Thread.currentThread().getName() + "\t 读取完成： " + result);
}
}
执行结果：
1 正在写入： 1
1 写入完成：
0 正在写入： 0
0 写入完成：
2 正在写入： 2
2 写入完成：
3 正在写入： 3
3 写入完成：
4 正在写入： 4
4 写入完成：
0 正在读取： 0
1 正在读取： 1
2 正在读取： 2
3 正在读取： 3
4 正在读取： 4
4 读取完成： 4
3 读取完成： 3
2 读取完成： 2
1 读取完成： 1
0 读取完成： 0
203
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
