方法一：传统的线程方法
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