一:使用syncronized
这是最直接原始的一种实现方式:
//数据源,用来模拟生产者生产的对象
public class DataSource {
//数据源--每个元素都是时间类型
private List<Date> data;
//设置数据源大小
private int maxSize;
public DataSource() {
this.data = new LinkedList<>();
this.maxSize = 10;
}
//初始化数据源方法-set
public synchronized void set(){
//如果数据源中的数据达到最大值,则让其等待
while (data.size()==maxSize){
try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
data.add(new Date());
System.out.printf("Set: %d.\n",data.size());
//在方法的尾部,调用notifyAll()方法来唤醒,所有在wait()方法上等待的线程
notifyAll();
}
public synchronized void get(){
//如果数据源中没有数据,则让其等待
while (data.size()==0){
try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.printf("Get: %d: %s .\n",data.size(),((LinkedList<?>)data).poll());
}
}
//生产者
public class Producer implements Runnable {
private DataSource dataSource;
public Producer(DataSource dataSource) {
this.dataSource = dataSource;
}
@Override
public void run() {
for (int i = 0; i < 1000; i++) {
dataSource.set();
}
}
}
//消费者
public class Consumer implements Runnable {
private DataSource dataSource;
public Consumer(DataSource dataSource) {
this.dataSource = dataSource;
}
@Override
public void run() {
for (int i = 0; i < 100; i++) {
dataSource.get();
}
}
}
//测试类
public class Main {
public static void main(String[] args) {
DataSource dataSource = new DataSource();
Thread producerThreads[] = new Thread[3];
Thread consumerThreads[] = new Thread[4];
for (int i = 0; i < 3; i++) producerThreads[i] = new Thread(new Producer(dataSource));
for (int i = 0; i < 4; i++) consumerThreads[i] = new Thread(new Consumer(dataSource));
for (int i = 0; i < 3; i++) producerThreads[i].start();
for (int i = 0; i < 4; i++) consumerThreads[i].start();
}
}
二:使用Lock和Condition
lock是实现java同步的另外一种方式,使用lock比syncronized更加灵活。一个锁可能伴随着多个条件,这些条件在condition接口中。
我们将上面代码中DataSource类修改一下:
//数据源--每个元素都是时间类型
private List<Date> data;
//设置数据源大小
private int maxSize;
private Condition add;
private Condition sub;
private Lock lock;
public DataSource() {
this.data = new LinkedList<>();
this.maxSize = 10;
lock = new ReentrantLock();
add = lock.newCondition();
sub = lock.newCondition();
}
//初始化数据源方法-set
public void set(){
//获取锁
lock.lock();
try{
//如果数据源中的数据达到最大值,则让其等待
while (data.size()==maxSize){
//注意,这里是await,wait()和notify()必须在synchronized的代码块中使用 因为只有在获取当前对象的锁时才能进行这两个操作 否则会报异常 而await()和signal()一般与Lock()配合使用
add.await();
}
data.add(new Date());
System.out.printf("Set: %d,%s.\n",data.size(),Thread.currentThread().getName());
//在方法的尾部,signalAll()方法来唤醒,所有在wait()方法上等待的线程
sub.signalAll();
}catch (Exception e){
e.printStackTrace();
}finally {
//释放锁
lock.unlock();
}
}
public void get(){
lock.lock();
//如果数据源中没有数据,则让其等待
try {
while (data.size()==0){
sub.await();
}
add.signalAll();
System.out.printf("Get: %d: %s .\n",data.size(),((LinkedList<?>)data).poll());
}catch (Exception e){
e.printStackTrace();
}finally {
lock.unlock();
}
}
三:使用Exchanger 类
Exchanger 类允许2个并发任务互相交换数据。Exchanger 定义了一个同步点,当两个线程到达这个点后,他们互相交换数据。也就是说,使用第一个线程的数据类型变成第二个的,然后第二个线程的数据类型变成第一个的。
只是Exchanger只能操作两个线程,所以只能在生产者和消费者中各选择一个来实现这个类。
public class Producer implements Runnable {
private List<String> buffer;
//Producer 中包含 exchanger实例
private final Exchanger<List<String>> exchanger ;
public Producer(List<String> buffer, Exchanger<List<String>> exchanger) {
this.buffer = buffer;
this.exchanger = exchanger;
}
@Override
public void run() {
for (int i = 0; i < 10; i++) {
for (int j = 0; j < 10; j++) {
String message = "Event "+((i*10)+j);
System.out.printf("Product : %s .\n",message);
buffer.add(message);
}
try {
//设置交换点
buffer = exchanger.exchange(buffer);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.printf("Producer : %d \n",buffer.size());
}
}
}
public class Consumer implements Runnable {
private List<String> buffer;
private final Exchanger<List<String>> exchanger;
public Consumer(List<String> buffer, Exchanger<List<String>> exchanger) {
this.buffer = buffer;
this.exchanger = exchanger;
}
@Override
public void run() {
for (int i = 0; i < 10; i++) {
try {
buffer = exchanger.exchange(buffer);
} catch (InterruptedException e) {
e.printStackTrace();
}
for (int j = 0; j < 10; j++) {
String message = buffer.get(0);
System.out.printf("Consumer : %s .\n",message);
buffer.remove(0);
}
}
}
}
public class Main {
public static void main(String[] args) {
List<String> buffer1 = new ArrayList<>();
List<String> buffer2 = new ArrayList<>();
Exchanger<List<String>> exchanger = new Exchanger<>();
Producer producer = new Producer(buffer1, exchanger);
Consumer consumer = new Consumer(buffer2, exchanger);
Thread threadProducer = new Thread(producer);
Thread threadConsumer = new Thread(consumer);
threadProducer.start();
threadConsumer.start();
}
}