synchronized关键字的使用

一、synchronized介绍

        synchronized是Java的一个关键字，实际使用对象锁保证了临界区代码的原子性，是线程同步的一种方式。synchronized可以修饰方法或者代码块，当修饰方法时锁住的是整个方法(实际锁住的是当前对象，保证了整个方法的原子性)，如果修饰的方法是静态方法会锁住整个类(锁的是类对象)。修饰代码块时只锁代码块。注意：不可以修饰静态代码块。

二、synchronized使用

        1、synchronized修饰普通方法

    public static void main(String[] args) {
        Test02 test02 = new Test02();
        new Thread(()->{
            test02.method();
        },"t1").start(); // 启动线程1
        new Thread(()->{
            test02.method();
        },"t2").start(); // 启动线程2
    }
    public synchronized void method(){
        System.out.println(Thread.currentThread() + "进入了method方法");
        while (true){

        }
    }

   

        可见，当线程1进入方法时，在线程1执行结束前，线程2无法进入该方法中。如果去掉 synchronized 修饰可以看到两个线程均进入方法中。由此可知被synchronized修饰的方法不会被多个线程同时访问，那么是什么原因使得线程不能同时访问被synchronized修饰的方法呢？

        synchronized是利用对象锁的原理保证临界区代码的原子性，修饰方法时是利用当前对象的对象锁来保证原子性，当线程1拿到了当前对象的对象锁，线程2就需要等待线程1释放锁后才能拿到锁，因此上述的例子中线由于线程1迟迟没有释放锁(方法执行完自动释放锁)，线程2一直处于等待状态。由于线程1和线程2是使用同一个对象调用的method()方法，才会无法同时访问，那若是利用不同对象调用method()方法会怎么样呢？

 

    public static void main(String[] args) {

        new Thread(()->{
            Test02 test02 = new Test02();
            test02.method();
        },"t1").start(); // 启动线程1
        new Thread(()->{
            Test02 test02 = new Test02();
            test02.method();
        },"t2").start(); // 启动线程2
    }
    public synchronized void method(){
        System.out.println(Thread.currentThread() + "进入了method方法");
        while (true){

        }
    }

         可以看到，两个线程此时使用不同的对象调用method()方法，两个线程均可进入，为什么会这样呢？原因就是synchronized锁住了当前对象，而两个不同的对象调用的method方法，所以两个线程执行到synchronized修饰的方法时都可以拿到对象锁，不会阻塞。

        2、synchronized修饰静态方法

                synchronized修饰静态方法锁的是类对象，因此整个类都会被锁住。如上述代码中，即使使用不同的对象调用method方法都需要先获得类对象锁，而不是当前对象锁。

        3、synchronized修饰代码块

                synchronized修饰代码块需要传进去一个对象，充当对象锁。

    public static void main(String[] args) {
        Test02 test02 = new Test02();
        new Thread(()->{
            test02.method();
        },"t1").start(); // 启动线程1
        new Thread(()->{

            test02.method();
        },"t2").start(); // 启动线程2
    }
    public void method(){
        System.out.println(Thread.currentThread() + "进入了method方法");
        synchronized (this){ // 使用当前对象的对象锁
            System.out.println(Thread.currentThread() + "进入了代码块");
            while (true){

            }
        }
    }

         上面可以看到两个方法均进入了method方法中，但是只有线程1进入了代码块中。因为两个线程是被同一个对象调用的，this作为参数就锁住了当前对象，两个线程就只能有一个线程获得锁。此外，还可以new 任何一个对象当作对象锁。

    private Object a = new Object();
    public void method(){
        System.out.println(Thread.currentThread() + "进入了method方法");
        synchronized (a){ // 使用当前对象的对象锁
            System.out.println(Thread.currentThread() + "进入了代码块");
            while (true){

            }
        }
    }

        上面就创建了一个Object类的对象做为对象锁，进入代码块的线程需要获得该对象的锁才能继续运行，否则会进入阻塞状态。

 三、小结

        synchronized利用对象的锁来保证临界区代码的原子性，需值得注意的是，同步是一种高开销的操作，因此应该尽量减少同步的内容。通常没有必要同步整个方法，使用synchronized代码块同步关键代码即可。