多线程——同步（synchronized）下

接着上一讲《多线程——同步（synchronized）上》

 

上一讲中说到的第二个例子，通过synchronized块，指定获取对象锁来达到同步的目的。那有没有其它的方法，可以通过synchronized方法来实现呢？

 

根据同步的原理：如果能获取一个共享对象锁或类锁，及可实现同步。那么我们是不是可以通过共享一个类锁来实现呢？

 

是的，我们可以使用静态同步方法，根据静态方法的特性，它只允许类对象本身才可以调用，不能通过实例化一个类对象来调用。那么如果获得了这个静态方法的锁，也就是获得这个类锁，而这个类锁都是TestThread类锁，及达到了获取共享类锁的目的。

 

实现代码如下：

package thread_test;

/**
 * 测试扩展Thread类实现的多线程程序 
 * 
 * @author ciding 
 * @createTime Dec 7, 2011 9:37:25 AM
 *
 */
public class TestThread extends Thread{ 
	private int threadnum;
	
	public TestThread(int threadnum) { 
        this.threadnum = threadnum; 
    }
	
    public static synchronized void staticTest(int threadnum) { 
		for(int i = 0;i<1000;i++){ 
            System.out.println("NO." + threadnum + ":" + i );
        } 
    } 

    public static void main(String[] args) throws Exception { 
    	for(int i=0; i<10; i++){
        	new TestThread(i).start();
        	Thread.sleep(1);
    	}
    } 
    
    @Override
    public void run(){
    	staticTest(threadnum);
    }
}

 运行结果略，与例二中一样。

 

 

以上的内容主要是说明两个问题：同步块与同步方法。

1，同步块：获取的对象锁是synchronized(flag)中的flag对象锁。

2，同步方法：获取的是方法所属的类对象，及类对象锁。

     静态同步方法，由于多个线程都会共享，所以一定会同步。

     而非静态同步方法，只有在单例模式下才会同步。

 

 

接下来说一说能在synchronized内部运行的wait方法、notify方法与notifyAll方法。

先看一段JDK API 1.6 文档的原话：

JDK API 1.6 文档 java.lang.Object类中的wait()方法：

wait
public final void wait()
throws InterruptedException在其他线程调用此对象的 notify() 方法或 notifyAll() 方法前，导致当前线程等待。换句话说，此方法的行为就好像它仅执行 wait(0) 调用一样。
当前线程必须拥有此对象监视器。该线程发布对此监视器的所有权并等待，直到其他线程通过调用 notify 方法，或 notifyAll 方法通知在此对象的监视器上等待的线程醒来。然后该线程将等到重新获得对监视器的所有权后才能继续执行。

对于某一个参数的版本，实现中断和虚假唤醒是可能的，而且此方法应始终在循环中使用：

synchronized (obj) {
while (<condition does not hold>)
obj.wait();
... // Perform action appropriate to condition
}
此方法只应由作为此对象监视器的所有者的线程来调用。有关线程能够成为监视器所有者的方法的描述，请参阅 notify 方法。

抛出：
IllegalMonitorStateException - 如果当前线程不是此对象监视器的所有者。
InterruptedException - 如果在当前线程等待通知之前或者正在等待通知时，任何线程中断了当前线程。在抛出此异常时，当前线程的中断状态 被清除。
另请参见：
notify(), notifyAll()

 

JDK API 1.6 文档 java.lang.Object类中的notify()方法:

notify
public final void notify()

唤醒在此对象监视器上等待的单个线程。如果所有线程都在此对象上等待，则会选择唤醒其中一个线程。选择是任意性的，并在对实现做出决定时发生。线程通过调用其中一个 wait 方法，在对象的监视器上等待。

直到当前线程放弃此对象上的锁定，才能继续执行被唤醒的线程。被唤醒的线程将以常规方式与在该对象上主动同步的其他所有线程进行竞争；例如，唤醒的线程在作为锁定此对象的下一个线程方面没有可靠的特权或劣势。

此方法只应由作为此对象监视器的所有者的线程来调用。通过以下三种方法之一，线程可以成为此对象监视器的所有者：

通过执行此对象的同步实例方法。
通过执行在此对象上进行同步的 synchronized 语句的正文。
对于 Class 类型的对象，可以通过执行该类的同步静态方法。
一次只能有一个线程拥有对象的监视器。


抛出：
IllegalMonitorStateException - 如果当前线程不是此对象监视器的所有者。
另请参见：
notifyAll(), wait()

 

JDK API 1.6 文档 java.lang.Object类中的notifyAll()方法:

notifyAll
public final void notifyAll() 

唤醒在此对象监视器上等待的所有线程。线程通过调用其中一个 wait 方法，在对象的监视器上等待。

直到当前线程放弃此对象上的锁定，才能继续执行被唤醒的线程。被唤醒的线程将以常规方式与在该对象上主动同步的其他所有线程进行竞争；例如，唤醒的线程在作为锁定此对象的下一个线程方面没有可靠的特权或劣势。

此方法只应由作为此对象监视器的所有者的线程来调用。有关线程能够成为监视器所有者的方法的描述，请参阅 notify 方法。


抛出：
IllegalMonitorStateException - 如果当前线程不是此对象监视器的所有者。
另请参见：
notify(), wait()

 

根据synchronized能够获取对象锁，及获取对象监视器，所以这几个方法在同步中利用也是天衣无缝。

 

本来打算在线程最后的章节来实现生产者消费者模式的，这里就先实现个简单的试试水；好让童鞋们更顺水的了解这三个方法的使用。

 

例子1

package thread;

/**
 * main主函数
 * 
 * @author ciding 
 * @createTime Dec 12, 2011 3:05:44 PM
 *
 */
public class ConsumerAndProducerThread {
	public static void main(String[] args) {
		Storage storage = new Storage(40,100);
		
		/**
		 * 一共消费了60+61+62+63+64=310
		 */
		for(int i=0; i<5; i++){
			Consumer c = new Consumer(60+i, storage);
			c.start();
		}
		
		/**
		 * 一共生产了10+20+30+40+15+25+35+45+49+51=320 再加上初始化的40 一共360
		 */
		Producer p1 = new Producer(10,storage);		//生产10
		Producer p2 = new Producer(20,storage);		//生产20
		Producer p3 = new Producer(30,storage);		//生产30
		Producer p4 = new Producer(40,storage);		//生产40
		Producer p5 = new Producer(15,storage);		//生产15
		Producer p6 = new Producer(25,storage);		//生产25
		Producer p7 = new Producer(35,storage);		//生产35
		Producer p8 = new Producer(45,storage);		//生产45
		Producer p9 = new Producer(49,storage);		//生产49
		Producer p10 = new Producer(51,storage);	//生产51
		
		p1.start();
		p2.start();
		p3.start();
		p4.start();
		p5.start();
		p6.start();
		p7.start();
		p8.start();
		p9.start();
		p10.start();
	}
}

/**
 * 生产者
 * 
 * @author ciding 
 * @createTime Dec 12, 2011 3:05:35 PM
 *
 */
class Consumer extends Thread {
	private int neednum; 		// 生产产品的数量
	private Storage storage; 	// 仓库

	Consumer(int neednum, Storage storage) {
		this.neednum = neednum;
		this.storage = storage;
	}

	public void run() {
		storage.consume(neednum);// 消费指定数量的产品
	}
}

/**
 * 消费者
 * 
 * @author ciding 
 * @createTime Dec 12, 2011 3:06:03 PM
 *
 */
class Producer extends Thread {
	private int neednum; 		// 生产产品的数量
	private Storage storage; 	// 仓库

	Producer(int neednum, Storage storage) {
		this.neednum = neednum;
		this.storage = storage;
	}

	public void run() {
		storage.produce(neednum);	// 生产指定数量的产品
	}
}

/**
 * 仓库
 * 
 * @author ciding 
 * @createTime Dec 12, 2011 3:06:31 PM
 *
 */
class Storage {
	public int max_size = 100;	// 库存量初始值
	public int curnum = 0;		// 当前库存量初始值

	Storage() {
	}

	Storage(int curnum, int max_size) {
		this.curnum = curnum;
		this.max_size = max_size;
	}

	/**
	 * 生产指定数量的产品
	 * 
	 * @param neednum
	 */
	public synchronized void produce(int neednum) {
		/* 测试是否需要生产 */
		while (neednum + curnum > max_size) {
			try {
				Thread.sleep(100);	//模拟运行时间
				
				System.out.println("要生产的产品数量" + neednum + "超过剩余库存量"
					+ (max_size - curnum) + "，暂时不能执行生产任务!");
				wait();		// 当前的生产线程等待
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		
		curnum += neednum; // 满足生产条件，则进行生产，这里简单的更改当前库存量
		System.out.println("已经生产了" + neednum + "个产品，现仓储量为" + curnum);

		notify(); // 唤醒在此对象监视器上等待的某个线程			
	}

	/**
	 * 消费指定数量的产品
	 * 
	 * @param neednum
	 */
	public synchronized void consume(int neednum) {
		// 测试是否可消费
		while (curnum < neednum) {
			try {
				Thread.sleep(100);//模拟运行时间

				System.out.println("仓储量为:" + curnum + "，不够消费:" + neednum);
				wait();// 当前的生产线程等待
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		curnum -= neednum; // 满足消费条件，则进行消费，这里简单的更改当前库存量
		System.out.println("已经消费了" + neednum + "个产品，现仓储量为" + curnum);

		notify(); // 唤醒在此对象监视器上等待的某个线程
	}
}

 

运行结果：

仓储量为:40，不够消费:60
已经生产了51个产品，现仓储量为91
要生产的产品数量49超过剩余库存量9，暂时不能执行生产任务!
要生产的产品数量45超过剩余库存量9，暂时不能执行生产任务!
要生产的产品数量35超过剩余库存量9，暂时不能执行生产任务!
要生产的产品数量25超过剩余库存量9，暂时不能执行生产任务!
要生产的产品数量15超过剩余库存量9，暂时不能执行生产任务!
要生产的产品数量40超过剩余库存量9，暂时不能执行生产任务!
要生产的产品数量30超过剩余库存量9，暂时不能执行生产任务!
要生产的产品数量20超过剩余库存量9，暂时不能执行生产任务!
要生产的产品数量10超过剩余库存量9，暂时不能执行生产任务!
已经消费了64个产品，现仓储量为27
仓储量为:27，不够消费:63
仓储量为:27，不够消费:62
仓储量为:27，不够消费:61
已经生产了49个产品，现仓储量为76
已经消费了60个产品，现仓储量为16
已经生产了35个产品，现仓储量为51
已经生产了25个产品，现仓储量为76
已经生产了15个产品，现仓储量为91
要生产的产品数量40超过剩余库存量9，暂时不能执行生产任务!
要生产的产品数量45超过剩余库存量9，暂时不能执行生产任务!

线程没有关闭，一直还在wait。

 

细心的童鞋，应该已经看出问题的所在，在调用wait后，程序是通过调用notify()方法来唤醒在此对象监视器上等待的某个线程。

 

另外，根据输出的结果，我们来分析一个wait()与notify()的调用。

a为能运行的生产者 a=10

b为能运行的消费者 b=5

 

0：调用消费者，不成功，等待。（a=10,b=4）

1：调用了生产者，成功，唤醒了一个生产者/消费者。(a=1,b=5)

2：调用了10个生产，其中9个等待。(a=0,b=5)

3：调用一个消费，成功，然后调用notify()唤醒一个生产。(a=1,b=4)

4：连着调用三个消费，不成功，等待。(a=1,b=1)

5：调用唤醒的那个生产者，生产，成功，唤醒了一个生产者/消费者。(a=1,b=1)或略

6：调用消费者，成功，唤醒了一个生产者/消费者。(a=2,b=0)或略

7：调用唤醒的那个生产者，生产，成功，唤醒了一个生产者/消费者。(a=2,b=0)或略

8：调用唤醒的那个生产者，生产，成功，唤醒了一个生产者/消费者。(a=2,b=0)或略

9：调用唤醒的那个生产者，生产，成功，唤醒了一个生产者/消费者。(a=2,b=0)或略

10：调用唤醒的那个生产者，不成功，等待。(a=1,b=0)或略

11：调用唤醒的那个生产者，不成功，等待。(a=0,b=0)或略

 

到此，可运行的线程为0，都在等待状态。

因为两个程序等待的对象都是curnum（产品量），所以唤醒的线程可能是生产者也可能是消费者。

 

如果将程序中的notify()方法换成notifyAll()方法，及可实现简单的生产者消费者。

那是不是两个notify()方法都要换呢？

这一点，就留给童鞋们自己思考了，如果你已经把上面的内容仔细阅读，相信你会懂的其中的原理。

 

关于同步的话题，对于synchronized的解讲，就先告一段落了。接下来的章节将从JDK 1.5及以上版本提供的Lock进行解读。

 

 

 

Java多线程及线程池专题 汇总http://ciding.iteye.com/blog/1300110

评论

2 楼 operthing 2012-04-17  

operthing 写道

1 楼 operthing 2012-04-17