Java中的锁按等级分可以分为对象锁、方法锁、类锁。
对象锁和方法锁其实是同一个东西
java的对象锁和类锁：java的对象锁和类锁在锁的概念上基本上和内置锁是一致的，但是，
两个锁实际是有很大的区别的，对象锁是用于对象实例方法，或者一个对象实例上的，类
锁是用于类的静态方法或者一个类的class对象上的。我们知道，类的对象实例可以有很
多个，但是每个类只有一个class对象，所以不同对象实例的对象锁是互不干扰的，但是
每个类只有一个类锁。但是有一点必须注意的是，其实类锁只是一个概念上的东西，并
不是真实存在的，它只是用来帮助我们理解锁定实例方法和静态方法的区别的
转载于:https://blog.51cto.com/12222886/2070295
本人第一篇博客，和大家分享一点关于java中的锁级别的问题，（PS：博主原先的名字千林被占用了，所以暂用DeBug
），由于本人知识，能力有限，如果表述中出现错误以及其他问题，请各位看官多多指教。闲话少说，开始正题。
个人认为在JAVA开发中，锁是一个避不开的问题，小到练习性代码，大到企业级开发的，并发编程是程序猿必须走的一步，而在进行并发编程时，如何进行线程间的同步，则一直是各种大牛，菜鸟们想法设法解决的问题，而为了保证线程间的数据同步以及数据可见性，常用的解决方式，便是加锁。
其实在JAVA中，每个对象都可以当成锁来使用，这要从JAVA对象来谈起。首先JAVA对象中有一个叫做‘对象头’的部分，JAVA对象头由Mark Word,Class matedata Address以及Array length三部分组成，而对象头中的Mark Word 则主要负责存储锁信息，当然，Mark Word不仅仅存储锁信息，其中还包括了对象分代信息，对象HashCode等。在存储的锁信息中，主要有三个部分，分别是锁状态，是否是偏向锁（之后会谈到偏向锁），以及锁的标记位。下面和大家分享一下这三个部分的作用。
在JAVA中，锁是有分级的，资源消耗从低到高分别为偏向锁，轻量级锁以及重量级锁。HotSpot的开发者在研究中发现一个很因吹斯汀的现象，就是在大多数情况下，锁的使用并不存在竞争（博主到现在也没明白怎么回事），反而经常被同一个线程得到或者占用，所以为了减少锁释放以及获取的资源消耗，便有了偏向锁。我们刚才讲到在对象头中存储了是否是偏向锁的标记以及锁状态，在偏向锁的使用中，就会用到。首先当某个线程获取到偏向锁后，锁（其实就是对象）就会在对象头中存储获取到自己的线程的线程ID，标识，自己已经被该线程获取到了（大家可以这样理解，你娶了你貌美如花，沉鱼落雁的妻子，然后你妻子就存储了你的标记，是什么呢，就是戒指啊，然后由于你妻子太美了，其他帅哥就会过来勾搭你妻子啊，然后这个标记就起作用了，帅哥们看到你妻子的戒指以后就会知道，她是有老公的人了，当然，这个比喻并不恰当）。之后每次线程来获取锁的时候，就是进行检查，当获取到该锁的线程来重新获取锁的时候，因为锁里面本来就存储了这个线程的ID，所以就会允许使用，但是如果线程B也来获取锁（看吧，老婆太漂亮，有人来竞争了吧
），首先竞争肯定是不成功的，但是线程B这哥们太强势，强制性的要求线程A释放锁，那么线程A在执行完同步体之后，就会释放偏向锁。但是偏向锁的释放需要等待全局安全点，也就是在这个安全点上没有任何程序在执行，那么锁就会将自己对象头中的偏向线程ID设置为空，（你老婆摘下了戒指），然后呢就表示锁已经是没有线程在使用了，然后线程恢复，线程B对释放偏向锁的请求就执行成功了，那么线程B是不是一定能获取锁呢，这是不一定的，只是对释放锁的请求执行成功了就是了（就是线程B要求线程A和他老婆分手，然后线程B就使用了一些阴暗的手段--CAS置换，然后线程A就和锁分手了，至于分手之后锁会被谁获取，是不一定的，说不定仍然会被线程A获取）。
偏向锁之后是轻量级锁。JVM在执行同步块之前，会在线程的栈帧中创建一块空间，专门用来存储所记录，那么存储的内容是什么呢，就是我们上面说到的Mark Word，那么对象原来用来存储Mark Word的空间用来存储什么呢，其实是用来存储指向线程中存储锁记录的指针。所以在轻量级锁获取当中，首先是在线程的栈帧中创建存储Mark Word的记录空间，然后就开始竞争锁，在竞争锁的过程中进行CAS，将对象中原本存储Mark Word的空间，置换为指向记录的指针，如果成功，标识获取成功，如果失败，则自旋（简单理解成死循环），不断的去尝试获取锁。那轻量级锁是怎么释放的呢，首先当线程在使用完锁之后，会尝试将栈帧中锁记录部分的数据置换会对象头中，如果成功，表示释放成功，如果失败。。。。下面是我们要说的锁升级。
首先当线程A获取到轻量锁的时候，线程B同样也来请求锁，但是由于锁已经被线程A获取到了，线程B会首先尝试自旋获取，但是由于自旋会消耗大量的资源，所以在某些情况下会判定自旋失败，那么就会将锁升级为重量级锁，当锁膨胀为重量级锁之后，线程B就会跳出自旋，然后阻塞自己。如果线程A尝试释放锁，就会释放失败，然后锁就知道有线程在竞争锁，就会唤醒阻塞的线程，然后就会开始重量级锁的竞争。
需要注意的是锁是可以升级的，但是并不能降级，这主要是为了提高获取锁和释放锁的效率。而且各种锁的适用条件并不相同。例如偏向锁，加锁和解锁并不需要太多的资源，但是如果存在大量的线程竞争，就会产生损耗，所以适用于只有一个线程执行同步块的情况（博主一直以为，这话说的很鸡肋，如果只有一个程序在执行同步块，为什么不把同步块单独写进线程，当然，这是不考虑线程封装的情况，如果所有的线程都执行一样的功能，那自然最好不要为了写一个同步块，单独写一个线程）。而轻量级锁在使用时由于竞争的线程不会阻塞，线程响应速度自然提高了，但是适应自旋来获取锁，就会造成CPU的额外损耗，所以适用于同步块执行时间比较短，并且追求响应速度的程序。
而重量级锁则不会消耗CPU资源，但是响应速度最慢，但是可以实现高吞吐量，（轻量级锁如果遇到高吞吐，大量的线程在自旋，机器估计要炸了），所以重量级锁，适用于追求高吞吐量，或者，同步块执行时间较长的程序。
上面就是博主的一些学习体会，希望大家多多指教。
在Java中，同步的代码块一次只能由一个线程执行。此外，java支持多个线程同时执行。这可能导致两个或多个线程同时访问相同的字段或对象。
同步是使执行中的所有并发线程保持同步的过程。同步可避免由于共享内存视图不一致而导致的内存一致性错误。当方法声明为synchronized时 ; 该线程持有监视器或锁定对象为这个方法的对象。如果另一个线程正在执行synchronized方法，则您的线程将被阻塞，直到该线程释放监视器。
请注意，我们可以
synchronized在类中使用关键字来定义方法或块。synchronized关键字不能与类定义中的变量或属性一起使用。1. Java中的对象级锁定
对象级锁是机制，当我们要同步非静态方法或者非静态代码块，使得只有一个线程就可以在类的给定实例执行的代码块。应始终这样做以使实例级数据线程安全。
对象级锁定可以按如下方式完成：
|
|
类级别锁定可防止多个线程synchronized在运行时的所有可用类实例中的块中输入。这意味着如果在运行时有100个实例DemoClass，则一次只能有一个线程demoMethod()在任何一个实例中执行，而其他所有实例都将被锁定用于其他线程。
应始终进行类级别锁定以使静态数据线程安全。我们知道static关键字将方法的数据关联到类级别，因此在静态字段或方法中使用锁定使其在类级别上进行。
|
|
synchronizedkeyword只能用于方法和代码块。这些方法或块可以是静态的还是非静态两种。synchronized方法或阻塞时，它获取一个锁，每当它离开同步方法或阻塞时，它就会释放锁。即使线程在完成后或由于任何错误或异常而离开同步方法，锁也会被释放。synchronized关键字本质上是可重入的，这意味着如果同步方法调用另一个需要相同锁定的同步方法，那么持有锁定的当前线程可以在不获取锁定的情况下进入该方法。NullPointerException如果synchronized块中使用的对象为null，则抛出Java同步。例如，在上面的代码示例中，如果将lock初始化为null，synchronized (lock)则将抛出“ ” NullPointerException。synchronized关键字与构造函数一起使用。这是非法的，会导致编译错误。new关键字创建的字符串对象可以安全使用。但作为最佳实践，请在我们要保护的共享变量本身上创建一个新的私有范围Object实例或锁定。[感谢Anu在评论中指出这一点。]让我知道Java中对象级别锁定与类级别锁定的想法和查询。
快乐学习!!
首先简单说下先偏向锁、轻量级锁、重量级锁三者各自的应用场景：
还要明确的是，偏向锁、轻量级锁都是JVM引入的锁优化手段，目的是降低线程同步的开销。比如以下的同步代码块：
synchronized (lockObject) {
// do something
}
上述同步代码块中存在一个临界区，假设当前存在Thread#1和Thread#2这两个用户线程，分三种情况来讨论：
上述的情况一是偏向锁的适用场景，此时当Thread#1进入临界区时，JVM会将lockObject的对象头Mark Word的锁标志位设为“01”，同时会用CAS操作把Thread#1的线程ID记录到Mark Word中，此时进入偏向模式。所谓“偏向”，指的是这个锁会偏向于Thread#1，若接下来没有其他线程进入临界区，则Thread#1再出入临界区无需再执行任何同步操作。也就是说，若只有Thread#1会进入临界区，实际上只有Thread#1初次进入临界区时需要执行CAS操作，以后再出入临界区都不会有同步操作带来的开销。
然而情况一是一个比较理想的情况，更多时候Thread#2也会尝试进入临界区。若Thread#2尝试进入时Thread#1已退出临界区，即此时lockObject处于未锁定状态，这时说明偏向锁上发生了竞争（对应情况二），此时会撤销偏向，Mark Word中不再存放偏向线程ID，而是存放hashCode和GC分代年龄，同时锁标识位变为“01”（表示未锁定），这时Thread#2会获取lockObject的轻量级锁。因为此时Thread#1和Thread#2交替进入临界区，所以偏向锁无法满足需求，需要膨胀到轻量级锁。
再说轻量级锁什么时候会膨胀到重量级锁。若一直是Thread#1和Thread#2交替进入临界区，那么没有问题，轻量锁hold住。一旦在轻量级锁上发生竞争，即出现“Thread#1和Thread#2同时进入临界区”的情况，轻量级锁就hold不住了。 （根本原因是轻量级锁没有足够的空间存储额外状态，此时若不膨胀为重量级锁，则所有等待轻量锁的线程只能自旋，可能会损失很多CPU时间）
MarkWord:
锁存在Java对象头里。如果对象是数组类型，则虚拟机用3个Word（字宽）存储对象头，如果对象是非数组类型，则用2字宽存储对象头。在32位虚拟机中，一字宽等于四字节，即32bit。
| 长度 | 内容 | 说明 |
| 32/64bit | Mark Word | 存储对象的hashCode或锁信息等。 |
| 32/64bit | Class Metadata Address | 存储到对象类型数据的指针 |
| 32/64bit | Array length | 数组的长度（如果当前对象是数组） |
Java对象头里的Mark Word里默认存储对象的HashCode，分代年龄和锁标记位。32位JVM的Mark Word的默认存储结构如下：
|
| 25 bit | 4bit | 1bit 是否是偏向锁 | 2bit 锁标志位 |
| 无锁状态 | 对象的hashCode | 对象分代年龄 | 0 | 01 |
在运行期间Mark Word里存储的数据会随着锁标志位的变化而变化。Mark Word可能变化为存储以下4种数据：
| 锁状态 | 25 bit | 4bit | 1bit | 2bit | |
| 23bit | 2bit | 是否是偏向锁 | 锁标志位 | ||
| 轻量级锁 | 指向栈中锁记录的指针 | 00 | |||
| 重量级锁 | 指向互斥量（重量级锁）的指针 | 10 | |||
| GC标记 | 空 | 11 | |||
| 偏向锁 | 线程ID | Epoch | 对象分代年龄 | 1 | 01 |
在64位虚拟机下，Mark Word是64bit大小的，其存储结构如下：
| 锁状态 | 25bit | 31bit | 1bit | 4bit | 1bit | 2bit |
|
|
| cms_free | 分代年龄 | 偏向锁 | 锁标志位 | |
| 无锁 | unused | hashCode |
|
| 0 | 01 |
| 偏向锁 | ThreadID(54bit) Epoch(2bit) |
|
| 1 | 01
|
上面是最简单的说法或者理解，但是实际上有很多的切换细节设计性能优化问题。
偏向所锁，轻量级锁都是乐观锁，重量级锁是悲观锁。
一个对象刚开始实例化的时候，没有任何线程来访问它的时候。它是可偏向的，意味着，它现在认为只可能有一个线程来访问它，所以当第一个线程来访问它的时候，它会偏向这个线程，此时，对象持有偏向锁。偏向第一个线程，这个线程在修改对象头成为偏向锁的时候使用CAS操作，并将对象头中的ThreadID改成自己的ID，之后再次访问这个对象时，只需要对比ID，不需要再使用CAS在进行操作。（偏向锁只进行一次cas操作）
一旦有第二个线程访问这个对象，因为偏向锁不会主动释放，所以第二个线程可以看到对象时偏向状态，这时表明在这个对象上已经存在竞争了，检查原来持有该对象锁的线程是否依然存活，如果挂了，则可以将对象变为无锁状态，然后重新偏向新的线程，如果原来的线程依然存活，则马上执行那个线程的操作栈，检查该对象的使用情况，如果仍然需要持有偏向锁，则偏向锁升级为轻量级锁，（偏向锁就是这个时候升级为轻量级锁的）。
如果不存在使用了，则可以将对象回复成无锁状态，然后重新偏向。 轻量级锁认为竞争存在，但是竞争的程度很轻，一般两个线程对于同一个锁的操作都会错开，或者说稍微等待一下（自旋），另一个线程就会释放锁。 但是当自旋超过一定的次数，或者一个线程在持有锁，一个在自旋，又有第三个来访时，轻量级锁膨胀为重量级锁，重量级锁使除了拥有锁的线程以外的线程都阻塞，防止CPU空转。
为什么此时升级为重量级锁呢，将所有竞争线程挂起（重量级锁，是jvm 借助系统级的互斥锁）？？假如很多线程都是处于轻量级上，都处于自旋状态，那么其中正在运行一个线程以及释放锁了，但是此时有很多线程在自旋，都在相互竞争。可能造成所有的线程都会一直自旋下去，cpu空转。
java
订阅
