Java Synchronized 关键字

本文内容

• Synchronized 关键字
• 示例
• Synchronized 方法
• 内部锁（Intrinsic Locks）和 Synchronization
• 参考资料

下载 Demo

Synchronized 关键字

---

Java 语言提供两个基本的同步机制：synchronized 方法（synchronized methods ）和 synchronized  语句（synchronized statements）。

示例

---

先大概说一下 Java Synchronized 关键字，当它用来修饰一个方法或者一个代码块的时候，能够保证在同一时刻只有一个线程执行该段代码。

• 当两个线程访问同一个对象 synchronized(this) 代码块时，只能有一个线程执行，另一个线程必须等待这个线程执行完后才能执行；
• 但是，当一个线程访问一个对象 synchronized(this) 同步代码块时，另一个线程仍能访问该对象的非 synchronized(this) 代码块；
• 尤其是，当一个线程访问一个对象的一个 synchronized(this) 代码块时，其他线程对该对象中其他所有 synchronized(this) 代码块的访问也将被阻塞；
• 以上规则对其它对象锁同样适用。

如下代码所示：

package cn.db.syncdemo;

public class NewClass {
    /**
     * 同步方法
     */
    public void synchronizedMethod() {
        synchronized (this) {
            int i = 5;
            while (i-- > 0) {
                System.out.println(Thread.currentThread().getName() + " : " + i
                        + " synchronized method");
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    System.out.println(e.toString());
                }
            }
        }
    }

    /**
     * 同步方法 2
     */
    public void synchronizedMethod2() {
        synchronized (this) {
            int i = 5;
            while (i-- > 0) {
                System.out.println(Thread.currentThread().getName() + " : " + i
                        + " synchronized method 2");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    System.out.println(e.toString());
                }
            }
        }
    }

    /**
     * 非同步方法
     */
    public void nonSynchronizedMethod() {
        int i = 5;
        while (i-- > 0) {
            System.out.println(Thread.currentThread().getName() + " : " + i
                    + " nonSynchronized method");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                System.out.println(e.toString());
            }
        }
    }

    public static void main(String[] args) {
        final NewClass mClass = new NewClass();

        // t1 和 t2 都要访问同一个同步方法 synchronizedMethod
        Thread t1 = new Thread(new Runnable() {
            public void run() {
                mClass.synchronizedMethod();
            }
        }, "Thread 1");
        Thread t2 = new Thread(new Runnable() {
            public void run() {
                mClass.synchronizedMethod();
            }
        }, "Thread 2");
        // t3 要访问另一个同步方法 synchronizedMethod2
        Thread t3 = new Thread(new Runnable() {
            public void run() {
                mClass.synchronizedMethod2();
            }
        }, "Thread 3");

        // t4 要访问非同步方法 nonSynchronizedMethod
        Thread t4 = new Thread(new Runnable() {
            public void run() {
                mClass.nonSynchronizedMethod();
            }
        }, "Thread 4");

        t1.start();
        t2.start();
        t3.start();
        t4.start();

    }
}

运行结果：

Thread 4 : 4 nonSynchronized method
Thread 1 : 4 synchronized method
Thread 4 : 3 nonSynchronized method
Thread 4 : 2 nonSynchronized method
Thread 1 : 3 synchronized method
Thread 4 : 1 nonSynchronized method
Thread 4 : 0 nonSynchronized method
Thread 1 : 2 synchronized method
Thread 1 : 1 synchronized method
Thread 1 : 0 synchronized method
Thread 3 : 4 synchronized method 2
Thread 3 : 3 synchronized method 2
Thread 3 : 2 synchronized method 2
Thread 3 : 1 synchronized method 2
Thread 3 : 0 synchronized method 2
Thread 2 : 4 synchronized method
Thread 2 : 3 synchronized method
Thread 2 : 2 synchronized method
Thread 2 : 1 synchronized method
Thread 2 : 0 synchronized method

说明：

• synchronizedMethod 同步方法，每隔 2 秒输出一条信息；
• synchronizedMethod2 同步方法，每隔 1 秒输出一条信息；
• nonSynchronizedMethod 非同步方法，每隔 1 秒输出一条信息；

另外，

• 线程 t1 和线程 t2 都访问 synchronizedMethod  方法；
• 只有线程 t3 访问 synchronizedMethod2 方法；
• 只有线程 t4 访问 nonSynchronizedMethod  方法。

注意：

• t4 访问非同步方法 nonSynchronizedMethod2，无论何时都可以访问，所以“thread 4：……”出现的是不规律的，交错的；
• t1 和 t2 都要访问同一个同步方法 synchronizedMethod，所以“thread 1：……”和“thread 2：……”绝对不会交错显示，一个线程访问完后，另一个线程才能访问；
• 对于 t3，t3 自己访问另一个同步方法 synchronizedMethod2，并且没有其他线程再访问，而且当 t3 访问该方法时，其他同步方法也被锁了，所以，“thread 3：……”是连续出现的；
• 如果不看 t4，也就是没有该线程，那么结果会是：

Thread 1 : 4 synchronized method
Thread 1 : 3 synchronized method
Thread 1 : 2 synchronized method
Thread 1 : 1 synchronized method
Thread 1 : 0 synchronized method
Thread 3 : 4 synchronized method 2
Thread 3 : 3 synchronized method 2
Thread 3 : 2 synchronized method 2
Thread 3 : 1 synchronized method 2
Thread 3 : 0 synchronized method 2
Thread 2 : 4 synchronized method
Thread 2 : 3 synchronized method
Thread 2 : 2 synchronized method
Thread 2 : 1 synchronized method
Thread 2 : 0 synchronized method

说明：

• “thread 1……”和”thread 2……” 绝对不会交错出现，只有当其中一个访问完，另一个才能访问；
• 调试时，“thread 1……”和”thread 2……” 谁先出现，貌似是不确定的，但如果“thread 1……”先执行，那“thread 1……”先出现的几率肯定会大很多。这得看场景，毕竟是并发，谁先出现，谁后出现，并不重要的；
• ”thread 3……“访问时，“thread 1……”和”thread 2……” 也不能访问。虽然没有线程跟”thread 3……“抢，但这三个线程访问的都是两个同步方法。

Synchronized 方法

---

要想使一个方法为同步方法，只需简单给它的声明加上 synchronized 关键字就行：

package cn.db.syncdemo;

public class SynchronizedCounter {
    private int c = 0;

    public synchronized void increment() {
        c++;
    }

    public synchronized void decrement() {
        c--;
    }

    public synchronized int value() {
        return c;
    }
}

如果 count 是 SynchronizedCounter 的一个实例，那么把这些方法变成 synchronized 方法会有两个效果：

• 首先，在同一个对象上，交错调用 synchronized 方法是不可能的。当一个线程正在执行一个对象的 synchronized 方法时，所有调用该 synchronized 方法的其他线程会被挂起，直到第一个线程完成；
• 其次，当一个 synchronized 方法退出时，它自动地建立一个对同一个对象的这个同步方法的任何后续调用的发生前关系（happens-before relationship）。这保证了对象状态的改变对所有线程都是可见的。

注意：构造函数不能是 synchronized，也就是说，synchronized 关键字修饰构造函数是一个语法错误。synchronized 构造函数没有意义，因为当对象创建时，只有创建对象的那个线程才能访问它。

警告：当构造一个对象在线程之间共享时，必须非常小心，一个对象的引用不能过早地“泄漏”。例如，假设你想维护一个名为 instances 的 List，它包含类的每个实例。你可能会用下面代码在你的构造函数里：

instances.add(this);

但是，当对象构造完成后，其他线程使用 instances 访问对象。

synchronized 方法用一个简单策略来阻止线程干扰和内存一致性错误：如果一个对象对多个线程可见，所有读或写该对象的变量都通过 synchronized 方法完成。 （一个重要的例外：final 字段，对象被构造后不能被修改，可以通过非 synchronized 方法来安全地读取，一旦对象被构造）。

内部锁（Intrinsic Locks）和 Synchronization

---

同步是建立在被称为内部锁（Intrinsic Locks）或监视器锁定的一个内部实体。（API 规范往往指的是作为一个“显示器”的实体。）内在锁扮演两方面同步的角色：执行独占访问对象的状态，建立发生前关系（happens-before relationships ）必要的可见性。

每个对象都有一个与之关联的内部锁。通常，一个需要独占和一致的访问对象字段的线程必须在访问之前要求对象的内部锁，然后当完成后释放内部锁。线程在要求和释放锁之间的时间拥有内部锁。只要一个线程拥有一个内部锁，其他线程就不能再要求这个锁。当其他线程试图要求锁时就会被阻塞。

当一个线程释放内部锁时，一个发生前关系（happens-before relationship）在该动作和后续相同锁的动作之间被建立。

Synchronized Methods 方法

当一个线程调用一个 synchronized 方法，它会自动获取该方法对象的内部锁，并且，当方法返回时，释放锁。即使返回由未捕获的异常发生时造成的锁释放。

你可能想知道，一个静态的 synchronized 方法被调用时发生了什么，因为一个静态方法与一个类关联，而不是一个对象。在这种情况下，线程获得与类有关的 Class 对象的内部锁。因此，访问类的静态字段是由锁控制的，而这个锁与任何类的实例的锁不同。

Synchronized 语句

创建 synchronized 代码的另一个方式是 synchronized  语句。与 synchronized 方法不同，synchronized 语句必须指定提供内部锁的对象，如下代码所示中的“this”：

public void addName(String name) {
    synchronized(this) {
        lastName = name;
        nameCount++;
    }
    nameList.add(name);
}

本例中，addName 方法需要同步改变 lastName 和 nameCount，还需要避免其它对象的方法同步调用。要是没有 synchronized 语句，就必须有一个单独的、非 synchronized 方法用于调用 nameList.add 的目的。

Synchronized 语句对用细粒度同步来改进并发也很有用。假设，例如，类 MsLunch 有两个实例字段，c1 和 c2，它们绝不会一起使用。所有这些字段的更新都必须被同步，但没有理由阻止 c1 和 c2 交叉更新（通过创建一个没有必要的代码块，来减少并发）。因此，不是使用 synchronized(this)，而是为两个对象提供单独的锁。如下所示：

public class MsLunch {
    private long c1 = 0;
    private long c2 = 0;
    private Object lock1 = new Object();
    private Object lock2 = new Object();

    public void inc1() {
        synchronized(lock1) {
            c1++;
        }
    }

    public void inc2() {
        synchronized(lock2) {
            c2++;
        }
    }
}

这么用要格外小心。你必须绝对确保它对交叉访问受影响字段是真的安全。

Reentrant Synchronization

回想一下，一个线程不能获取由另一个线程拥有的锁。但一个线程可以获取，它已经拥有的锁。让一个线程不只一次获取相同的锁会造成折返同步（reentrant synchronization）。这描述了一种情况，同步代码码直接或间接地调用一个方法，该方法也包含的同步代码，并且这两组代码都使用相同的锁。如果没有折返同步（reentrant synchronization），同步代码必须采取很多额外的预防措施，来避免线程阻塞自己。

参考资料

---

• https://docs.oracle.com/javase/tutorial/essential/concurrency/syncmeth.html
• https://docs.oracle.com/javase/tutorial/essential/concurrency/syncrgb.html
• java 并发演示动画
  

下载 Demo