![](http://static.blog.csdn.net/images/category_icon.jpg)
Java中的同步
线程间的通讯首要的方式就是对字段及其字段所引用的对象的共享访问。这种通信方式是及其高效的,但是也是导致了可能的错误:线程间相互干涉和内存一致性的问题。避免出现这两种错误的方法就是同步。
- 线程间相互干扰描述了当多个线程访问共享数据时可能出现的错误。
- 内存一致性错误描述的了共享内存可能导致的错误。
- 同步方法(Synchronized method)描述了一种简单的可以有效防止线程间相互干扰及其内存一致性错误的方法。
- 明锁及同步描述了一种更加通用的同步方法,以及同步是如何基于明锁而实现的。
- 原子性描述了不能被其它线程干扰的操作。
线程间的相互干扰
—————————————————————————————————————————————————————————————————————————————
考虑下面的一个简单的类Counter:
不难看出,其中的increment()方法用来对c加1;decrement()方法用来对c减1。然而,有多个线程中都存在对某个Counter对象的引用,那么线程间的干扰就可能导致出现我们不想要的结果。
线程间的干扰出现在多个线程对同一个数据进行多个操作的时候,也就是出现了“交错”。这就意味着操作是由多个步骤构成的,而此时,在这多个步骤的执行上出现了叠加。
Counter类对象的操作貌似不可能出现这种“交错”,因为其中的两个关于c的操作都很简单,只有一条语句。然而,即使是一条语句也是会被VM翻译成多个步骤的。在这里,我们不深究VM具体上上面的操作翻译成了什么样的步骤。只需要知道即使简单的c++这样的表达式也是会被翻译成三个步骤的:
1. 获取c的当前值。
2. 对其当前值加1。
3. 将增加后的值存储到c中。
表达式c--也是会被按照同样的方式进行翻译,只不过第二步变成了减1,而不是加1。
假定线程A中调用increment方法,线程B中调用decrement方法,而调用时间基本上相同。如果c的初始值为0,那么这两个操作的“交错”顺序可能如下:
1. 线程A:获取c的值。
2. 线程B:获取c的值。
3. 线程A:对获取到的值加1;其结果是1。
4. 线程B:对获取到的值减1;其结果是-1。
5. 线程A:将结果存储到c中;此时c的值是1。
6. 线程B:将结果存储到c中;此时c的值是-1。
这样线程A计算的值就丢失了,也就是被线程B的值覆盖了。上面的这种“交错”只是一种可能性。在不同的系统环境中,有可能是B线程的结果丢失了,或者是根本就不会出现错误。由于这种“交错”是不可预测的,线程间相互干扰造成的缺陷是很难定位和修改的。
内存一致性错误
—————————————————————————————————————————————————————————————————————————————
内存一致性错误发生在不同线程对同一数据产生不同的“见解”。导致内存一致性错误的原因很复杂,超出了本文的描述范围。庆幸的是,程序员并不需要知道出现这些原因的细节。我们需要的只是一种可以避免这种错误的方法。
避免出现内存一致性错误的关键在于理解“先后顺序”关系。这种关系是一种简单的方法,能够确保一条语句对内存的写操作对于其它特定的语句都是可见的。为了理解这点,我们可以考虑如下的示例。假定定义了一个简单的int类型的字段并对其进行了初始化:
int counter = 0;
该字段由两个线程共享:A和B。假定线程A对counter进行了自增操作:
counter++;
然后,线程B输出counter的值:
System.out.println(counter);
如果以上两条语句是在同一个线程中执行的,那么输出的结果自然是1。但是如果这两条语句是在两个不同的线程中,那么输出的结构有可能是0。这是因为没有保证线程A对counter的修改对线程B来说是可见的。除非程序员在这两条语句间建立了一定的“先后顺序”。
我们可以采取多种方式建立这种“先后顺序”。使用同步就是其中之一,这点我们将会在下面的小节中看到。
到目前为止,我们已经看到了两种建立这种“先后顺序”的方式:
- 当一条语句中调用了Thread.start()方法,那么每一条和该语句已经建立了“先后顺序”的语句都和新线程中的每一条语句有着这种“先后顺序”。引入并创建这个新线程的代码产生的结果对该新线程来说都是可见的。
- 当一个线即将程终止并调用了Thread.join方法来等待另外一个线程返回,那么此时这个即将终止的线程中执行过的所有语句都和随后的语句线程中的所有语句建立了这种“先后关系”。也就是说终止了的线程中的代码效果对调用join方法的线程来说是可见。
关于哪些操作可以建立这种“先后关系”,更多的信息请参阅“java.util.concurrent包的概要说明”。
同步方法
—————————————————————————————————————————————————————————————————————————————
Java编程语言中提供了两种基本的同步用语:同步方法和同步语句。同步语句相对而言更为复杂一些,我们将在下一小节中进行描述。本节重点讨论同步方法。
我们只需要在声明方法的时候增加关键字synchronized即可:
如果 count 是SynchronizedCounter类的实例,设置其方法为同步方法将有一下两个效果:
- 首先,不可能出现对同一对象的同步方法的两个调用的“交错”。当一个线程在执行一个对象的同步方式的时候,其他所有的调用该对象的同步方法的线程对会被挂起,直到第一个线程对该对象操作完毕。
- 其次,当一个同步方法退出时,会自动与该对象的后续同步方法间建立“先后顺序”的关系。这就确保了对该对象的修改对其他线程是可见的。
注意:构造函数不能为同步的——在构造函数前使用synchronized关键字将导致语义错误。同步构造函数是没有意义的。这是因为只有创建该对象的线程才能调用其构造函数。
————————————————————————————————————————————————————————————————————————————
警告:在创建多个线程共享的对象时,要特别小心对该对象的引用不能过早地“泄露”。例如,假定我们想要维护一个保存类的所有实例的列表instances。我们可能会在构造函数中这样写到:
instances.add(this);
但是,其他线程可会在该对象的构造完成之前就访问该对象。
————————————————————————————————————————————————————————————————————————————
同步方法是一种简单的可以避免线程相互干扰和内存一致性错误的策略:如果一个对象对多个线程都是可见的,那么所有对该对象的变量的读写都应该是通过同步方法完成的(一个例外就是final字段,他在对象创建完成后是不能被修改的,因此,在对象创建完毕后,可以通过非同步的方法对其进行安全的读取)。这种策略是有效的,但是可能导致“liveness”问题。这点我们会在本课程的后面进行描述。
内部锁及同步
—————————————————————————————————————————————————————————————————————————————
同步是构建在被称为“内部锁或者是监视锁”的内部实体上的。(在API中通常被称为是“监视器”。)内部锁在两个方面都扮演着重要的角色:保证对对象访问的排他性和建立也对象可见性相关的重要的“先后顺序”。
每一个对象都有一个与之相关联动的内部锁。按照传统的做法,当一个线程需要对一个对象的字段进行排他性访问并保持访问的一致性时,他必须在访问前先获取该对象的内部锁,然后才能访问之,最后释放该内部锁。在线程获取对象的内部锁到释放对象的内部锁的这段时间,我们说该线程拥有该对象的内部锁。只要有一个线程已经拥有了一个内部锁,其他线程就不能在拥有该锁了。其他线程将会在试图获取该锁的时候被阻塞了。
当一个线程释放了一个内部锁,那么就会建立起该动作和后续获取该锁之间的“先后顺序”。
同步方法中的锁
当一个线程调用一个同步方法的时候,他就自动地获得了该方法所属对象的内部锁,并在方法返回的时候释放该锁。即使是由于出现了没有被捕获的异常而导致方法返回,该锁也会被释放。
我们可能会感到疑惑:当调用一个静态的同步方法的时候会怎样了,静态方法是和类相关的,而不是和对象相关的? 在这种情况下,线程获取的是该类的类对象的内部锁。这样对于静态字段的方法是通过一个和类的实例的锁相区分的另外的锁来进行的。
同步语句
另外一种创建同步代码的方式就是使用同步语句。和同步方法不同,使用同步语句是必须指明是要使用哪个对象的内部锁:
在上面的示例中,方法addName需要对lastName和nameCount的修改进行同步,还要避免同步调用其他对象的方法(在同步代码段中调用其他对象的方法可能导致“Liveness”中描述的问题)。如果没有使用同步语句,那么将不得不使用一个单独的,未同步的方法来完成对nameList.add的调用。
在改善并发性时,巧妙地使用同步语句能起到很大的帮助作用。例如,我们假定类MsLunch有两个实例字段,c1和c2,这两个变量绝不会一起使用。所有对这两个变量的更新都需要进行同步。但是没有理由阻止对c1的更新和对c2的更新出现交错——这样做会创建不必要的阻塞,进而降低并发性。此时,我们没有使用同步方法或者使用和this相关的锁,而是创建了两个单独的对象来提供锁。
采用这种方式时需要特别的小心。我们必须绝对确保相关字段的访问交错是完全安全的。
同步的重入
回忆前面提到的:线程不能获取已经被别的线程获取的锁。单丝线程可以获取自身已经拥有的锁。允许一个线程能重复获得同一个锁就称为同步重入。它是这样的一种情况:在同步代码中直接或者间接地调用了还有同步代码的方法,两个同步代码段中使用的是同一个锁。如果没有同步重入,在编写同步代码时需要额外的小心,以避免线程将自己阻塞。
原子性
—————————————————————————————————————————————————————————————————————————————
在编程中,原子性动作就是指一次性有效完成的动作。原子性动作是不能在中间停止的:要么一次性完全执行完毕,要么就不执行。在动作没有执行完毕之前,是不会产生可见结果的。
通过前面的示例,我们已经发现了诸如c++这样的自增表达式并不属于原子操作。即使是非常见到的表达式也定义了负责的动作,这些动作可以被解释成许多别的动作。然而,的确存在一些原子操作的:
- 对几乎所有的原生数据类型变量的读写(除了long和都变了外)以及引用变量的读写都是原子的。
- 对所有声明为volatile的变量的读写都是原子的,包括long和double类型。
原子性动作是不会出现交错的,因此,使用这些原子性动作时不用考虑线程间的干扰。然而,这并不意味着可以移除对原子操作的同步。因为内存一致性错误还是有可能出现的。使用volatile变量可以减少内存一致性错误的风险,因为任何对volatile变量的写操作都和后续对该变量的读操作建立了“先后顺序”。这就意味着对volatile类型变量的修改对于别的线程来说是可见的。更重要的是,这意味着当一个线程读取一个volatile类型的变量是,他看到的不仅仅是对该变量的最后一次修改,还看到了导致这种修改的代码带来的其他影响。
使用简单的原子变量访问比通过同步代码来访问变量更高效,但是需要程序员的更多细心考虑,以避免内存一致性错误。这种额外的付出是否值得完全取决于应用程序的大小和复杂度。
在包java.util.concurrent中的一些类提供了原子方法,这些方法不依赖于同步。我们会在章节:High Level Concurrency Objects中进行讨论。
-
顶
- 9
-
踩
- 0
-
猜你在找
2楼 clean80 2015-07-20 20:49发表 [回复]-
-
已读。虽然有些还没看懂。但例题讲的不错,易懂。
1楼 Clinkz 2014-12-17 17:08发表 [回复]-
-
讲的不错!
Re: Mark马克 2014-12-26 11:21发表 [回复]-
-
回复Clinkz:感谢您的评价。欢迎继续浏览其他博文。