多线程---批量线程同步模型

在一批线程处理程序中，有时必须等到所有线程全部运行完后，才能进行下一步任务处理，
可以采用如下方法解决，创建一个锁对象 ，该锁对象提供一个当前线程等待其他线程的方法。见代码：

/**
 * 
 * 此类主要用来处理线程的同步屏蔽模型，比如，一批线程运行，必须在最后一个线程运行
 * 完后，才能进行下一步的操作，那么就可以创建一个锁对象，锁对象提供一个线程等待其他线程
 * 的方法，如果当前线程运行时，还有未运行的线程，则此线程wait，否则，此线程唤醒其他阻塞的
 * 线程，进而最终完成线程的运行
 * */
public class LockObject {

	private int totalThread = 0;
	private int currentThread = 0;

	public LockObject(int totalThread) {
		this.totalThread = totalThread;
		this.currentThread = 1;
	}

	public synchronized void waitForOtherThread() {
		if (this.currentThread < this.totalThread) {
			this.currentThread++;
			try {
				this.wait();
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		} else {
			this.currentThread = 1;
			notifyAll();
		}
	}

	public int getTotalThread() {
		return totalThread;
	}

	public void setTotalThread(int totalThread) {
		this.totalThread = totalThread;
	}

	public int getCurrentThread() {
		return currentThread;
	}

	public void setCurrentThread(int currentThread) {
		this.currentThread = currentThread;
	}
}

此对象提供 二个私有变量，totalThread 的初始值为所运行的线程的总数，currentThread 为当前正在运行的线程数。

线程运行时处理完自己的任务后调用方法waitForOtherThread 等待其他线程结束，即当前运行线程数与线程总数的比较

如果运行线程数小于线程总数，则当前运行线程数+1 后，当前线程进入等待状态，否则，唤醒其他等待线程。

 见测试程序

public class MyThread extends Thread {
	public static LockObject lo = new LockObject(1000);

	public MyThread(String threadName) {
		super(threadName);
	}

	public void run() {
			System.out.println(Thread.currentThread().getName() + " ----开始运行");
			lo.waitForOtherThread();
			System.out.println(Thread.currentThread().getName() + " ----结束运行");
	}

	public static void main(String[] args) {
		for (int i = 1; i <= 1000; i++) {
			Thread thread = new MyThread("第" + i + "个线程");
			thread.setPriority(NORM_PRIORITY);
			thread.start();
		}
	}

}

 。。。。。。。。初次发帖，如有不妥，欢迎拍砖!

评论

8 楼 tianshiyeben 2009-09-17  

学习了    楼主强啊  

7 楼 kind790 2009-09-16  

CountDownLatch  or CyclicBarrier

6 楼 xuyan2680 2009-09-15  

anson2003 写道

很简单的事情:

List<Thread> threadList = new LinkedList<Thread>();
for(int i=0;i<1000;i++){
   Thread t = new MyThread();
   threadList.add(t);
   t.start();
}

for(Thread t : threadList){
    try{
         t.join();
    }catch (InterruptedException e) {  
    }

}

学习嘛，究其原!

5 楼 anson2003 2009-09-15  

很简单的事情:

List<Thread> threadList = new LinkedList<Thread>();
for(int i=0;i<1000;i++){
   Thread t = new MyThread();
   threadList.add(t);
   t.start();
}

for(Thread t : threadList){
    try{
         t.join();
    }catch (InterruptedException e) {  
    }

}

4 楼 xuyan2680 2009-09-15  

多谢大家光顾!

3 楼 only_java 2009-09-15  

不错，简单明了!

2 楼 xuyan2680 2009-09-14  

liangguanhui 写道

在Java1.5，直接用线程池，然后awaitTerminate，不是更加方便？

呵呵，确实是方便些，来一下模拟实现，会理解的更深些。

1 楼 liangguanhui 2009-09-14  

在Java1.5，直接用线程池，然后awaitTerminate，不是更加方便？