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` 实现线程池队列,以及其中的关键概念和技术。 线程池是一种线程使用模式,通过预先创建并维护一定数量的工作线程来避免频繁创建和销毁线程的开销。在Java中,`...
"java.util.concurrent.ExecutionException: java.lang.OutOfMemoryError" 是一个典型的错误提示,它表明在并发执行过程中遇到了内存不足的问题。下面我们将深入探讨这个问题的原因、影响以及如何解决。 内存溢出...
"JDK1.5中的线程池(java.util.concurrent.ThreadPoolExecutor)使用" JDK1.5中的线程池(java.util.concurrent.ThreadPoolExecutor)使用是Java多线程编程中的一种重要概念。随着多线程编程的普及,线程池的使用变得...
Java.util.concurrent的引入是为了解决传统并发原语如wait()、notify()、synchronized和volatile的使用难度大、容易出错以及性能问题。 在并发编程中,我们经常会遇到需要管理多个线程执行任务的情况。传统的做法是...
### Java并发工具包 `java.util.concurrent` 知识点详解 #### 一、引言 随着多核处理器的普及和应用程序复杂度的增加,多线程编程成为了现代软件开发不可或缺的一部分。为了简化并发编程的复杂性,Java 5 引入了 `...
java.util.concurrent - Java 并发工具包 2. 阻塞队列 BlockingQueue 3. 数组阻塞队列 ArrayBlockingQueue 4. 延迟队列 DelayQueue 5. 链阻塞队列 LinkedBlockingQueue 6. 具有优先级的阻塞队列 ...
Java.util.concurrent(JUC)是Java平台中的一个核心包,专门用于处理多线程并发问题。这个包包含了大量的工具类和接口,极大地简化了并发编程的复杂性,提高了程序的性能和可伸缩性。本测试源文件主要是针对JUC并发...
在 java.util.concurrent 多线程框架中,线程池是最重要的一部分。线程池是一种池化技术,用于管理线程的生命周期,包括线程的创建、执行、销毁等。线程池可以大大提高系统的性能和可靠性。 在 Java 语言中,线程池...
描述中提到了“Java并发编程工具包java.util.concurrent的UML类结构图 PDF”,这强调了文件是一个图表,它可能包括并发包中的线程安全集合、同步器、线程池、执行器等核心组件的类图和接口图。 标签“Java ...
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.util.concurrent包中的线程池和消息队列是一种高效的多线程编程技术,主要用于解决处理器单元内多个线程执行的问题。线程池技术可以显著减少处理器单元的闲置...
通过这份中文版的`java.util.concurrent`用户指南,读者可以深入理解这些并发工具的使用方法和原理,提升在多线程环境下的编程能力。书签功能使得学习更加便捷,能够快速定位到感兴趣的章节或知识点,对Java并发编程...
在Java并发编程中,`java.util.concurrent`(简称JUC)提供了丰富的类和接口,如Executor框架、线程池、并发集合、同步工具类等。这些工具使得程序员能够更方便地管理线程,避免了传统的锁和同步机制带来的复杂性和...
总之,`java.util.concurrent` 提供的工具使得并发编程变得更加容易和高效,是 Java 并发编程的基石,无论是对于初学者还是经验丰富的开发者,理解和掌握这个包都是非常重要的。通过熟练运用这些工具,开发者可以...
在Java编程领域,`java.util.concurrent`包是并发编程的核心工具包,提供了高效、线程安全的类和接口,使得开发者能够更容易地处理多线程环境。本篇将深入探讨这个包中一些鲜为人知的知识点,以帮助你提升并发编程的...
- **线程池管理**:Atlassian Util Concurrent库提供了一种定制化的线程池实现,允许开发者根据具体需求调整线程数量、任务队列策略等,从而有效地管理和控制并发执行的任务。 - **锁和同步机制**:库中包含了各种...
Java的并发库(java.util.concurrent)提供了丰富的线程池实现,包括`ThreadPoolExecutor`,它是基于工作窃取算法的高效线程池。本文主要分析的是基于`concurrent`包的一个特定线程池实现,探讨其实现原理和源码。 ...
Java提供了两种方式实现线程同步机制,分别是使用synchronized关键字和java.util.concurrent.locks.Lock接口。 线程池的应用: 线程池技术可以应用于Web服务系统中,控制服务器系统的最大并发数与最多处理的任务数...