java的静态方法加锁与一般方法加锁

第一部分: synchronized 与static synchronized  的区别

第二部分:java多线程锁,源码剖析

1、synchronized与static synchronized 的区别

      synchronized是对类的当前实例进行加锁,防止其他线程同时访问该类的该实例的所有synchronized块。

  static synchronized是限制线程同时访问jvm中该类的所有实例同时访问对应的代码块。且一个类的所有静态方法公用一把锁。
如下:

pulbic class Something(){

       public synchronized void isSyncA(){}

       public synchronized void isSyncB(){}

       public static synchronized void cSyncA(){}

       public static synchronized void cSyncB(){}

}

注解:该列子来自一个日本作者-结成浩的《java多线程设计模式》

那么,假如有Something类的两个实例a与b,那么下列组方法何以被1个以上线程同时访问呢

a.   x.isSyncA()与x.isSyncB() 

b.   x.isSyncA()与y.isSyncA()

c.   x.cSyncA()与y.cSyncB()

d.   x.isSyncA()与Something.cSyncA()

这里,很清楚的可以判断:

a,都是对同一个实例的synchronized域访问,因此不能被同时访问

b,是针对不同实例的,因此可以同时被访问

c,因为是staticsynchronized,所以不同实例之间仍然会被限制,相当于Something.isSyncA()与   Something.isSyncB()了,因此不能被同时访问。

那么,第d呢?,书上的 答案是可以被同时访问的,答案理由是synchronzied的是实例方法与synchronzied的类方法由于锁定(lock)不同的原因。

个人分析也就是synchronized 与static synchronized 相当于两帮派,各自管各自,相互之间就无约束了,可以被同时访问。 后面一部分将详细分析 synchronzied 是怎么样实现的 

结论 :

A: synchronized static是某个类的范围,synchronized static cSync{}防止多个线程同时访问这个类中的synchronized static 方法。它可以对类的所有对象实例起作用。

B: synchronized 是某实例的范围,synchronized isSync(){}防止多个线程同时访问这个实例中的synchronized 方法。

2、synchronized方法与synchronized代码快的区别        synchronizedmethods(){}与 synchronized(this){}之间没有什么区别,只是 synchronized methods(){} 便于阅读理解,而 synchronized ( this){}可以更精确的控制冲突限制访问区域,有时候表现更高效率。

3 、synchronized

关键字是不能继承的

也就是说,基类的方法synchronized f(){} 在继承类中并不自动是synchronized f(){},而是变成了f(){}。继承类需要你显式的指定它的某个方法为synchronized方法;

4、从源代码详细理解synchronized关键字(参考Observable类源码)

Java中的Observer模式,看了其中的Observable类的源码,发现里面几乎所有的方法都用了synchronized关键字(不是全部),其中个别用了synchronized(this){}的区块

第二部分:Java多线程锁,源代码剖析

多线程的同步依靠的是锁机制,java中可通过 synchronized 关键字锁锁住共享资源以实现异步多线程的达到同步。总结起来,要达到同步,我们要做的就是构造各线程间的 共享资源 ,其中的共享资源可以 对象 ,也可以是 方法 。

package algorithms.com.guan.zoo.stackTest;

public class LockDemo {
  public static void main(String[] args) {
    MyRunnerVarLock runnerVarLock = new MyRunnerVarLock(new Integer(0));
    MyRunnerFuncLock runnerFuncLock = new MyRunnerFuncLock();
    MyRunnerNoLock runnerNoLock = new MyRunnerNoLock(); 
    
    // 对共享对象进行加锁,线程会依次打印0-99的数,每一次运行的结果都一样
    for(int i = 0; i < 10; i++) {
      Thread thread = new Thread(runnerVarLock);
      thread.start();
    }
    
    // 对共享函数进行加锁,线程会依次打印0-99的数,每一次运行的结果都一样
    for(int i = 0; i < 10; i++) {
      Thread thread = new Thread(runnerFuncLock);
      thread.start();
    }
    
    // 未加锁,会因为线程调用的时序不同而发生变化,每一次运行的结果不一定相同
    for(int i = 0; i < 10; i++) {
      Thread thread = new Thread(runnerNoLock);
      thread.start();
    }
  }
}

// 对共享对象进行加锁
class MyRunnerVarLock implements Runnable {
  private Object lock;

  public MyRunnerVarLock(Object lock) {
    this.lock = lock;
  }

  public void run() {
    synchronized (lock) {
      for (int i = 0; i < 100; i++) {
        System.out.println("Lock: " + i);
      }
    }
  }
}

// 对共享函数进行加锁
class MyRunnerFuncLock implements Runnable {
  public synchronized void run() {
    for (int i = 0; i < 100; i++) {
      System.out.println("Func lock: " + i);
    }
  }
}

// 没有加锁
class MyRunnerNoLock implements Runnable {
  public void run() {
    for (int i = 0; i < 100; i++) {
      System.out.println("No lock: " + i);
    }
  }
}


    原文作者:java锁
    原文地址: https://blog.csdn.net/qq_35909080/article/details/79068694
    本文转自网络文章,转载此文章仅为分享知识,如有侵权,请联系博主进行删除。
点赞