Java synchronized到底锁住的是什么？

使用环境：多线程java程序中。

做用：在多线程的环境下，控制synchronized代码段不被多个线程同时执行。synchronized既能够加在一段代码上，也能够加在方法上。

使用：synchronized锁住的是括号里的对象，而不是代码。对于非static的synchronized方法，锁的就是对象自己也就是this。

经过如下两个案例说明：

//包含了synchronized 方法的类
public class SynchronizedMethod {
    public synchronized void test()
    {
        System.out.println("线程开始..");
        try {
            Thread.sleep(2000);
        } catch (Exception e) {
            e.printStackTrace();
        }
        System.out.println("线程结束..");
    }
}

//测试类
public class MyThread extends Thread{
    public void run(){
        SynchronizedMethod clazz = new SynchronizedMethod();
        clazz.test();
    }
    
    public static void main(String[] args) {
        for(int i=0;i<3;i++)
        {
            Thread thread = new MyThread();
            thread.start();
        }
    }

}


执行结果:

线程开始..
线程开始..
线程开始..
线程结束..
线程结束..
线程结束..

分析上述执行结果可知：

　　当main方法执行时，分别建立了三个MyThread对象，而这三个对象又各自建立了独立的 SynchronizedMethred类，虽然使用了test方法使用了synchronized方法修饰，可是synchronized锁住的是三个独立的对象，由于三个对象各自分别执行了test方法。

 

所以，能够修改代码，让三个线程使用同一个SynchronizedMethod对象：

 

 1 //修改测试类代码以下，使用同一对象调用test方法
 2 
 3 public class MyThread extends Thread{
 4 
 5     /**
 6      * Author:LearnAndGet
 7      */
 8     private SynchronizedMethod sync;
 9     public MyThread(SynchronizedMethod sync)
10     {
11         this.sync = sync;
12     }
13     
14     public void run(){
15         sync.test();
16     }
17 
18     
19     public static void main(String[] args) {
20         SynchronizedMethod sync = new SynchronizedMethod();
21         for(int i=0;i<3;i++)
22         {
23             MyThread thread = new MyThread(sync);
24             thread.start();
25         }
26     }
27 }

　运行结果：

线程开始..
线程结束..
线程开始..
线程结束..
线程开始..
线程结束..

分析上述结果：因为每次新线程启动，使用的同一对象sync，所以synchronized生效了。

 

固然，更经常使用的方法是：使用schronized锁住这个类对应的Class对象：

public class SynchronizedMethod {
    public void test()
    {
        //将代码块使用synchronized锁住
        synchronized(SynchronizedMethod.class)
        {
            System.out.println("线程开始..");
            try {
                Thread.sleep(2000);
            } catch (Exception e) {
                e.printStackTrace();
            }
            System.out.println("线程结束..");
        }
    }
}

使用上述代码后，即便每次建立不一样的SynchronizedMethod对象，执行其test方法时，由于synchronized锁住了SynchronizedMethod类对应的class对象，因此每次只能有一个SynchronizedMethod的对象获取锁，直到该锁得到释放，其余SynchronizedMethod对象都没法执行其方法。

上述代码中，经过使用 synchronized(SynchronizedMethod.class)实现了全局锁的效果

除此以外，使用 static synchronized一块儿修饰方法时，static方法能够直接类名加方法名调用，方法中没法使用this，因此它锁的不是this，而是类的Class对象，因此，static synchronized方法也至关于全局锁，至关于锁住了代码段。