【老婆出差,送老婆去车站,本想送到站里面的,谁知检票员不让进,老婆在里面瞅了瞅我哈哈大笑道:"来呀,来打我啊!你进不来!"。知道老婆一直是个二货的我无奈地笑笑,谁知检票员开口了:你进去吧!这次给你个特例!我。。。。。。】
java 中关于锁的几点总结和建议
下面的内容有些概念解释得有点简单。但是,我不想解释一堆枯燥的概念。如果有哪些解释的不是很清楚,请谅解,然后找度娘。本文中的很多例子是来自网上的,并非有意抄袭。
"非线程安全" 的问题存在于 "实例变量" 中,如果是方法内部的私有变量,则不存在 "非线程安全" 的问题。
** 方法锁:**synchronized 修饰方法时。
** 对象锁:**synchronized 修饰方法或代码块。
** 类锁:**synchronized 修饰静态的方法或代码块。
总结:关键字加到 static 方法上是给 Class 上锁,加到非 static 方法上是给对象上锁。class 锁可以对类的所有实例起作用,即就是在任何时候,只能有一个线程访问该类的 static 方法。因为 static 方法就是类方法。
锁优化的思路和方法总结一下,有以下几种。
我们应该确保我们只在必要的地方加锁,将锁从方法声明移到方法体中会延迟锁的加载,进而降低了锁竞争的可能性。先看下面的实例:
- 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 同步代码块中的代码,另一个线程不可以访问该对象的任何同步代码块,但可以访问非同步代码块。所有缩小锁的范围可以在一定程度上提高代码性能。
这个例子其实和上面的尽量缩小锁的范围意思相差无二,也很简单,具体看下面例子,就不多说了。
- public synchronized void syncMethod(){
- method1();
- method2();
- method3();
- }
- public void syncMethod(){
- method1();
- //减少锁持有的时间
- synchronized(this){
- method2();
- }
- method3();
- }
加锁粒度:所谓加锁粒度就是你要锁住的范围是多大。
例如:你在家上卫生间,你只要锁住卫生间就可以了吧,不需要将整个家都锁起来不让家人进门吧,卫生间就是你的加锁粒度。
合理的加锁粒度:
其实卫生间并不只是用来上厕所的,还可以洗澡,洗手。这里就涉及到优化加锁粒度的问题。你在卫生间里洗澡,其实别人也可以同时去里面洗手,只要做到隔离起来就可以,如果马桶,浴缸,洗漱台都是隔开相对独立的,实际上卫生间可以同时给三个人使用,当然三个人做的事儿不能一样。这样就细化了加锁粒度,你在洗澡的时候只要关上浴室的门,别人还是可以进去洗手的。如果当初设计卫生间的时候没有将不同的功能区域划分隔离开,就不能实现卫生间资源的最大化使用。这就是设计架构的重要性。
Java 相关锁粒度注意点:
- 1. 读写分开 (CopyOnWrite)
- 2. 将锁打散 (ConcurrentHashMap 分解 Segment)
- 3. 通过 synchronized 或 Lock 来锁定一段代码区域时,除了考虑它们锁定的对象是什么以外,还需要考虑是否可以将范围缩小一些。
- 4. 定义多个对象,然后让不同的方法锁住不同的对象。
- 5. 拆分子方法,对某个必要的子方法加锁;通过锁块来隔离部分代码段。
- 6.JVM 对锁的优化有一个粗粒度的动作,我们自己写代码时尽量不依赖于 JVM 这种优化机制。
- 7. 用乐观替代悲观,如同步之前先做某些条件判断。
还有就是网上一个高手写的一个例子:
- 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);
- }
- }
通常情况下,为了保证多线程间的有效并发,会要求每个线程持有锁的时间尽量短,即在使用完公共资源后,应该立即释放锁。只有这样,等待在这个锁上的其他线程才能尽早的获得资源执行任务。但是,凡事都有一个度,如果对同一个锁不停的进行请求、同步和释放,其本身也会消耗系统宝贵的资源,反而不利于性能的优化 。
举个例子:
- 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++){
- }
- }
当然如果有需求说,这样的循环太久,需要给其他线程不要等待太久,那只能写成上面那种。如果没有这样类似的需求,还是直接写成下面那种比较好。
总结:减少对锁的等待时间的最有效方法是减少这个锁所保护的范围大小。下面是一些准则:
- 减少对任何锁的请求频率。
- 只锁定访问共享数据的代码,而不是一个组件的所有代码(这将减少锁的持有时间)。
- 只锁定特定的数据项或结构,而不是整个例程。
- 始终将锁和特定的数据项或结构关联起来,而不是和例程关联。
- 对于大的数据结构,为结构的每一元素选择一个锁,而不是为整个结构选择一个锁。
- 当持有一个锁时,从不执行同步 I/O 或者任何其他阻塞活动。
- 如果您对您组件中的同一数据有多个访问,请试着将它们移到一起,以便它们可以包含在一个锁定 - 解锁操作中。
- 避免双唤醒的情况。如果您在一个锁下修改了一些数据,并且不得不通知某人您做了这件事,那么在公布唤醒之前请释放该锁。
- 如果必须同时持有两个锁,那么最后请求那个最忙的锁。
来自村上春树《1Q84》
【禅师爱兰花:有一位金代禅师非常喜爱兰花,在平日弘法讲经之余,花费了许多的时间栽种兰花。有一天,他要外出云游一段时间,临行前交待弟子? 要好好照顾寺里的兰花。在这段期间,弟子们总是细心照顾兰花,但有一天在浇水时却不小心将兰花架碰倒了,所有的兰花盆都跌碎了,兰花散了满地。弟子们都因此非常恐慌,打算等师父回来后,向师父赔罪领罚。金代禅师回来了,闻知此事,便召集弟子们,不但没有责怪,反而说道:" 我种兰花,一来是希望用来供佛,二来也是为了美化寺庙环境,不是为了生气而种兰花的。】
【1】
【2】
【3】
【4】
【5】
【6】
【7】
【8】
如果有带给你一丝丝小快乐,就让快乐继续传递下去,欢迎点赞、顶、欢迎留下宝贵的意见、多谢支持!
来源: http://www.bubuko.com/infodetail-1999157.html