概述
juc主要是为了解决线程并发问题来引入的,在JDK1.5中就已经有了。
参考资料
尚硅谷周阳的juc
尚硅谷李贺飞的juc
前置知识复习
什么是进程?什么是线程?举例说明。
日常开发中有过哪些对于进程和线程的配置?
多线程的状态有哪些?
什么是并发?什么是并行?举例说明。
wait和sleep的区别是什么?
如何实现一个线程?
tips:编程思路上、lambda表达式
对常用开发工具的一些配置如何实现的?
学习目标
lambda表达式可以用来做什么,它的使用条件是什么?
lambda表达式的使用步骤是怎样的?
Lock和Condition对于synchronized和obj.wait()、obj.notify()的映射?用这两种方法都去实现一下基本的生产者和消费者模式。
obj.wait()的虚假唤醒问题?
Lock的效率为什么比synchronized好?
juc的整个框架体系是怎样的?
说一下CountDownLatch和CyclicBarrier的作用?他俩有何异同点?并举例说明。
说一下SemaphoreDemo的作用?并举例说明。
说一下CopyOnWriteArrayList、CopyOnWriteArraySet、CocurrentHashMap的优点和它们底层实现原理,最好对比ArrayList、HashSet、HashMap来说明?
HashSet的底层实现是什么?为什么HashMap一次存键和值,而HashSet就是一次存键呢?
知道内存可见性问题吗?
举一个例子说明volatile存在的意义?
volatile和synchronized的区别是什么?
A:volatile不满足互斥性和原子性。
知道原子性问题吗?说一下。
volatile满足原子性吗?请举例说明。
说一下cas算法的大概过程?
volatile关键字和内存可见性
public class VolatileDemo {
public static void main(String[] args) {
MyThread myThread=new MyThread();
Thread thread=new Thread(myThread);
thread.start();
while (true){
if(myThread.isFlag()){//为什么flag明明变成true了,还是无法检测到呢?
System.out.println("flag这时候的值是true");//不会打印
break;
}
}
}
}
class MyThread implements Runnable{
private boolean flag=false;
//这个方法休眠200ms后将flag由false变成true
@Override
public void run() {
try {
Thread.sleep(200);
} catch (InterruptedException e) {
e.printStackTrace();
}
flag=true;
System.out.println("flag的值变成了:"+flag);//将会打印说明变成了true
}
public boolean isFlag() {//其实叫getFlag()也行
return flag;
}
}
flag的值变成了:true
原因分析:myThread读取线程缓存flag=false,修改为flag=true.写回到主内存中去。
Main通过isFlag读取flag=false是比较早的。之后陷入死循环就是因为读取共享数据flag时总是可以在主线程缓存自己里找到,就不会想要去到主内存里去去查实时的数据。效率虽高然而可能有错。
解决方案:
(1)加volatile
private boolean flag=false;
(2)加synchronized
while (true){
synchronized (VolatileDemo.class){
if(myThread.isFlag()){//为什么flag明明变成true了,还是无法检测到呢?
System.out.println("flag这时候的值是true");//不会打印
break;
}
}
}
方案对比:加volatile更好一点,毕竟轻量,算是一种乐观锁的实现方式,比悲观锁好多了!
原子变量和CAS算法
原子性问题的引入
int i=10;
i=i++;//结果是多少?10
解释
int i=10;
int temp=i;
i=i+1;
i=temp;
基于i++的多步操作的原子性依旧无法解决
public class AtomicDemo {
public static void main(String[] args) {
AtomicThread atomicThread=new AtomicThread();
for(int i=0;i<10;i++){
new Thread(atomicThread).start();
}
}
}
class AtomicThread implements Runnable{
private volatile int serialNumber=0;
@Override
public void run() {
try {
Thread.sleep(200);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"的serialNumber is:"+getSerialNumber());
}
public int getSerialNumber() {
return serialNumber++;
}
}
Thread-2的serialNumber is:1
Thread-1的serialNumber is:4
Thread-6的serialNumber is:3
Thread-5的serialNumber is:5
Thread-0的serialNumber is:2
Thread-3的serialNumber is:1
Thread-4的serialNumber is:0
Thread-7的serialNumber is:6
Thread-9的serialNumber is:8
Thread-8的serialNumber is:7
原因分析:同时出现两次1的原因是两个线程同时读取到serialNumber的值为1然后又去加1,这两次加法的结果最终是2,读写操作不满足原子性,这就遗漏了一次期望中的加法。
解决方案:原子变量------JDK1.5后java.util.concurrent.atomic包下提供了常用的原子变量。
内部原理:
(1)volatile保证内存存可见性;
(2)CAS(Compare And Swap)算法保证数据的原子性。------CAS算法是硬件对于并发操作共享数据的支持。
boolean compareAndSet(int expect, int update)
CAS包含了三个操作数:内存值V(实际值);预估旧值A;更新值B.
当且仅当V==A时,V=B.否则不做任何操作(失败了可以立即重试,效率还是令人满意的)。好像MVCC呀,思想都是一样的。
// private volatile int serialNumber=0;
private AtomicInteger serialNumber=new AtomicInteger(0);
// public int getSerialNumber() {
// return serialNumber++;
// }
public int getSerialNumber() {
return serialNumber.getAndIncrement();
}
Thread-0的serialNumber is:0
Thread-1的serialNumber is:1
Thread-2的serialNumber is:2
Thread-6的serialNumber is:3
Thread-9的serialNumber is:7
Thread-3的serialNumber is:6
Thread-8的serialNumber is:5
Thread-7的serialNumber is:4
Thread-5的serialNumber is:9
Thread-4的serialNumber is:8
上面结果说明问题得到了解决!
同步容器类java.util.concurrent.collections
https://blog.csdn.net/qq_40261771/article/details/88823736
这是一个梗概。
ConcurrentHashMap
CopyOnWriteArrayList
https://www.cnblogs.com/simple-focus/p/7439919.html
https://www.cnblogs.com/Java3y/p/9920784.html
CopyOnWriteArraySet
ConcurrentSkipListMap
ConcurrentSkipListSet