背景：

在java多线程当中，我们总有遇到过多个线程操作一个共享数据时，而这个最后的代码执行结果并没有按照我们的预期一样得到正确的结果。此时我们就需要让代码执行在操作共享变量时，要等一个线程操作完毕时，另一个线程才能去操作这个共享变量。synchronized锁就能达到这样的目的。在线程A操作某个共享变量时，其他线程想要操作这个对像的话只能先处于等待状态，只有线程A操作完毕后其他线程才能操作这个变量。synchronized还有一个作用，就是将让其他线程看到这个线程内对像的变化，获取到对像的最新的值。

sychronized锁的使用方式

利用synchronized实现同步的基础：Java中的每一个对象都可以作为锁。具体表现 为以下3种形式。

• 对于普通同步方法，锁是当前实例对象。
• 对于静态同步方法，锁是当前类的Class对象。
• 对于同步方法块，锁是Synchonized括号里配置的对象。

下面我对于这三种方式进行详细的说明，但再此之前要介绍多线程操作共享变量的内存图：

多线程处理共享数据是从主内存中将数据拷贝一份到自己的工作内存当中，再工作内存当中对其进行操作，然后再写回到主内存当中。

对于普通同步方法，锁是当前实例对象。

当sychronized修饰普通方法时，这个方法已经变为了同步方法，并对这个对象加了锁，此时想要操作这个对像的同步方法要先获得这个对像的锁，所以说这个加锁并不是其他线程都无法访问这个对象了，而是无法访问这个对像内被sychronized修饰变为同步方法的方法了，其他方法并不受影响。

public class ThreadTest {
    public synchronized  void m1() {    //同步方法
        System.out.println("m1方法开始");
        try {
            Thread.sleep(1000);
        } catch (Exception e) {}
        System.out.println("m1方法结束");
    }
    public synchronized void m2() {   //同步方法
        System.out.println("m2方法开始");
        try {
            Thread.sleep(1000);
        } catch (Exception e) {}
        System.out.println("m2方法结束");
    }

    public static void main(String[] args) {
        ThreadTest threadTest = new ThreadTest();
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                threadTest.m1();
            }
        });
        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                threadTest.m2();
            }
        });
        t1.start();
        t2.start();

    }
}

此时m1和m2方法都是同步方法，我们创建一个ThreadTest对像，然后用两个线程分别调用同一个对像的m1和m2方法，根据前面两个所讲，可以预测由于线程1执行方法m1时就拿到了这个对像锁，则其他线程无法执行这个对像的其他同步方法。执行结果不出我们所料：

确实是线程1先执行m1，等其执行完毕后线程2再执行的m2方法。当我们将m2变为普通方法（不被关键字synchronized修饰），然后执行：

这时候就没有等待线程1执行同步方法m1完毕后线程2再调用m2方法。因为此时执行普通方法m2不需要这个对像的锁，也就不用等待线程A执行完释放锁了。

对于静态同步方法，锁是当前类的Class对象。

当synchronized修饰的是静态方法时，此时加锁的并不是这个类的实例对象了，而是这个类的Class对象。此时和前面那种形式有一些不同了。但一个线程调用这个静态同步方法时会获取到这个Class对像的锁，其他线程就不能再执行这个类的其他静态同步方法。但可以调用其他普通的静态方法和普通方法。同时也可以调用它的普通同步方法，因为调用这两者方法需要的锁并不一样，一个是类锁，一个是对像锁，所以他们并不互斥。下面代码结果展示一下：

public class ThreadTest {
    public synchronized  void m1() {
        System.out.println("m1方法开始");
        try {
            Thread.sleep(1000);
        } catch (Exception e) {}
        System.out.println("m1方法结束");
    }
    public synchronized static void m2() {
        System.out.println("m2方法开始");
        try {
            Thread.sleep(1000);
        } catch (Exception e) {}
        System.out.println("m2方法结束");
    }
    public synchronized static void m3() {
        System.out.println("m3方法开始");
        try {
            Thread.sleep(1000);
        } catch (Exception e) {}
        System.out.println("m3方法结束");
    }


    public static void main(String[] args) {
        ThreadTest threadTest = new ThreadTest();
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                threadTest.m1();
            }
        });
        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                ThreadTest.m2();
            }
        });
        Thread t3 = new Thread(new Runnable() {
            @Override
            public void run() {
                ThreadTest.m3();
            }
        });
        t1.start();
        t2.start();
        t3.start();

    }
}

我定义了三个方法都用synchronized修饰了，m1是普通同步方法，而m2、m3是静态同步方法，并用三个线程分别调用这三个方法。按照前面原理解释，m1方法和m2、m3这两个方法不互斥，m2和m3这两个方法互斥。

由结果看出，m1和m2方法可以看出不互斥，同时执行，并没有等待，而m3方法是再m2方法完全执行完毕后再执行的。可以说明m2执行时获取了Class对象的锁，而静态同步方法m3想要执行的话，就得等待锁的释放才能执行，最终产生了上面的执行结果。

对于同步方法块，锁是Synchonized括号里配置的对象。

锁住同步方法块，锁是synchonized括号里面那个引用类型对像（注意：能作为锁的只能是引用类型，不能是基本数据类型）。这样子实现的功能是：因为线程的切换是随机的，但我们要保证一段代码一定要全部执行，不想被执行到一办事就被切换到其他线程，无法保证线程安全。此时就需要synchonized来锁住这段代码了。还有就是想要执行这个代码块就得先获取到相对应的对象锁。也就是说当两个线程执行两个拿同一个对象作为锁的代码块，则两者不能同时执行，必须等一个代码块执行完毕，释放锁后，另一个线程才能获取这个对像锁然后执行。

public class ThreadTest {
    public static Object o = new Object();
    public   void m1() {
        synchronized(o) {
            System.out.println("m1方法开始");
            try {
                Thread.sleep(1000);
            } catch (Exception e) {
            }
            System.out.println("m1方法结束");
        }
    }
    public   void m2() {
        synchronized(o){
            System.out.println("m2方法开始");
            try {
                Thread.sleep(1000);
            } catch (Exception e) {}
            System.out.println("m2方法结束");
        }
    }


    public static void main(String[] args) {
        ThreadTest threadTest = new ThreadTest();
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                threadTest.m1();
            }
        });
        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                threadTest.m2();
            }
        });
        t1.start();
        t2.start();

    }
}

代码中两个线程各执行一个代码块，两个代码块用的是同一个对象锁，则他们不能同时执行是互斥的。

由输出结果可以看出，线程2中的代码块是等线程1执行完其内的代码块并释放锁后再执行的。