第一部分： synchronized 与static synchronized 的区别java
第二部分：java多线程锁，源码剖析设计模式
一、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() jvm
b. x.isSyncA()与y.isSyncA()函数
c. x.cSyncA()与y.cSyncB()this
d. x.isSyncA()与Something.cSyncA()spa
这里，很清楚的能够判断：线程
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 方法。
二、synchronized方法与synchronized代码快的区别 synchronizedmethods(){}与 synchronized（this）{}之间没有什么区别，只是 synchronized methods(){} 便于阅读理解，而 synchronized （ this）{}能够更精确的控制冲突限制访问区域，有时候表现更高效率。
3 、synchronized
关键字是不能继承的
也就是说，基类的方法synchronized f(){} 在继承类中并不自动是synchronized f(){}，而是变成了f(){}。继承类须要你显式的指定它的某个方法为synchronized方法；
四、从源代码详细理解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); } }}