【Java性能调优】之设计优化（三）

public static void main(String[] args){
    Client client=new Client();
    
    Data data=client.request("name");//这里会立即返回，因为得到的是FutureData，而不是RealData
    System.out.println("请求完毕");
    
    try{
        Thread.sleep(2000);//模拟耗时处理其他业务操作
    }catch(InterruptedException e){
    }
    
    System.out.println(data.getResult());//使用真实数据
}

public class Client{
    public Data request(final String queryStr){
        new Thread(){
            public void run(){
                RealData readdata=new RealData(queryStr);
                future.setRealData(realdata);
            }
        }.start();
        return future;
    }
}

public interface Data{
    public String getResult();
}

public class FutureDataa implements Data{
    protected RealData realdata=null;
    protected boolean isReady=false;
    
    public synchronized void setRealData(RealData realdata){
        if(isReady){
            return;
        }
        this.realData=realdata;
        isReady=true;
        notifyAll();
    }
    public synchronized String getResult(){
        while(!isReady){
            try{
                wait();  //一直等待，知道RealData被注入
            }catch(InterruptedException e){}
        }    
        return realdata.result;
    }
}

• 声明为volatile的变量，当啊其他线程对变量的修改会即时地反应在当前线程中
• 确保当前线程对volatile变量的修改，能即时写回共享内存中，并被其他线程所见
• 使用volatile声明的变量，编译器会保证其有序性

• 公平锁保证在锁的等待队列中各个线程是公平的，不存在插队情况，对锁的获取总是先进先出。
• 非公平锁申请锁的先出可能插队，非公平锁的性能要好得多。因此若无特殊需要，应该优先选择非公平锁。
• 使用重入锁，要做程序最后释放锁，一般写在finally里，否则程序出现异常，重入锁就无法释放了。

• 互斥条件：一个资源每次只能被一个进程使用
• 请求与保持条件：一个进程因请求资源而被阻塞时，对已获得的资源保持不放
• 不剥夺条件：进程已获得资源，在未使用完之前，不能强行剥夺
• 循环等待条件：若干线程之间形成一种头尾相接的循环等待资源关系

public synchronized void syncMethod(){
    othercode1();
    mutextMethod();    //只有改方法有同步需求
    othercode2();
}

//优化代码如下：
public void synchMethod2(){
    othercode1();
    synchronized(this){
        mutexMethod();    //只对有需求的方法同步
    }
    othercode2();
}

private final ReentrantLock takeLock=new ReentrantLock(); //take()函数需要持有takeLock

private final Condition notEmpty=takeLock.newCondition();

private final ReentrantLock putLock=new ReentrantLock();  //put()函数需要持有putLock

private final Condition notFull=putLock.newCondition();

public void demoMethod(){
    synchronized(lock){
        //do sth.
    }
}
synchronized(lock){
    //do sth.
    //做其他不需要同步的工作，但很快执行完毕
}


//整合后
public void demoMethod(){
    //整合锁
    synchronized(lock){
        //do sth.
        //做其他不需要的同步工作，但能和快执行完毕
    }
}

public final int get();  //取得当前值
public final void set(int newValue)  //设置当前值
public final int getAndSet(int newValue) //设置新值并返回旧值