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

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

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

java.util.concurrent.LinkedBlockingQueue 是线程安全的阻塞队列,该队列可以在不少状况下对线程进行阻塞,好比队列为空时调用take() 方法,改方法是从队首取得对象,若是对象不存在,则会阻塞等待,直到有可取的对象以后则唤醒该线程并取走队首对象。一样,这种阻塞队列还有put() 这样的阻塞方法:在放入对象到队尾的时候若是队列不可用,则阻塞等待,知道队列可用。而非阻塞队列则没有这样的阻塞方法。 ide


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

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 包下面的不少类可以解决问题,这比起本身实现对象锁和同步来讲,代码更简单,也更安全。 线程

相关文章
相关标签/搜索