互斥机制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上的锁，再执行下面的语句。
 * */