方法一：传统的线程方法
import org.apache.log4j.Logger; /** * 两个线程执行的代码片段要实现同步互斥的效果，它们必须用同一个Lock对象。<br/> * 锁是上在代表要操作的资源的类的内部方法中，而不是线程代码中。<br/> * * 样例：<br/> * 1）、主线程执行10次循环，接着子线程执行100此循环；<br/> * 2）、重复1）操作50次，结束。<br/> * * @author wangzhu * @date 2015-3-21下午8:00:57 * */ public class ThreadCommunication { public static void main(String[] args) { final Bussiness bussiness = new Bussiness(); new Thread() { @Override public void run() { for (int i = 0; i < 50; i++) { bussiness.main(i); } }; }.start(); new Thread() { @Override public void run() { for (int i = 0; i < 50; i++) { bussiness.sub(i); } }; }.start(); } } class Bussiness { private static final Logger logger = Logger.getLogger(Bussiness.class); /** * true:主线程<br/> * false:子线程<br/> * 默认执行主线程<br/> */ private boolean mark = false; public synchronized void main(int c) { while (mark) { // 表示当前是主线程，则进入等待状态 try { this.wait(); } catch (InterruptedException e) { e.printStackTrace(); } } // 当不是主线程，则开始执行 for (int i = 0; i < 10; i++) { logger.info(c + "==main thread====" + i); } // 表示当前是主线程 mark = true; // 唤醒所有的线程 this.notifyAll(); } public synchronized void sub(int c) { while (!mark) { // 表示当前是子线程，则进入等待状态 try { this.wait(); } catch (InterruptedException e) { e.printStackTrace(); } } // 当不是子线程，则开始执行 for (int i = 0; i < 100; i++) { logger.info(c + "==sub thread====" + i); } // 表示当前是子线程 mark = false; // 唤醒所有的线程 this.notifyAll(); } }
2、JDK1.5之后（包括1.5）加入的并发包（Lock与Condition）
import java.util.concurrent.locks.Condition; import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; import org.apache.log4j.Logger; /** * 两个线程执行的代码片段要实现同步互斥的效果，它们必须用同一个Lock对象。<br/> * 锁是上在代表要操作的资源的类的内部方法中，而不是线程代码中。<br/> * * 样例：<br/> * 1）、主线程执行10次循环，接着子线程执行100此循环；<br/> * 2）、重复1）操作50次，结束。<br/> * * @author wangzhu * @date 2015-3-22下午9:50:11 * */ public class ConditionCommunication { private static final Logger logger = Logger .getLogger(ConditionCommunication.class); /** * @param args */ public static void main(String[] args) { final Bussiness bussiness = new Bussiness(); new Thread() { @Override public void run() { for (int i = 0; i < 50; i++) { bussiness.sub(i); } }; }.start(); new Thread() { @Override public void run() { for (int i = 0; i < 50; i++) { bussiness.main(i); } }; }.start(); } static class Bussiness { private Lock lock = new ReentrantLock(); private Condition condition = lock.newCondition(); /** * true:主线程<br/> * false:子线程<br/> */ private boolean mark; public void main(int k) { // 加锁 lock.lock(); try { while (mark) { // 当前是主线程，则等待 try { condition.await(); } catch (InterruptedException e) { e.printStackTrace(); } } for (int i = 0; i < 10; i++) { logger.info(k + "==main thread====" + i); } // 标记当前执行的是主线程 mark = true; // 发出信号 condition.signal(); } finally { // 释放锁 lock.unlock(); } } public void sub(int k) { // 加锁 lock.lock(); try { while (!mark) { try { condition.await(); } catch (InterruptedException e) { e.printStackTrace(); } } for (int i = 0; i < 100; i++) { logger.info(k + "==sub thread====" + i); } // 标记当前执行的是子线程 mark = false; // 发出信号 condition.signal(); } finally { // 释放锁 lock.unlock(); } } } }
JDK中的实例：
class BoundedBuffer { final Lock lock = new ReentrantLock();//锁对象 final Condition notFull = lock.newCondition();//写线程条件 final Condition notEmpty = lock.newCondition();//读线程条件 final Object[] items = new Object[100];//缓存队列 int putptr/*写索引*/, takeptr/*读索引*/, count/*队列中存在的数据个数*/; public void put(Object x) throws InterruptedException { lock.lock(); try { while (count == items.length)//如果队列满了 notFull.await();//阻塞写线程 items[putptr] = x;//赋值 if (++putptr == items.length){ putptr = 0;//如果写索引写到队列的最后一个位置了，那么置为0 } ++count;//个数++ notEmpty.signal();//唤醒读线程 } finally { lock.unlock(); } } public Object take() throws InterruptedException { lock.lock(); try { while (count == 0)//如果队列为空 notEmpty.await();//阻塞读线程 Object x = items[takeptr];//取值 if (++takeptr == items.length){ takeptr = 0;//如果读索引读到队列的最后一个位置了，那么置为0 } --count;//个数-- notFull.signal();//唤醒写线程 return x; } finally { lock.unlock(); } } }
参考：
http://blog.csdn.net/vking_wang/article/details/9952063
3、JDK1.5并发包中的阻塞队列（ArrayBlockingQueue）
import java.util.concurrent.ArrayBlockingQueue; import org.apache.log4j.Logger; /** * ArrayBlockingQueue(阻塞队列)<br/> * put(anObject):<br/> * 把anObject加到BlockingQueue里,如果BlockQueue没有空间,<br/> * 则调用此方法的线程被阻断,直到BlockingQueue里面有空间再继续.<br/> * * take():<br/> * 取走BlockingQueue里排在首位的对象,若BlockingQueue为空,<br/> * 阻断进入等待状态直到,BlockingQueue有新的数据被加入;<br/> * * @author wangzhu * @date 2015-3-23上午9:31:22 * */ public class ArrayBlockingQueueCommunication { private static final Logger logger = Logger .getLogger(ArrayBlockingQueueCommunication.class); /** * @param args */ public static void main(String[] args) { final Bussiness bussiness = new Bussiness(); new Thread() { @Override public void run() { for (int i = 0; i < 50; i++) { bussiness.sub(i); } }; }.start(); new Thread() { @Override public void run() { for (int i = 0; i < 50; i++) { bussiness.main(i); } }; }.start(); } static class Bussiness { // 阻塞队列 ArrayBlockingQueue<Integer> mainQuery = new ArrayBlockingQueue<Integer>( 1); ArrayBlockingQueue<Integer> subQuery = new ArrayBlockingQueue<Integer>( 1); { try { subQuery.put(1); } catch (InterruptedException e) { e.printStackTrace(); } } public void main(int k) { try { mainQuery.put(1); } catch (InterruptedException e) { e.printStackTrace(); } for (int i = 0; i < 10; i++) { logger.info(k + "==main thread====" + i); } try { subQuery.take(); } catch (InterruptedException e) { e.printStackTrace(); } } public void sub(int k) { try { subQuery.put(1); } catch (InterruptedException e) { e.printStackTrace(); } for (int i = 0; i < 100; i++) { logger.info(k + "==sub thread====" + i); } try { mainQuery.take(); } catch (InterruptedException e) { e.printStackTrace(); } } } }
参考：
http://www.cnblogs.com/jackyuj/archive/2010/11/24/1886553.html