利用JAVA线程安全队列简单实现读者写者问题。

摘要: 常见的操作系统教科书中，会使用互斥锁来实现读者线程和写者线程的同步问题，但是在JDK5推出线程安全队列之后，将该问题变得异常简单。

常见的操作系统教科书中，会使用互斥锁来实现读者线程和写者线程的同步问题，但是在JDK5推出线程安全队列之后，将该问题变得异常简单。

java.util.concurrent.ConcurrentLinkedQueue 是线程安全的非阻塞队列，其实很容易想到，非阻塞队列当线程需要等待的时候，则不会阻塞等待，而是直接根据情况返回。

java.util.concurrent.LinkedBlockingQueue 是线程安全的阻塞队列，该队列能够在很多情况下对线程进行阻塞，比如队列为空时调用take() 方法，改方法是从队首取得对象，如果对象不存在，则会阻塞等待，直到有可取的对象之后则唤醒该线程并取走队首对象。同样，这种阻塞队列还有put() 这样的阻塞方法：在放入对象到队尾的时候如果队列不可用，则阻塞等待，知道队列可用。而非阻塞队列则没有这样的阻塞方法。

下面这个例子，是使用非阻塞队列实现读者写者问题的简单例子：

package nonblockingqueueconpro;

import java.util.concurrent.ConcurrentLinkedQueue;

public class MainThread {
public static void main(String args[]) {
ConcurrentLinkedQueue<String> queue = new ConcurrentLinkedQueue<String>();

for (int i = 0; i < 2; i++) {
Productor task = new Productor(queue);
Thread t = new Thread(task, "生产者线程" + i);
t.start();
}

for (int i = 0; i < 2; i++) {
Consumer task = new Consumer(queue);
Thread t = new Thread(task, "消费者线程" + i);
t.start();
}
}
}

class Consumer implements Runnable {
private ConcurrentLinkedQueue<String> queue;

public Consumer(ConcurrentLinkedQueue<String> queue) {
this.queue = queue;
}

@Override
public void run() {
while (true) {
try {
Thread.currentThread().sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}

System.out.println("消费者-->  " + queue.poll());
}

}
}

class Productor implements Runnable {

private ConcurrentLinkedQueue<String> queue;

public Productor(ConcurrentLinkedQueue<String> queue) {
this.queue = queue;
}

@Override
public void run() {
while (true) {
try {
Thread.currentThread().sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
String content = String.valueOf(System.currentTimeMillis());
System.out.println("生产者==>  " + content);
queue.add(content);
}

}

}

可以看到，消费者线程有可能会取不到对象的情况（队列为空），则poll() 方法返回空，运行结果片段如下：

消费者-->  null
消费者-->  null
生产者==>  1439301233285
生产者==>  1439301233284
消费者-->  1439301233284
生产者==>  1439301234289
生产者==>  1439301234289
......

而使用阻塞队列设计的例子，消费者不会出现返回null的情况，如果队列为空时，消费者线程会进行等待，代码如下：

package blockingqueueconpro;

import java.util.concurrent.LinkedBlockingQueue;

public class MainThread {
public static void main(String args[]) {
LinkedBlockingQueue<String> queue = new LinkedBlockingQueue<String>();

for (int i = 0; i < 2; i++) {
Productor task = new Productor(queue);
Thread t = new Thread(task, "生产者线程" + i);
t.start();
}

for (int i = 0; i < 2; i++) {
Consumer task = new Consumer(queue);
Thread t = new Thread(task, "消费者线程" + i);
t.start();
}
}
}

class Productor implements Runnable {

private LinkedBlockingQueue<String> queue;

public Productor(LinkedBlockingQueue<String> queue) {
this.queue = queue;
}

@Override
public void run() {
while (true) {
try {
Thread.currentThread().sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
String content = String.valueOf(System.currentTimeMillis());
System.out.println("生产者==>  " + content);
queue.add(content);
}

}

}

class Consumer implements Runnable {
private LinkedBlockingQueue<String> queue;

public Consumer(LinkedBlockingQueue<String> queue) {
this.queue = queue;
}

@Override
public void run() {
while (true) {
try {
Thread.currentThread().sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}

try {
System.out.println("消费者-->  " + queue.take());
} catch (InterruptedException e) {
e.printStackTrace();
}
}

}
}

运行结果如下：

生产者==>  1439301385710
生产者==>  1439301385710
消费者-->  1439301385710
消费者-->  1439301385710
生产者==>  1439301386716
生产者==>  1439301386716
......

总结：在日常开发中，需要线程安全的情况下，java.util.concurrent 包下面的很多类能够解决问题，这比起自己实现对象锁和同步来说，代码更简单，也更安全。