java线程同步

java线程之同步技术

基本概念：

竞态条件：多个线程试图同时访问同一个数据。

原子性：被认为是最小的，不可继续分割的物质单位，因此一个原子性的操作不能被中断，在实际程序中，原子性是指不能停留在中间状态的例程。java规范规定，除了double和long类型以外，对于其他类型的变量进行赋值的操作都是原子性的

一个经典的线程同步问题是ATM取款问题，如果检查账户状态和改变账户状态不是的，就会导致竞态条件。

互斥锁：许多线程系统都提供这种类型的锁作为一个同步的方法。功能是：同一个时间只能允许一个线程占有一个互斥体。

synchronized（同步化）方法：一个线程要执行该方法，就必须获得锁，获得后才能执行。当运行结束后，无论是正常返回还是因为异常返回，都会释放锁。

接下来，我们介绍下异步读取数据的实现。（异步读取数据是什么意思呢？可以理解为对同一个数据或者实例对象的多个方法操作时，使得这些方法都是异步（不可能同时有两个方法同时）进行。还是不理解的话，看例程代码。

package com.demo;

import java.io.DataInputStream;
import java.net.Socket;

public class AsyncReadSocket extends Thread{
private Socket s;
private StringBuffer result; //缓存数据存放

public AsyncReadSocket(Socket s){
this.s = s;
result = new StringBuffer();
}

public void run(){
DataInputStream is= null;
try{
is = new DataInputStream(s.getInputStream());
}catch(Exception e){

}
while(true){
try{
char c=is.readChar();
appendResult(c);
}catch(Exception e){

}
}
}

public synchronized String getResult(){
String retval = result.toString();
result = new StringBuffer();
return retval;
}

public synchronized void appendResult(char c){
result.append(c);
}
}

以上程序可能执行的时间顺序 如下图所示：



为什么当一个对象的两个方法都被定义为同步后，一个线程调用其中一个方法时，另一个线程对另一个方法的调用也会被阻塞呢？那是因为加锁其实通过对象加锁的机制来实现的。也就是说同一个对象被多个线程调用时，这两个方法是共享同一个对象锁的。言下之意，如果是不同的对象的方法调用，那就随意用啦。

锁的作用域：从锁被获取到其被释放的时间。

那么对于同步化的static method又是怎么运作的呢？

我们都知道取得锁是指“对象的锁”，一个static method 没有this引用的概念，我们引进了class lock的概念，但事实上却没有class lock的概念，只是为了让我们好理解。

作为程序员，可以这么理解：对每一个class只有一个thread可以执行synchronized static method，每个class的instance只有一个thread可以执行synchronized method。

synchronized能够达到对数据保护的要求，但是在更复杂的情况下，可能需要另一个通用的Lock这个interface。这个接口有lock（）和unlock（）这两个方法。使用方法是在method开始的时候调用lock（），并在结束的时候调用unlock（）方法。使用lock的类的好处在于，我们可以根据某个条件决定是否要是否锁，而且可以实现让两个对象共享同一个lock，同样，也可以让一个对象占有多个lock。

privateLock scoreLock = new ReentrantLock();

public interface Lock{
void lock();
void lockInterruptibly() throws InterruptedException;
boolean tryLock();
boolean tryLock(long time,TimeUnit unit) throws InterruptedException;

void unlock();
Condition newCondition();
}

trylock()与lock()不同的地方在于，假如没有取到锁的时候并不会等待，而是返回boolean，同时也可以有参数来设定等待的时间长度。

接下来我们介绍下嵌套锁（nested lock）

嵌套锁：可以理解为一个加锁的方法调用另一个加锁的方法。

         这种机制可以运行是因为java进入synchronized方法时，假如当前的thread已经占有lock，那么没有等到lock被释放掉，或者获取lock，而是直接运行。系统会保持追踪递归取得lock的数目，最后再第一个取得lock的method（或块）退出时将lock释放掉。

         java对这种机制的支持非常重要，因为相互调用和回调在java的核心函数库中运用得非常广泛。