“生产者-消费者”实验
<!-- 附上依赖包配置 --> <dependency> <groupId>com.lmax</groupId> <artifactId>disruptor</artifactId> <version>3.0.1</version> </dependency> <dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java</artifactId> <version>5.1.30</version> </dependency>
参考：http://blog.csdn.net/ghsau/article/details/7481142
package thread;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.CountDownLatch;
public class WaitTest {
/**
* 容器的最大长度
*/
private static final int listSize = 3;
/**
* 容器
*/
private static List<String> list = new ArrayList<String>(listSize);
static class ProducerThread extends Thread {
/**
* 生产者的id
*/
private int proId;
/**
* 当这个生产者结束后，这个值降1，表明生产者数量减少了一个
*/
private CountDownLatch proCount;
public ProducerThread(int proId, CountDownLatch proCount) {
this.proId = proId;
this.proCount = proCount;
}
@Override
public void run() {
int time = 0;
while (time < 5) {
synchronized (list) {
while (list.size() >= listSize) { // 标记A1
try {
System.out.println("**** producer proId=" + proId
+ ": wait begin, time=" + time + " list.size=" + list.size());
list.wait();
System.out.println("**** producer proId=" + proId
+ ": wait finish, time=" + time + " list.size=" + list.size());
} catch (InterruptedException e) {
e.printStackTrace();
}
}
list.add(time++ + ":" + proId);
System.out.println("------------- pro " + proId + " add ----------------");
list.notifyAll(); // 当有多个生产者时，这里会唤醒其他生产者，因此在标记A1处要用while，而不能是if
}
}
System.out.println("producer proId=" + proId + ": end");
proCount.countDown();
}
}
static class ComsumerThread extends Thread {
/**
* 消费者id
*/
private int comId;
/**
* 当这个生产者结束后，这个值降1，表明生产者数量减少了一个
*/
private CountDownLatch proCount;
public ComsumerThread(int comsumerId, CountDownLatch proCount) {
this.comId = comsumerId;
this.proCount = proCount;
}
@Override
public void run() {
while (true) {
if (proCount.getCount() == 0) {
return;
}
synchronized (list) {
while (list.size() == 0) { // 标记B1
if (proCount.getCount() == 0) {
return;
}
try {
System.out.println("##### consumer comId=" + comId
+ ", wait begin, list.size=" + list.size());
list.wait();
System.out.println("##### consumer comId=" + comId
+ ", wait end, list.size=" + list.size());
} catch (InterruptedException e) {
e.printStackTrace();
}
}
String firstItem = list.remove(0);
System.out.println("消费一个：" + firstItem + ", list.size=" + list.size());
list.notifyAll(); // 当有多个消费者时，这个notify会唤醒其他消费者，因此在标记B1处要用while，而不能是if
}
}
}
}
public static void main(String[] args) {
final int proCount = 10; // 生产者的数量
final int comCount = 10; // 消费者的数量
CountDownLatch countDown = new CountDownLatch(proCount);
System.out.println("========================================================");
for (int nLoop = 0; nLoop < proCount; ++nLoop) {
new ProducerThread(nLoop, countDown).start();
}
for (int nLoop = 0; nLoop < comCount; ++nLoop) {
new ComsumerThread(nLoop, countDown).start();
}
}
}
改进版，用await/signal/signallAll还执行
package thread;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;
public class WaitTest {
/**
* 容器的最大长度
*/
private static final int listSize = 3;
/**
* 容器
*/
private static List<String> list = new ArrayList<String>(listSize);
private static ReentrantLock lock = new ReentrantLock();
private static Condition notFull = lock.newCondition();
private static Condition notEmpty = lock.newCondition();
static class ProducerThread extends Thread {
/**
* 生产者的id
*/
private int proId;
/**
* 当这个生产者结束后，这个值降1，表明生产者数量减少了一个
*/
private CountDownLatch proCount;
public ProducerThread(int proId, CountDownLatch proCount) {
this.proId = proId;
this.proCount = proCount;
}
@Override
public void run() {
int time = 0;
while (time < 5) {
/// synchronized (list) {
lock.lock();
try {
while (list.size() >= listSize) { // 标记A1
try {
System.out.println("**** producer proId=" + proId
+ ": wait begin, time=" + time + " list.size=" + list.size());
/// list.wait();
notFull.await();
System.out.println("**** producer proId=" + proId
+ ": wait finish, time=" + time + " list.size=" + list.size());
} catch (Exception e) {
e.printStackTrace();
}
}
list.add(time++ + ":" + proId);
notEmpty.signalAll();
System.out.println("------------- pro " + proId + " add ----------------");
/// list.notifyAll(); // 当有多个生产者时，这里会唤醒其他生产者，因此在标记A1处要用while，而不能是if
} finally {
lock.unlock();
}
/// }
}
System.out.println("producer proId=" + proId + ": end");
proCount.countDown();
// 确保那些还在阻塞的消费者被signal
lock.lock();
try {
notEmpty.signalAll();
} finally {
lock.unlock();
}
}
}
static class ComsumerThread extends Thread {
/**
* 消费者id
*/
private int comId;
/**
* 当这个生产者结束后，这个值降1，表明生产者数量减少了一个
*/
private CountDownLatch proCount;
public ComsumerThread(int comsumerId, CountDownLatch proCount) {
this.comId = comsumerId;
this.proCount = proCount;
}
@Override
public void run() {
while (true) {
if (proCount.getCount() == 0) {
return;
}
/// synchronized (list) {
lock.lock();
try {
while (list.size() == 0) { // 标记B1
if (proCount.getCount() == 0) {
System.out.println("comsumer " + comId + " return.");
return;
}
try {
System.out.println("##### consumer comId=" + comId
+ ", wait begin, list.size=" + list.size() + ", proCount=" + proCount.getCount());
/// list.wait();
notEmpty.await();
System.out.println("##### consumer comId=" + comId
+ ", wait end, list.size=" + list.size() + ", proCount=" + proCount.getCount());
} catch (InterruptedException e) {
e.printStackTrace();
}
}
String firstItem = list.remove(0);
System.out.println("消费一个：" + firstItem + ", list.size=" + list.size());
notFull.signal();
/// list.notifyAll(); // 当有多个消费者时，这个notify会唤醒其他消费者，因此在标记B1处要用while，而不能是if
} finally {
lock.unlock();
}
/// }
}
}
}
public static void main(String[] args) {
final int proCount = 10; // 生产者的数量
final int comCount = 20; // 消费者的数量
CountDownLatch countDown = new CountDownLatch(proCount);
System.out.println("========================================================");
for (int nLoop = 0; nLoop < proCount; ++nLoop) {
ProducerThread producerThread = new ProducerThread(nLoop, countDown);
producerThread.setPriority(Thread.MIN_PRIORITY);
producerThread.start();
}
for (int nLoop = 0; nLoop < comCount; ++nLoop) {
ComsumerThread comsumerThread = new ComsumerThread(nLoop, countDown);
comsumerThread.setPriority(Thread.MAX_PRIORITY);
comsumerThread.start();
}
}
}
用disruptor的一个例子，目前仅仅是写出例子了，还没仔细研究
package disruptor.dbreadwrite;
import java.sql.CallableStatement;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.sql.Statement;
import java.sql.Types;
import java.util.concurrent.Executors;
import com.lmax.disruptor.EventFactory;
import com.lmax.disruptor.EventHandler;
import com.lmax.disruptor.RingBuffer;
import com.lmax.disruptor.dsl.Disruptor;
import com.lmax.disruptor.dsl.EventHandlerGroup;
class RowEvent {
private long id;
public long getId() {
return id;
}
public void setId(long id) {
this.id = id;
}
}
/**
* disruptor的测试类
* 参考：https://github.com/LMAX-Exchange/disruptor/wiki/Getting-Started
* http://lavasoft.blog.51cto.com/62575/238613
*
* 简介：生产者不断往表里写入记录，消费者不断从表里删除记录
* @author Longli
* @since 2014-6-3 17:48:49
*/
public class LongliTestMain {
static Connection con = null;
static {
try {
Class.forName("com.mysql.jdbc.Driver");
String url = "jdbc:mysql://localhost:4050/test?charactorEncoding=utf-8";
con = DriverManager.getConnection(url , "root", "123456");
} catch (Throwable e) {
e.printStackTrace();
System.exit(1);
}
}
@SuppressWarnings({ "unchecked", "unused" })
public static void main(String[] args) {
Disruptor<RowEvent> disruptor = new Disruptor<RowEvent>(new EventFactory<RowEvent>() {
@Override
public RowEvent newInstance() {
return new RowEvent();
}
}, 32/* ringBuffer容量 */, Executors.newCachedThreadPool()/*线程池，线程池最后应该shutdown的*/);
// 消费者行为
EventHandlerGroup<RowEvent> handlerGroup = disruptor.handleEventsWith(new EventHandler<RowEvent>() {
@Override
public void onEvent(RowEvent event, long sequence, boolean endOfBatch) throws Exception {
long rowId = event.getId();
try {
Statement delStatement = con.createStatement();
System.out.println("be to delete row with id=" + rowId);
int delCount = delStatement.executeUpdate("delete from disruptor_test where id = " + rowId);
System.out.println("end delete row with id=" + rowId + ", delCount=" + delCount);
} catch (SQLException e) {
e.printStackTrace();
}
}
});
disruptor.start();
// 生产者行为
RingBuffer<RowEvent> ringBuffer = disruptor.getRingBuffer();
for (int n=0; n<10000/*生产行为的次数*/; ++n) {
long sequence = ringBuffer.next();
RowEvent event = ringBuffer.get(sequence);
try {
// insert_and_get_id是我自己写的存储过程：插入一条记录，然后获取刚刚插入记录的自增id
// 参考：http://lavasoft.blog.51cto.com/62575/238613
CallableStatement prepareCall = con.prepareCall("call insert_and_get_id(?,?)");
prepareCall.setString(1, "nLoop=" + n);
prepareCall.registerOutParameter(2, Types.BIGINT);
prepareCall.executeUpdate();
long lastInsertId = prepareCall.getLong(2);
event.setId(lastInsertId);
} catch (SQLException e) {
e.printStackTrace();
} finally {
ringBuffer.publish(sequence);
}
}
}
}