主要讲解synchronized的应用方式和内存语义。synchronized的三种应用方式synchronized关键字最主要有以下3种应用方式下面分别介绍修饰实例方法作用于当前实例加锁进入同步代码前要获得当前实例的锁修饰静态方法作用于当前类对象加锁进入同步代码前要获得当前类对象的锁修饰代码块指定加锁对象对给定对象加锁进入同步代码库前要获得给定对象的锁。synchronized作用于实例方法所谓的实例对象锁就是用synchronized修饰实例对象中的实例方法注意是实例方法不包括静态方法如下public class AccountingSync implements Runnable { //共享资源(临界资源) static int i 0; // synchronized 修饰实例方法 public synchronized void increase() { i ; } Override public void run() { for(int j0;j1000000;j){ increase(); } } public static void main(String args[]) throws InterruptedException { AccountingSync instance new AccountingSync(); Thread t1 new Thread(instance); Thread t2 new Thread(instance); t1.start(); t2.start(); t1.join(); t2.join(); System.out.println(static, i output: i); } } /** * 输出结果: * static, i output:2000000 */如果在函数increase()前不加synchronized因为i不具备原子性所以最终结果会小于2000000具体分析可以参考文章《Java并发编程系列2-volatile》。下面这点非常重要一个对象只有一把锁当一个线程获取了该对象的锁之后其他线程无法获取该对象的锁所以无法访问该对象的其他synchronized实例方法但是其他线程还是可以访问该实例对象的其他非synchronized方法。但是一个线程 A 需要访问实例对象 obj1 的 synchronized 方法 f1(当前对象锁是obj1)另一个线程 B 需要访问实例对象 obj2 的 synchronized 方法 f2(当前对象锁是obj2)这样是允许的public class AccountingSyncBad implements Runnable { //共享资源(临界资源) static int i 0; // synchronized 修饰实例方法 public synchronized void increase() { i ; } Override public void run() { for(int j0;j1000000;j){ increase(); } } public static void main(String args[]) throws InterruptedException { // new 两个AccountingSync新实例 Thread t1 new Thread(new AccountingSyncBad()); Thread t2 new Thread(new AccountingSyncBad()); t1.start(); t2.start(); t1.join(); t2.join(); System.out.println(static, i output: i); } } /** * 输出结果: * static, i output:1224617 */上述代码与前面不同的是我们同时创建了两个新实例AccountingSyncBad然后启动两个不同的线程对共享变量i进行操作但很遗憾操作结果是1224617而不是期望结果2000000因为上述代码犯了严重的错误虽然我们使用synchronized修饰了increase方法但却new了两个不同的实例对象这也就意味着存在着两个不同的实例对象锁因此t1和t2都会进入各自的对象锁也就是说t1和t2线程使用的是不同的锁因此线程安全是无法保证的。每个对象都有一个对象锁不同的对象他们的锁不会互相影响。解决这种困境的的方式是将synchronized作用于静态的increase方法这样的话对象锁就当前类对象由于无论创建多少个实例对象但对于的类对象拥有只有一个所有在这样的情况下对象锁就是唯一的。下面我们看看如何使用将synchronized作用于静态的increase方法。synchronized作用于静态方法当synchronized作用于静态方法时其锁就是当前类的class锁不属于某个对象。当前类class锁被获取不影响对象锁的获取两者互不影响。由于静态成员不专属于任何一个实例对象是类成员因此通过class对象锁可以控制静态成员的并发操作。需要注意的是如果一个线程A调用一个实例对象的非static synchronized方法而线程B需要调用这个实例对象所属类的静态synchronized方法不会发生互斥现象因为访问静态synchronized方法占用的锁是当前类的class对象而访问非静态synchronized方法占用的锁是当前实例对象锁看如下代码public class AccountingSyncClass implements Runnable { static int i 0; /** * 作用于静态方法,锁是当前class对象,也就是 * AccountingSyncClass类对应的class对象 */ public static synchronized void increase() { i; } // 非静态,访问时锁不一样不会发生互斥 public synchronized void increase4Obj() { i; } Override public void run() { for(int j0;j1000000;j){ increase(); } } public static void main(String[] args) throws InterruptedException { //new新实例 Thread t1new Thread(new AccountingSyncClass()); //new新实例 Thread t2new Thread(new AccountingSyncClass()); //启动线程 t1.start();t2.start(); t1.join();t2.join(); System.out.println(i); } } /** * 输出结果: * 2000000 */由于synchronized关键字修饰的是静态increase方法与修饰实例方法不同的是其锁对象是当前类的class对象。注意代码中的increase4Obj方法是实例方法其对象锁是当前实例对象如果别的线程调用该方法将不会产生互斥现象毕竟锁对象不同但我们应该意识到这种情况下可能会发现线程安全问题(操作了共享静态变量i)。synchronized同步代码块在某些情况下我们编写的方法体可能比较大同时存在一些比较耗时的操作而需要同步的代码又只有一小部分如果直接对整个方法进行同步操作可能会得不偿失此时我们可以使用同步代码块的方式对需要同步的代码进行包裹这样就无需对整个方法进行同步操作了同步代码块的使用示例如下public class AccountingSync2 implements Runnable { static AccountingSync2 instance new AccountingSync2(); // 饿汉单例模式 static int i0; Override public void run() { //省略其他耗时操作.... //使用同步代码块对变量i进行同步操作,锁对象为instance synchronized(instance){ for(int j0;j1000000;j){ i; } } } public static void main(String[] args) throws InterruptedException { Thread t1new Thread(instance); Thread t2new Thread(instance); t1.start();t2.start(); t1.join();t2.join(); System.out.println(i); } } /** * 输出结果: * 2000000 */从代码看出将synchronized作用于一个给定的实例对象instance即当前实例对象就是锁对象每次当线程进入synchronized包裹的代码块时就会要求当前线程持有instance实例对象锁如果当前有其他线程正持有该对象锁那么新到的线程就必须等待这样也就保证了每次只有一个线程执行i;操作。当然除了instance作为对象外我们还可以使用this对象(代表当前实例)或者当前类的class对象作为锁如下代码//this,当前实例对象锁 synchronized(this){ for(int j0;j1000000;j){ i; } } //class对象锁 synchronized(AccountingSync.class){ for(int j0;j1000000;j){ i; } }synchronized禁止指令重排分析指令重排的情况可以参考文章《Java并发编程系列1-基础知识》我们先看如下代码class MonitorExample { int a 0; public synchronized void writer() { //1 a; //2 } //3 public synchronized void reader() { //4 int i a; //5 //…… } //6 }假设线程A执行writer()方法随后线程B执行reader()方法。根据happens before规则这个过程包含的happens before关系可以分为两类根据程序次序规则1 happens before 2, 2 happens before 3; 4 happens before 5, 5 happens before 6。根据监视器锁规则3 happens before 4。根据happens before的传递性2 happens before 5。上述happens before 关系的图形化表现形式如下在上图中每一个箭头链接的两个节点代表了一个happens before 关系。黑色箭头表示程序顺序规则橙色箭头表示监视器锁规则蓝色箭头表示组合这些规则后提供的happens before保证。上图表示在线程A释放了锁之后随后线程B获取同一个锁。在上图中2 happens before 5。因此线程A在释放锁之前所有可见的共享变量在线程B获取同一个锁之后将立刻变得对B线程可见。synchronized的可重入性从互斥锁的设计上来说当一个线程试图操作一个由其他线程持有的对象锁的临界资源时将会处于阻塞状态但当一个线程再次请求自己持有对象锁的临界资源时这种情况属于重入锁请求将会成功。synchronized就是可重入锁因此一个线程调用synchronized方法的同时在其方法体内部调用该对象另一个synchronized方法是允许的如下public class AccountingSync implements Runnable{ static AccountingSync instancenew AccountingSync(); static int i0; static int j0; Override public void run() { for(int j0;j1000000;j){ //this,当前实例对象锁 synchronized(this){ i; increase();//synchronized的可重入性 } } } public synchronized void increase(){ j; } public static void main(String[] args) throws InterruptedException { Thread t1new Thread(instance); Thread t2new Thread(instance); t1.start();t2.start(); t1.join();t2.join(); System.out.println(i); } }当前实例对象锁后进入synchronized代码块执行同步代码并在代码块中调用了当前实例对象的另外一个synchronized方法再次请求当前实例锁时将被允许。需要特别注意另外一种情况当子类继承父类时子类也是可以通过可重入锁调用父类的同步方法。注意由于synchronized是基于monitor实现的因此每次重入monitor中的计数器仍会加1。总结该文章给大家讲解了synchronized的三种应用方式指令重排情况分析以及synchronized的可重入性通过该文章基本可以掌握synchronized的使用姿势以及可能会遇到的坑。关于“线程中断与synchronized”的相关知识因为篇幅原因就不写了大家可以到网上查一下相关资料进一步学习。