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);
}
}
}