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

2023年6月30日 270次阅读 来源: 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
    本文转自网络文章，转载此文章仅为分享知识，如有侵权，请联系博主进行删除。
点赞