文章目录

查看锁的信息
- 饥饿死锁的例子
Synchronized 其原理是什么？
你刚才提到获取对象的锁，这个“ 锁 ”到底是什么？如何确定对象的锁
什么是可重入性，为什么说 Synchronized 是可重入锁？
为什么说 Synchronized 是一个悲观锁？乐观锁的实现原理又是什么？什么是 CAS，它有什么特性？
乐观锁一定就是好的吗？
跟 Synchronized 相比，可重入锁 ReentrantLock 其实现原理有什么不同？
- AQS框架是怎么回事儿？
- synchronized实例

查看锁的信息

jvisualvm
查看pid

死锁代码：


public class sisuoDemo4 {public static void main(String[] args) {Obj1 obj1 = new Obj1();Obj2 obj2 = new Obj2();Thread thread1 = new Thread(new SynAddRunalbe(obj1,obj2,1,2,true));Thread thread2 = new Thread(new SynAddRunalbe(obj1,obj2,2,1,false));thread1.setName("1");thread2.setName("线程2");thread1.start();thread2.start();}public static class SynAddRunalbe implements Runnable {Obj1 obj1;Obj2 obj2;int a,b;boolean flag;public SynAddRunalbe(Obj1 obj1, Obj2 obj2, int a, int b, boolean flag) {this.obj1 = obj1;this.obj2 = obj2;this.a = a;this.b = b;this.flag = flag;}@Overridepublic void run() {if(flag){synchronized (obj1){try {Thread.sleep(5);synchronized (obj2){System.out.println(a+b);System.out.println(Thread.currentThread().getName());}} catch (InterruptedException e) {e.printStackTrace();}}}else{synchronized (obj2)
{try{Thread.sleep(5);synchronized (obj1){System.out.println(a+b);System.out.println(Thread.currentThread().getName());}} catch (InterruptedException e) {e.printStackTrace();}
}}}}public static class Obj1 {}public static class Obj2 {}
}

C:\hello>jstack -l 20488

饥饿死锁的例子

public class ExecutorLock {private static ExecutorService single = Executors.newSingleThreadExecutor();
public static class AnotherCallable implements Callable<String> {@Override
public String call() throws Exception {System.out.println("in AnotherCallable");
return "annother success";
}
}public static class MyCallable implements Callable<String> {@Override
public String call() throws Exception {System.out.println("in MyCallable");
Future<String> submit = single.submit(new AnotherCallable());
return "success:" + submit.get();
}
}
public static void main(String[] args) throws ExecutionException,
InterruptedException {MyCallable task = new MyCallable();
Future<String> submit = single.submit(task);
System.out.println(submit.get());
System.out.println("over");
single.shutdown();
}
}

Synchronized 其原理是什么？

Synchronized 是由 JVM 实现的一种实现互斥同步的一种方式，如果你查看被 Synchronized 修饰过的程序块编译后的字节码，会发现，被Synchronized 修饰过的程序块，在编译前后被编译器生成了 monitorenter 和 monitorexit 两个字节码指令。
这两个指令是什么意思呢？
在虚拟机执行到 monitorenter 指令时，首先要尝试获取对象的锁：
如果这个对象没有锁定，或者当前线程已经拥有了这个对象的锁，把锁的计数器 +1；当执行 monitorexit 指令时将锁计数器 -1；当计数器为 0 时，锁就被释放了。
如果获取对象失败了，那当前线程就要阻塞等待，直到对象锁被另外一个线程释放为止。
Java 中 Synchronize 通过在对象头设置标记，达到了获取锁和释放锁的目的。

你刚才提到获取对象的锁，这个“ 锁 ”到底是什么？如何确定对象的锁

“ 锁 ” 的本质其实是 monitorenter 和 monitorexit 字节码指令的一个
Reference 类型的参数，即要锁定和解锁的对象。我们知道，使用Synchronized 可以修饰不同的对象，因此，对应的对象锁可以这么确定。

如果 Synchronized 明确指定了锁对象，比如 Synchronized（变量名）、Synchronized(this) 等，说明加解锁对象为该对象。
如果没有明确指定：
若 Synchronized 修饰的方法为非静态方法，表示此方法对应的对象为锁对象；
若 Synchronized 修饰的方法为静态方法，则表示此方法对应的类对象为锁对象。
注意，当一个对象被锁住时，对象里面有用Synchronized 修饰的方法都将产生堵塞，而对象里非 Synchronized 修饰的方法可正常被调用，不受锁影响。

什么是可重入性，为什么说 Synchronized 是可重入锁？

可重入性是锁的一个基本要求，是为了解决自己锁死自己的情况。

比如一个类中的同步方法调用另一个同步方法，假如
Synchronized 不支持重入，进入 method2 方法时当前线程获得锁，method2 方法里面执行 method1 时当前线程又要去尝试获取锁，这时如果不支持重入，它就要等释放，把自己阻塞，导致自己锁死自己。

为什么说 Synchronized 是一个悲观锁？乐观锁的实现原理又是什么？什么是 CAS，它有什么特性？

Synchronized 显然是一个悲观锁，因为它的并发策略是悲观的：
不管是否会产生竞争，任何的数据操作都必须要加锁、用户态核心态转换、维护锁计数器和检查是否有被阻塞的线程需要被唤醒等操作。
随着硬件指令集的发展，我们可以使用基于冲突检测的乐观并发策略。先进行操作，如果没有其他线程征用数据，那操作就成功了；如果共享数据有征用，产生了冲突，那就再进行其他的补偿措施。这种乐观的并发策略的许多实现不需要线程挂起，所以被称为非阻塞同步。
乐观锁的核心算法是 CAS（ Compareand Swap，比较并交换），它涉及到三个操作数：内存值、预期值、新值。当且仅当预期值和内存值相等时才将内存值改为新值，这样处理的逻辑是，首先检查某块内存的值是否跟之前我读取时的一样，如不一样则表示期间此内存值已经被别的线程更改过，舍弃本次操作，否
则说明期间没有其他线程对此内存值操作，可以把新值设置给此块内存。
CAS 具有原子性，它的原子性由 CPU 硬件指令实现保证，即使用 JNI 调用 Native 方法调用由 C++ 编写的硬件级别指令， JDK 中提供了Unsafe 类执行这些操作。

乐观锁一定就是好的吗？

乐观锁避免了悲观锁独占对象的现象，同时也提高了并发性能，但它也有缺点：

乐观锁只能保证一个共享变量的原子操作。如果多一个或几个变量，乐观锁将变得力不从心，但互斥锁能轻易解决，不管对象数量多少及对象颗粒度大小。
长时间自旋可能导致开销大。假如 CAS 长时间不成功而一直自旋，会给 CPU 带来很大的开销。
ABA 问题。CAS 的核心思想是通过比对内存值与预期值是否一样而判断内存值是否被改过，但这个判断逻辑不严谨，假如内存值原来是 A，后来被一条线程改为 B，最后又被改成了 A，则 CAS 认为此内存值并没有发生改变，但实际上是有被其他线程改过的，这种情况对依赖过程值的情景的运算结果影响很大。解决的思路是引入版本号，每次变量更新都把版本号加一。

可重入锁 ReentrantLock 及其他显式锁相关问题

跟 Synchronized 相比，可重入锁 ReentrantLock 其实现原理有什么不同？

其实，锁的实现原理基本是为了达到一个目的：
让所有的线程都能看到某种标记。
Synchronized 通过在对象头中设置标记实现了这一目的，是一种 JVM
原生的锁实现方式，而 ReentrantLock 以及所有的基于 Lock 接口的实现类，都是通过用一个 volitile 修饰的 int 型变量，并保证每个线程都能拥有对该 int 的可见性和原子修改，其本质是基于所谓的 AQS 框架。

AQS框架是怎么回事儿？

AQS（ AbstractQueuedSynchronizer 类）是一个用来构建锁和同步器的框架，各种Lock 包中的锁（常用的有ReentrantLock 、ReadWriteLock），以及其他如 Semaphore、 CountDownLatch，甚至是早期的 FutureTask 等，都是基于 AQS 来构建。
5. AQS 在内部定义了一个 volatile int state 变量，表示同步状态：当线程调用 lock 方法时，如果 state=0，说明没有任何线程占有共享资源的锁，可以获得锁并将 state=1；如果 state=1，则说明有线程目前正在使用共享变量，其他线程必须加入同步队列进行等待。
6. AQS 通过 Node 内部类构成的一个双向链表结构的同步队列，来完成线程获取锁的排队工作，当有线程获取锁失败后，就被添加到队列末尾。
Node 类是对要访问同步代码的线程的封装，包含了线程本身及其状态叫waitStatus（有五种不同取值，分别表示是否被阻塞，是否等待唤醒，是否已经被取消等），每个 Node 结点关联其 prev 结点和 next 结点，方便线程释放锁后快速唤醒下一个在等待的线程，是一个 FIFO 的过程。
Node 类有两个常量， SHARED 和 EXCLUSIVE，分别代表共享模式和独占模式。所谓共享模式是一个锁允许多条线程同时操作（信号量Semaphore 就是基于 AQS 的共享模式实现的），独占模式是同一个时间段只能有一个线程对共享资源进行操作，多余的请求线程需要排队等待（如 ReentranLock）。
7. AQS 通过内部类 ConditionObject 构建等待队列（可有多个），当Condition 调用 wait() 方法后，线程将会加入等待队列中，而当Condition 调用 signal() 方法后，线程将从等待队列转移动同步队列中进行锁竞争。

synchronized实例

1.synchronized:内置的Java关键字
LOCK:一个接口，下面有多个实现类，可以判断是否取得了锁
2.synchronized自动释放锁，lock必须手动释放锁
3.synchronized不可以中断，非公平锁，lock 可以设置公平还是非公平
前者适合锁少量代码同步问题，后者适合锁大量同步代码
一个用synchronized的例子1：


public class A {public static void main(String[] args) {Threadtest threadtest = new Threadtest();new Thread(()->{for(int i = 0;i < 5;i++){try{threadtest.increment();}catch (InterruptedException e){e.printStackTrace();}}},"A").start();new Thread(()->{for(int i = 0;i < 5;i++){try{threadtest.decrement();}catch (InterruptedException e){e.printStackTrace();}}},"B").start();}
}


public class Threadtest
{private int number = 0;Lock lock = new ReentrantLock();public synchronized void increment()throws InterruptedException{// lock.lock();try{//自己的业务代码if(number !=0)this.wait();number++;System.out.println(Thread.currentThread().getName()+"->"+number);this.notify();}catch (Exception e){e.printStackTrace();}}public synchronized void decrement()throws InterruptedException{try{if(number == 0)this.wait();number--;System.out.println(Thread.currentThread().getName()+"->"+number);this.notify();}catch (Exception e){e.printStackTrace();}}
}

1this.notify()去掉this对结果无影响
以上例子如果再加一个线程C，改成notifyAll()会出现问题：
A->1
B->0
A->1
B->0
C->1
A->2
C->3
B->2
B->1
B->0
C->1
A->2

发现输出不正确了，是因为/if和while的虚假唤醒问题，改if为while
增加CD两个线程：


public class A {public static void main(String[] args) {Threadtest threadtest = new Threadtest();new Thread(()->{for(int i = 0;i < 5;i++){try{threadtest.increment();}catch (InterruptedException e){e.printStackTrace();}}},"A").start();new Thread(()->{for(int i = 0;i < 5;i++){try{threadtest.decrement();}catch (InterruptedException e){e.printStackTrace();}}},"B").start();new Thread(()->{for(int i = 0;i < 5;i++){try{threadtest.increment();}catch (InterruptedException e){e.printStackTrace();}}},"C").start();new Thread(()->{for(int i = 0;i < 5;i++){try{threadtest.decrement();}catch (InterruptedException e){e.printStackTrace();}}},"D").start();}
}


public class Threadtest
{private int number = 0;Lock lock = new ReentrantLock();public synchronized void increment()throws InterruptedException{// lock.lock();try{//自己的业务代码while(number !=0)this.wait();number++;System.out.println(Thread.currentThread().getName()+"->"+number);notifyAll();}catch (Exception e){e.printStackTrace();}}public synchronized void decrement()throws InterruptedException{try{while (number == 0)this.wait();number--;System.out.println(Thread.currentThread().getName()+"->"+number);notifyAll();}catch (Exception e){e.printStackTrace();}}
}

输出
A->1
B->0
A->1
B->0
A->1
B->0
A->1
B->0
A->1
B->0
C->1
D->0
C->1
D->0
C->1
D->0
C->1
D->0
C->1
D->0

五个为一轮

例子2：

public class Test {public static void main(String[] args) {Sell sell = new Sell();new Thread(() -> {sell.sell1();},"A").start();new Thread(() -> {sell.sell2();},"B").start();
}
}
class Sell{public synchronized void sell1(){System.out.println("卖衣服");}public synchronized void sell2(){System.out.println("卖包子");}
}

输出卖衣服
卖包子
如果sell2和sell1改一下顺序，则输出变成卖包子卖衣服
说明：sychronized锁的对象是方法的调用者，由于上面两个方法用的是同一个锁，因此谁先拿到锁先执行谁
加了sleep方法：

public class Test {public static void main(String[] args) {Sell sell = new Sell();Sell mm = new Sell();new Thread(() -> {try {sell.sell2();} catch (InterruptedException e) {e.printStackTrace();}mm.sell1();},"A").start();new Thread(() -> {mm.sell1();try {mm.sell2();} catch (InterruptedException e) {e.printStackTrace();}},"B").start();
}
}
class Sell{public synchronized void sell1(){System.out.println("卖衣服"+Thread.currentThread().getName());}public synchronized void sell2() throws InterruptedException {Thread.sleep(2);System.out.println("卖包子"+Thread.currentThread().getName());}
}

卖衣服B
卖包子A
卖包子B
卖衣服A
记住：非同步方法不受锁的影响
如果sychronized修饰的方法是static的，则锁的是整个class,此时即使即使new了不同的两个实例，仍然是同一把锁

【学习笔记】juc并发学习+关于锁的面试题相关推荐

JAVA学习笔记 -- JUC并发编程
1 进程.线程进程就是用来加载指令.管理内存.管理IO.当一个程序被运行,从磁盘加载这个程序的代码至内存,这时就开启了一个进程.进程可以被视为程序的一个实例. 线程,一个线程就是一个指令流,将指令流 ...
多线程编程学习笔记——使用并发集合（三）
接上文多线程编程学习笔记--使用并发集合(一) 接上文多线程编程学习笔记--使用并发集合(二) 四. 使用ConcurrentBag创建一个可扩展的爬虫本示例在多个独立的即可生产任务又可消费 ...
Java学习笔记---多线程并发
Java学习笔记---多线程并发 (一)认识线程和进程 (二)java中实现多线程的三种手段 [1]在java中实现多线程操作有三种手段: [2]为什么更推荐使用Runnable接口? [3][补充知 ...
tornado学习笔记day01-高并发性能web框架
tornado的安装这里我使用的是虚拟环境中的pip安装,配合清华大学镜像源安装的 pip install tornado -i https://pypi.tuna.tsinghua.edu.cn/ ...
学习笔记-Java并发(一)
学习笔记-Java并发(一) 目录学习笔记-Java并发一目录 Executer Callable和Future 后台线程线程加入小计今天看了这一篇 Java编程思想-java中的并发(一) ...
深度学习入门之PyTorch学习笔记：深度学习介绍
深度学习入门之PyTorch学习笔记:深度学习介绍绪论 1 深度学习介绍 1.1 人工智能 1.2 数据挖掘.机器学习.深度学习 1.2.1 数据挖掘 1.2.2 机器学习 1.2.3 深度学习第 ...
学习笔记：CentOS7学习之二十二：结构化命令case和for、while循环
目录学习笔记:CentOS7学习之二十二: 结构化命令case和for.while循环 22.1 流程控制语句:case 22.2 循环语句 22.1.2 for-do-done 22.3 whil ...
学习笔记：CentOS7学习之十六：LVM管理和ssm存储管理器使用
目录学习笔记:CentOS7学习之十六:LVM管理和ssm存储管理器使用 16.1 LVM的工作原理 16.1.1 LVM常用术语 16.1.2 LVM优点 16.2 创建LVM的基本步骤 16.2 ...
学习笔记：强化学习与最优控制（Chapter 2）
Approximation in Value Space 学习笔记:强化学习与最优控制(Chapter 2) Approximation in Value Space 1. 综述 2. 基于Value ...
【长篇博文】Docker学习笔记与深度学习环境的搭建和部署（二）
长篇博文记录学习流程不容易,请关注.转发.点赞.评论,谢谢! 上一篇文章:Docker学习笔记与深度学习环境的搭建和部署(一) 文章末尾附加nvidia455.23.cuda11.1.cudnn8.0 ...

【学习笔记】juc并发学习+关于锁的面试题

文章目录

查看锁的信息

饥饿死锁的例子

Synchronized 其原理是什么？

你刚才提到获取对象的锁，这个“ 锁 ”到底是什么？如何确定对象的锁

什么是可重入性，为什么说 Synchronized 是可重入锁？

为什么说 Synchronized 是一个悲观锁？乐观锁的实现原理又是什么？什么是 CAS，它有什么特性？

乐观锁一定就是好的吗？

跟 Synchronized 相比，可重入锁 ReentrantLock 其实现原理有什么不同？

AQS框架是怎么回事儿？

synchronized实例

【学习笔记】juc并发学习+关于锁的面试题相关推荐

最新文章

热门文章

【学习笔记】juc并发学习+关于锁的面试题

文章目录

查看锁的信息

饥饿死锁的例子

Synchronized 其 原 理 是 什 么 ？

你 刚 才 提 到 获 取 对 象 的 锁 ，这 个“ 锁 ”到 底 是 什 么 ？ 如 何 确 定 对象的锁

什 么 是 可 重 入 性 ， 为 什 么 说 Synchronized 是 可 重 入 锁 ？

为 什 么 说 Synchronized 是 一 个 悲 观 锁 ？ 乐 观 锁 的 实 现 原 理 又 是 什 么 ？ 什 么 是 CAS， 它 有 什 么 特 性 ？

乐 观 锁 一 定 就 是 好 的 吗 ？

跟 Synchronized 相 比 ， 可 重 入 锁 ReentrantLock 其实现原理 有 什 么 不 同 ？

AQS框 架 是 怎 么 回 事 儿 ？

synchronized实例

【学习笔记】juc并发学习+关于锁的面试题相关推荐

最新文章

热门文章

Synchronized 其原理是什么？

你刚才提到获取对象的锁，这个“ 锁 ”到底是什么？如何确定对象的锁

什么是可重入性，为什么说 Synchronized 是可重入锁？

为什么说 Synchronized 是一个悲观锁？乐观锁的实现原理又是什么？什么是 CAS，它有什么特性？

乐观锁一定就是好的吗？

跟 Synchronized 相比，可重入锁 ReentrantLock 其实现原理有什么不同？

AQS框架是怎么回事儿？