Java之多线程锁的10点整理和建议

开心一笑

【老婆出差，送老婆去车站，本想送到站里面的，谁知检票员不让进，老婆在里面瞅了瞅我哈哈大笑道：“来呀，来打我啊！你进不来！”。知道老婆一直是个二货的我无奈地笑笑，谁知检票员开口了：你进去吧！这次给你个特例！我。。。。。。】

视频教程

大家好，我录制的视频《Java之优雅编程之道》已经在CSDN学院发布了，有兴趣的同学可以购买观看，相信大家一定会收获到很多知识的。谢谢大家的支持……

视频地址：http://edu.csdn.net/lecturer/994

提出问题

java中关于锁的几点总结和建议???

解决问题

前言

下面的内容有些概念解释得有点简单。但是，我不想解释一堆枯燥的概念。如果有哪些解释的不是很清楚，请谅解，然后找度娘。本文中的很多例子是来自网上的，并非有意抄袭。

1.线程安全和非线程安全概念

“非线程安全”的问题存在于“实例变量”中，如果是方法内部的私有变量，则不存在“非线程安全“的问题。

2.方法锁，对象锁，类锁概念

**方法锁：**synchronized 修饰方法时。

**对象锁：**synchronized 修饰方法或代码块。

**类锁:**synchronized 修饰静态的方法或代码块。

总结：关键字加到 static 方法上是给 Class 上锁，加到非 static 方法上是给对象上锁。class 锁可以对类的所有实例起作用，即就是在任何时候，只能有一个线程访问该类的 static 方法。因为 static 方法就是类方法。

3.synchronized需要注意的几点

synchronized 取得的锁都是对象锁，而不是代码。

synchronized 关键字是不能继承的。基类的方法 synchronized ay(){} 在继承类中并不自动是 synchronized ay(){}，而是变成了ay(){}。继承类需要你显式的指定它的某个方法为 synchronized 方法。

一个线程访问了 synchronized 同步代码块中的代码，另一个线程不可以访问该对象的任何同步代码块，但可以访问非同步代码块。同步代码块锁定的也是当前对象

4. 锁优化的思路

锁优化的思路和方法总结一下，有以下几种。

减少锁持有时间（尽量缩小锁的范围）

减小锁粒度

锁分离

锁粗化

锁消除

5.尽量缩小锁的范围

我们应该确保我们只在必要的地方加锁，将锁从方法声明移到方法体中会延迟锁的加载，进而降低了锁竞争的可能性。先看下面的实例：

class SynObj {

//方法锁/或者对象锁
public synchronized void methodA() {
System.out.println("methodA.....");
try {
Thread.sleep(5000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}

public  void methodB() {
//对代码块进行锁，降低锁的竞争
synchronized(this) {
System.out.println("methodB.....");
}
}

public void methodC() {
String str = "sss";
//这里锁的是 str 这个对象，而不是 SynObj 对象
synchronized (str) {
System.out.println("methodC.....");
}
}
}

/**
* Created by Ay on 2017/3/26.
*/
public class AyTest {

public static void main(String[] args) {
final SynObj obj = new SynObj();

Thread t1 = new Thread(new Runnable() {
@Override
public void run() {
obj.methodA();
}
});
t1.start();

Thread t2 = new Thread(new Runnable() {
@Override
public void run() {
obj.methodB();
}
});
t2.start();

Thread t3 = new Thread(new Runnable() {
@Override
public void run() {
obj.methodC();
}
});
t3.start();
}
}

打印结果:

methodA.....
methodC.....
//methodB会隔一段时间才会打印出来
methodB.....

总结：因为，一个线程访问了 synchronized 同步代码块中的代码，另一个线程不可以访问该对象的任何同步代码块，但可以访问非同步代码块。所有缩小锁的范围可以在一定程度上提高代码性能。

6.减少锁持有时间

这个例子其实和上面的尽量缩小锁的范围意思相差无二，也很简单，具体看下面例子，就不多说了。

public synchronized void syncMethod(){
method1();
method2();
method3();
}

public void syncMethod(){
method1();
//减少锁持有的时间
synchronized(this){
method2();
}
method3();
}

7.减小锁粒度

加锁粒度：所谓加锁粒度就是你要锁住的范围是多大。

例如：你在家上卫生间，你只要锁住卫生间就可以了吧，不需要将整个家都锁起来不让家人进门吧，卫生间就是你的加锁粒度。

合理的加锁粒度:

其实卫生间并不只是用来上厕所的，还可以洗澡，洗手。这里就涉及到优化加锁粒度的问题。你在卫生间里洗澡，其实别人也可以同时去里面洗手，只要做到隔离起来就可以，如果马桶，浴缸，洗漱台都是隔开相对独立的，实际上卫生间可以同时给三个人使用，当然三个人做的事儿不能一样。这样就细化了加锁粒度，你在洗澡的时候只要关上浴室的门，别人还是可以进去洗手的。如果当初设计卫生间的时候没有将不同的功能区域划分隔离开，就不能实现卫生间资源的最大化使用。这就是设计架构的重要性。

Java相关锁粒度注意点：

- 1.读写分开(CopyOnWrite)

- 2.将锁打散(ConcurrentHashMap分解Segment)

- 3.通过synchronized或Lock来锁定一段代码区域时，除了考虑它们锁定的对象是什么以外，还需要考虑是否可以将范围缩小一些。

- 4.定义多个对象，然后让不同的方法锁住不同的对象。

- 5.拆分子方法，对某个必要的子方法加锁；通过锁块来隔离部分代码段。

- 6.JVM对锁的优化有一个粗粒度的动作，我们自己写代码时尽量不依赖于JVM这种优化机制。

- 7.用乐观替代悲观，如同步之前先做某些条件判断。

8.锁分离

最常见的锁分离就是读写锁ReadWriteLock，根据功能进行分离成读锁和写锁，这样读读不互斥，读写互斥，写写互斥，即保证了线程安全，又提高了性能。

还有就是网上一个高手写的一个例子：

public class Grocery {
private final ArrayList fruits = new ArrayList();
private final ArrayList vegetables = new ArrayList();
//对象锁，不好，效率低
public synchronized void addFruit(int index, String fruit) {
fruits.add(index, fruit);
}
//对象锁，不好，效率低
public synchronized void removeFruit(int index) {
fruits.remove(index);
}
//对象锁，不好，效率低
public synchronized void addVegetable(int index, String vegetable) {
vegetables.add(index, vegetable);
}
//对象锁，不好，效率低
public synchronized void removeVegetable(int index) {
vegetables.remove(index);
}
}

优化后：

public class Grocery {
private final ArrayList fruits = new ArrayList();
private final ArrayList vegetables = new ArrayList();
public void addFruit(int index, String fruit) {
//水果锁
synchronized(fruits) fruits.add(index, fruit);
}
public void removeFruit(int index) {
//水果锁
synchronized(fruits) {fruits.remove(index);}
}
public void addVegetable(int index, String vegetable) {
//蔬菜锁
synchronized(vegetables) vegetables.add(index, vegetable);
}
public void removeVegetable(int index) {
//蔬菜锁
synchronized(vegetables) vegetables.remove(index);
}
}

9.锁粗化

通常情况下，为了保证多线程间的有效并发，会要求每个线程持有锁的时间尽量短，即在使用完公共资源后，应该立即释放锁。只有这样，等待在这个锁上的其他线程才能尽早的获得资源执行任务。但是，凡事都有一个度，如果对同一个锁不停的进行请求、同步和释放，其本身也会消耗系统宝贵的资源，反而不利于性能的优化 。

举个例子：

public void demoMethod(){
synchronized(lock){
//do sth.
}
//做其他不需要的同步的工作，但能很快执行完毕
synchronized(lock){
//do sth.
}
}

这种情况，根据锁粗化的思想，应该合并

public void demoMethod(){
//整合成一次锁请求
synchronized(lock){
//do sth.
//做其他不需要的同步的工作，但能很快执行完毕
}
}

当然这是有前提的，前提就是中间的那些不需要同步的工作是很快执行完成的。

再举一个极端的例子：

for(int i=0;i<CIRCLE;i++){
synchronized(lock){

}
}

在一个循环内不同得获得锁。虽然JDK内部会对这个代码做些优化，但是还不如直接写成

synchronized(lock){
for(int i=0;i<CIRCLE;i++){

}
}

当然如果有需求说，这样的循环太久，需要给其他线程不要等待太久，那只能写成上面那种。如果没有这样类似的需求，还是直接写成下面那种比较好。

10 锁原则的总结

总结：减少对锁的等待时间的最有效方法是减少这个锁所保护的范围大小。下面是一些准则：

- 减少对任何锁的请求频率。

- 只锁定访问共享数据的代码，而不是一个组件的所有代码（这将减少锁的持有时间）。

- 只锁定特定的数据项或结构，而不是整个例程。

- 始终将锁和特定的数据项或结构关联起来，而不是和例程关联。

- 对于大的数据结构，为结构的每一元素选择一个锁，而不是为整个结构选择一个锁。

- 当持有一个锁时，从不执行同步 I/O 或者任何其他阻塞活动。

- 如果您对您组件中的同一数据有多个访问，请试着将它们移到一起，以便它们可以包含在一个锁定 - 解锁操作中。

- 避免双唤醒的情况。如果您在一个锁下修改了一些数据，并且不得不通知某人您做了这件事，那么在公布唤醒之前请释放该锁。

- 如果必须同时持有两个锁，那么最后请求那个最忙的锁。

读书感悟

来自村上春树《1Q84》

孤独一人也没关系，只要能发自内心地爱着一个人，人生就会有救。哪怕不能和他生活在一起。

有希望之处定有磨练。

我能承受任何痛苦，只要这种痛苦有意义。

如果能真心爱上一个人，那么不管对方是何等恶劣，哪怕对方并不爱自己，人生也至少不会是地狱，就算多少有点黯淡。

世上的人大半不会用自己的脑袋思考，而且越是不思考的人，越不愿倾听别人说话。

我讨厌别人的施舍，因此要尽可能多地施与于人。

有再多的才能，也未必能换来一顿饱饭；但是有优秀的直觉，就完全衣食无忧了。

经典故事

【禅师爱兰花：有一位金代禅师非常喜爱兰花，在平日弘法讲经之余，花费了许多的时间栽种兰花。有一天，他要外出云游一段时间，临行前交待弟子?要好好照顾寺里的兰花。在这段期间，弟子们总是细心照顾兰花，但有一天在浇水时却不小心将兰花架碰倒了，所有的兰花盆都跌碎了，兰花散了满地。弟子们都因此非常恐慌，打算等师父回来后，向师父赔罪领罚。金代禅师回来了，闻知此事，便召集弟子们，不但没有责怪，反而说道：“我种兰花，一来是希望用来供佛，二来也是为了美化寺庙环境，不是为了生气而种兰花的。】

大神文章

【1】《java多线程编程核心技术》读书笔记2.1

【2】Java多线程编程核心技术–第二章

【3】方法锁，对象锁，类锁区别

【4】java中的synchronized（同步代码块和同步方法的区别）

【5】改善Java中锁的性能

【6】[高并发Java 九] 锁的优化和注意事项

【7】并发性能优化 – 降低锁粒度

【8】锁粒度

其他

如果有带给你一丝丝小快乐，就让快乐继续传递下去，欢迎点赞、顶、欢迎留下宝贵的意见、多谢支持！