互斥机制synchronized学习

/**
* 互斥机制学习
* @author 蒙查查
* @date 2013-4-9
* **/
package com.test.sync;

import java.util.LinkedList;

import com.test.R;

import android.app.Activity;
import android.os.Bundle;
import android.util.Log;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;
import android.widget.SlidingDrawer;

public class MainActivity extends Activity{

Integer mutex = new Integer(-1); //互斥信号

LinkedList<String> list = new LinkedList<String>(); //模拟临界区

Button btn1, btn2;
boolean keepRun = true;

@Override
protected void onCreate(Bundle savedInstanceState) {
// TODO Auto-generated method stub
super.onCreate(savedInstanceState);
setContentView(R.layout.main);

btn1 = (Button) findViewById(R.id.btn1);

btn1.setOnClickListener(new OnClickListener() {

@Override
public void onClick(View v) {
// TODO Auto-generated method stub
keepRun = true;
new Thread(new Productor()).start();
new Thread(new CustomerThread()).start();
}
});

btn2 = (Button) findViewById(R.id.btn2);
btn2.setOnClickListener(new OnClickListener() {

@Override
public void onClick(View v) {
// TODO Auto-generated method stub
keepRun = false;
}
});
}

/**
* 模拟生产者
* */
class Productor implements Runnable {

@Override
public void run() {
// TODO Auto-generated method stub
while(keepRun) {
Log.i("Productor==", "");
try {
synchronized(mutex) {
Log.i("Productor==", "i get a lock");
if(list.size() > 10) {
//调用notify之后退出了synchronized块，即立刻释放了锁,wait()处将被唤醒
mutex.notify();
}
else {
double add = Math.random();
Log.i("Productor==", "add " + add);
list.add("" + add);
Thread.sleep(500);
}
}
} catch(Exception e) {
e.printStackTrace();
}
}
}

}

/**
* 模拟消费者
* */
class CustomerThread implements Runnable {

@Override
public void run() {
// TODO Auto-generated method stub
while(keepRun) {
Log.i("CustomerThread--","");
synchronized(mutex) {
Log.i("CustomerThread--","i get a lock");
try {
if(list.size() <= 0){
//当资源不足,消费者在等待,mutex.wait()让出CPU的使用权，并且释放了锁,当某处调用了mutex.notify()这里将被唤醒
mutex.wait();
}
else {
Log.i("CustomerThread--", ""+list.removeFirst());
}
} catch(Exception e) {
e.printStackTrace();
}
}
}
}

}
}

/**
* PS:
* wait()、notify()、notifyall()只能在synchronized块或方法中被调用，否则会抛异常。
* wait()不仅是让出了CPU的使用权，而且把持有的锁释放了。
* 分析上面的java代码：在调用mutex.wait()之前的若干步我们锁住了mutex；调用mutex.wait()让出CPU的使用权，并且释放了锁；
* 调用mutex.notify()之前先获得mutex上的锁，调用notify之后退出了synchronized块，即立刻释放了锁；这时wait()被唤醒，
* 它首先获得mutex上的锁，再执行下面的语句。
* */