1.阻塞队列
package tutorial;
/**
* <pre>
* 这是java.util.concurrent队列应用的例子
* 这里以阻塞队列为实例说明 内容和代码取自jdk文档并做出了相应的修改
*
* 接口 BlockingQueue<E> 实现类
* ArrayBlockingQueue, DelayQueue,
* LinkedBlockingDeque, LinkedBlockingQueue,
* PriorityBlockingQueue, SynchronousQueue
*
* BlockingQueue 方法以四种形式出现,对于不能立即满足但可能在将来某一时刻可以满足的操作,
* 这四种形式的处理方式不同:第一种是抛出一个异常,第二种是返回一个特殊值(null 或 false,
* 具体取决于操作),第三种是在操作可以成功前,无限期地阻塞当前线程,第四种是在放弃前只在
* 给定的最大时间限制内阻塞。下表中总结了这些方法:
* 抛出异常 特殊值 阻塞 超时
* 插入 add(e) offer(e) put(e) offer(e, time, unit)
* 移除 remove() poll() take() poll(time, unit)
* 检查 element() peek() 不可用 不可用
*
* 以下是基于典型的生产者-使用者场景的一个用例。注意,BlockingQueue 可以安全地与多个生产者和多个使用者一起使用。
* </pre>
*/
import java.util.Date;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;
@SuppressWarnings("unchecked")
class Producer implements Runnable {
private final BlockingQueue queue;
Producer(BlockingQueue q) {
queue = q;
}
public void run() {
try {
while (true) {
queue.put(produce());
Thread.sleep(3000);
}
} catch (InterruptedException ex) {
ex.printStackTrace();
}
}
Object produce() {
return new Date();
}
}
@SuppressWarnings("unchecked")
class Consumer implements Runnable {
int id;
private final BlockingQueue queue;
Consumer(BlockingQueue q, int id) {
queue = q;
this.id = id;
}
public void run() {
try {
while (true) {
consume(queue.take());
}
} catch (InterruptedException ex) {
ex.printStackTrace();
}
}
void consume(Object x) {
System.out.println(id + " " + (Date) x);
}
}
@SuppressWarnings("unchecked")
class Setup {
void main() {
BlockingQueue q = new LinkedBlockingQueue();
Producer p = new Producer(q);
Consumer c1 = new Consumer(q, 1);
Consumer c2 = new Consumer(q, 2);
new Thread(p).start();
new Thread(c1).start();
new Thread(c2).start();
}
}
public class BlockingQueueTest {
public static void main(String args[]) {
new Setup().main();
}
}
2.执行者
package tutorial;
/**
* Executor使用例子 代码取自jdk文档并稍作了修改
*
* 执行已提交的 Runnable 任务的对象。此接口提供一种将任务提交与每个任务将如何运行的
* 机制(包括线程使用的细节、调度等)分离开来的方法。通常使用 Executor 而不是显式
* 地创建线程。例如,可能会使用以下方法,而不是为一组任务中的每个任务调用
* new Thread(new(RunnableTask())).start():
*/
import java.util.Queue;
import java.util.concurrent.Executor;
import java.util.concurrent.LinkedBlockingQueue;
class DirectExecutor implements Executor {
public void execute(Runnable r) {
r.run();
}
}
class SerialExecutor implements Executor {
final Queue<Runnable> tasks = new LinkedBlockingQueue<Runnable>();
final Executor executor;
Runnable active;
SerialExecutor(Executor executor) {
this.executor = executor;
}
public synchronized void execute(final Runnable r) {
tasks.offer(new Runnable() {
public void run() {
try {
r.run();
} finally {
scheduleNext();
}
}
});
if (active == null) {
scheduleNext();
}
}
protected synchronized void scheduleNext() {
if ((active = tasks.poll()) != null) {
executor.execute(active);
}
}
}
public class SerialExecutorTest {
public static void main(String args[]) {
SerialExecutor exe = new SerialExecutor(new DirectExecutor());
exe.execute(new Runnable(){
public void run() {
System.out.println("执行任务1");
}
});
exe.execute(new Runnable(){
public void run() {
System.out.println("执行任务2");
}
});
}
}
3.线程池
package tutorial;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
public class ThreadPoolExecutorTest {
/**
* @param args
*/
@SuppressWarnings("unchecked")
public static void main(String[] args) {
ThreadPoolExecutor executor = new ThreadPoolExecutor(3, 6, 60L, TimeUnit.SECONDS,
new LinkedBlockingQueue());
executor.execute(new Runnable() {
public void run() {
System.out.println("执行线程任务1");
}
});
executor.execute(new Runnable() {
public void run() {
try {
Thread.sleep(10000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("执行线程任务2");
}
});
executor.execute(new Runnable() {
public void run() {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("执行线程任务3");
}
});
executor.execute(new Runnable() {
public void run() {
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("执行线程任务4");
}
});
executor.execute(new Runnable() {
public void run() {
System.out.println("执行线程任务5");
}
});
}
}
分享到:
相关推荐
1. java.util.concurrent - Java 并发工具包 2. 阻塞队列 BlockingQueue 3. 数组阻塞队列 ArrayBlockingQueue 4. 延迟队列 DelayQueue 5. 链阻塞队列 LinkedBlockingQueue 6. 具有优先级的阻塞队列 ...
java.util.concurrent 使用jdk内置的包实现一个线程池的操作
JDK1.5中的线程池(java.util.concurrent.ThreadPoolExecutor)使用
java.util.concurrent - Java 并发工具包 2. 阻塞队列 BlockingQueue 3. 数组阻塞队列 ArrayBlockingQueue 4. 延迟队列 DelayQueue 5. 链阻塞队列 LinkedBlockingQueue 6. 具有优先级的阻塞队列 ...
JDK1.5中的线程池(java.util.concurrent.ThreadPoolExecutor)使用简介
本资源包含两个 pdf 文档,一本根据 Jakob Jenkov 最新博客 (http://tutorials.jenkov.com/java-util-concurrent/index.html) 整理的 java_util_concurrent_user_guide_en.pdf,一个中文翻译的 java_util_concurrent...
主要介绍了浅谈java.util.concurrent包中的线程池和消息队列,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
而了解 Java 并发编程以及其中的 JUC(java.util.concurrent)线程池,对于构建高性能、高可伸缩性的应用程序具有重要意义。 多核处理器的出现使得并发执行成为一种重要的优化手段。了解并发编程和线程池的工作原理...
[2]中介绍了java.util.concurrent.Executors类的API。 [3]中介绍了Java中线程池的类体系结构。 [4]中有ThreadPoolExecutor的实例应用。 [5]中有线程池的实例讲解,实现了一个基于线程池的端口监听服务器。★ [6]...
(转)线程池:java_util_ThreadPoolExecutor 比较详细的介绍了ThreadPoolExecutor用法与属性
Java JUC的使用1.volatile关键字-内存可见性2.原子变量-CAS算法3.ConcurrentHashMap锁分段机制4.CountDownLatch闭锁5.实现Callable接口6.Lock同步锁7.Condition控制线程通信8.线程按序交替9.ReadWriteLock读写锁10....
在客户/ 服务器通信模式中, 服务器端需要创建监听特定端口的 ServerSocket , ServerSocket 负责接收客户连接请求。...章还介绍了 java.util.concurrent 包中的线程池类的用法,在服务器程序中可以直接使用它们。
无论是工作学习,不断的总结是必不可少的。只有不断的总结,发现问题,弥补不足,才能长久的...java.util.concurrent.locks包下常用的类 326 NIO(New IO) 327 volatile详解 337 Java 8新特性 347 Java 性能优化 362
Executors: 是java.util.concurrent包下的一个类,提供了若干个静态方法,用于生成不同类型的线程池。Executors一共可以创建下面这四类线程池: 1.newFixedThreadPool创建一个可缓存线程池,如果线程池长度超过...
本资源包含两个 pdf 文档,一本根据 Jakob Jenkov 最新博客 (http://tutorials.jenkov.com/java-util-concurrent/index.html) 整理的 java_util_concurrent_user_guide_en.pdf,一个中文翻译的 java_util_concurrent...
1. java.util.concurrent - Java 并发工具包 2. 阻塞队列 BlockingQueue 3. 数组阻塞队列 ArrayBlockingQueue 4. 延迟队列 DelayQueue 5. 链阻塞队列 LinkedBlockingQueue 6. 具有优先级的阻塞队列 ...
import java.util.concurrent.CountDownLatch; import java.util.concurrent.Executor; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; public class ...
介绍了java线程池的使用方式。 线程的使用在java中占有极其重要的地位,...Jdk1.5之后加入了java.util.concurrent包,这个包中主要介绍java中线程以及线程池的使用。为我们在开发中处理线程的问题提供了非常大的帮助。
阅读xsocket需要一些线程,nio,niosocket,和java.util.concurrent(锁,线程池等)包的一些知识。要不读起来很费劲,建议先去了解下这些知识。可以在我的文章分类concurrent里面有一些,
接口 java.util.concurrent.ExecutorService 表述了异步执行的机制,并且可以让任务在后台执行。壹個 ExecutorService 实例...事实上,在 java.util.concurrent 包中的 ExecutorService 的实现就是壹個线程池的实现。