java线程同步初探

        线程是任何程序中都存在的相对独立的一段小程序。每个进程（程序）中都会含有许许多多的线程。少则只有一个多则成千上万。就例如一个班级，每个独立的人就是一个线程，他们既有自己独立的行为方式，也拥有共同的共享资源（教师，公告等等）。所以当很多学生同时阅读一份报告或者询问一个老师的时候就会有出现冲突。这时候就要有规矩，最简单的规矩就是排队。程序中也一样，不同的线程同时访问一片公有内存时，这种冲突无法避免。当然，如果是简单的阅读（只读）不会发生问题，但如果是修改其内容则就会出现悲剧。可以想象，当一个线程正在修改内存时另一个线程进入读取内容，显然会出现错误。这里用一个简单的例子来表示，现在火车的订票系统。

当一个用户查询余票时，发现还有票。准备购买，但购买的时间较长，票的数量还没有减少。此时，另一个用户查询余票，发现还有一张。但是在购买的时候，那张票已经被上一个用户购买了，实际上已经没有票了。这时就出现了错误。用一段代码来实现：

package 线程同步问题;

public class MyMain {	
	static int x=5; //总票数
	static final Object lock=new Object();
	public static void main(String[] args) {
		MyMain main=new MyMain();
		main.create();
	}
	public void create(){
		//5个人同时买票
		for(int i=1;i<=5;i++){
			TestThread tt=new TestThread(i);		
			tt.start();			
		}
	}
	//买票
	public static boolean buy(){
		//用于检查当前票数量是否符合规定
			if(x>0){
				System.out.println("购票成功");
				x--;
				return true;
			}else {
				return false;
			}
	}
	//线程，用来买票
	class TestThread extends Thread{
		int i;
		public TestThread(int i){
			this.i=i;
		}
		public void run(){
			boolean b=true;
			while(b){					
					b=MyMain.buy();
					System.out.println("第"+i+"个人购买后剩余="+MyMain.x);
				
			}
		}
	}
	
}

 结果：

     票的数量出现了负数，很明显，出现了上述错误。为了解决这个问题，我们就需要线程同步机制。说是同步，其实正相反，就是让线程排队。什么时候排队呢?当他们要同时使用（修改）一块内存时。我们使用关键字synchronize。一把锁。格式如下synchronize（object）{ …… }

至于括号里的object就是这把锁的钥匙，可以使任何的object reference都可以当做钥匙。因为钥匙只是这个对象所对应的内存地址。只有当你得到了这片内存空间，你才能打开这把锁，执行锁中的代码。测试将上述代码修改为同步，如下：

//买票
	public static boolean buy(){
		synchronized(lock){
		//用于检查当前票数量是否符合规定
			if(x>0){
				System.out.println("购票成功");
				x--;
				return true;
			}else {
				return false;
			}
		}
	}

结果如下，可以明显的看出同步问题已解决：

       有些时候我们不一定只需要一把锁，因为有不同的线程访问不同的空间，发生同的冲突。我们就需要几把锁，把相应的需要进行同步的代码块进行相应的同步。例如

synchronize(lock1){ 代码1访问内存1   }  

synchronize(lock1){ 代码2访问内存1   }  

synchronize(lock2){ 代码3访问内存2   }   

synchronize(lock2){ 代码4访问内存2   }

这样来区分不同的锁与钥匙。

    这种同步模型只是最简单的模型，其实还有许多复杂的模型，这里就先介绍一下生产/消费者模型。其中也是用到了这种同步机制，但有了一个小小的改动，就是加入了wait/notify的使用。Wait与notify一个是等待通知，一个是发出通知。就是通过上述的“钥匙”调用wait方法进入等待队列Wait中，不执行后续代码。当有其他线程启用了notify的时候才继续执行。

等待通知：

synchronize(lock){

  lock.wait    放弃这个钥匙，使这个线程进入等待

   ……

}

这里的等待其实就是阻塞了这个线程。下面为测试代码

 

package 线程同步问题2;

public class MyMain {

	/**
	 * @param args
	 */
	static int x=0;
	static Object lock=new Object();
	public static void main(String[] args) {
		TestThread test1=new TestThread();
		TestThread2 test2=new TestThread2();
		TestThread3 test3=new TestThread3();
		test1.start();
		System.out.println("执行");
		test2.start();
		test3.start();
	}
	
	public static void add(){
		synchronized (lock) {
			try {
				lock.wait();
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			x++;
			System.out.println("add方法执行");
		}
		
	}
	
	public static void add2(){
		synchronized (lock) {
			try {
				lock.wait();
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			x++;
			System.out.println("add2方法执行");
		}
		
	}
	
	public static void add3(){
		synchronized (lock) {
			lock.notify();
			System.out.println("add3方法执行");
		}
		
	}
}

 

 

package 线程同步问题2;

public class TestThread3 extends Thread{
	int count=0;
	public void run(){
		while(true){
			count++;
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			System.out.println("count="+count);
			if(count%5==0){
				MyMain.add3();
			}
		}
	}
	
}

 

package 线程同步问题2;

public class TestThread2 extends Thread{
	
	public void run(){
		while(true){
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			MyMain.add2();
			
		}
	}
}

 

package 线程同步问题2;

public class TestThread extends Thread{
	public void run(){
		while(true){
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			MyMain.add();
		}
	}
	
}

 测试结果如下：

 有此结果可得出如下结论：

1.当一个线程放弃钥匙进入等待时，其他线程可以获取钥匙执行代码。

2.进入等待的线程会在等待队列中排队等待通知。

3.当一个线程发出notify通知时，在等待队列中的靠前的代码会先执行，并且只执行一个。其他的继续等待通知。

4.发出通知这一举动不会影响本线程的执行。

ps：notigyAll可以通知全部线程。  

ps2：wait()中可以加入等待时间，时间已到则无需通知直接进入执行队列ready。

ps3：获取到通知或者时间到后（即已进入执行队列中ready），仍需要先竞争到钥匙才可以继续执行代码。

本次的同步问题暂时就先说到这里，如果再有其他心得会继续更新。。。