并
发库中的BlockingQueue
是一个比较好玩的类,顾名思义,就是阻塞队列。该类主要提供了两个方法put()和take(),前者将一个对象放到队列中,如果队列已经满了,就等待直到有空闲节点;后者从head取一个对象,如果没有对象,就等待直到有可取的对象。
下面的例子比较简单,一个读线程,用于将要处理的文件对象添加到阻塞队列中,
另外四个写线程用于取出文件对象,为了模拟写操作耗时长的特点,特让线程睡眠一段随机长度的时间。另外,该Demo也使用到了线程池和原子整型
(AtomicInteger),AtomicInteger可以在并发情况下达到原子化更新,避免使用了synchronized,而且性能非常高。由
于阻塞队列的put和take操作会阻塞,为了使线程退出,特在队列中添加了一个“标识”,算法中也叫“哨兵”,当发现这个哨兵后,写线程就退出。
当然线程池也要显式退出了。
package
concurrent;
import
java.io.File;
import
java.io.FileFilter;
import
java.util.concurrent.BlockingQueue;
import
java.util.concurrent.ExecutorService;
import
java.util.concurrent.Executors;
import
java.util.concurrent.LinkedBlockingQueue;
import
java.util.concurrent.atomic.AtomicInteger;
public class
TestBlockingQueue
{
static
long
randomTime
() {
return
(
long
) (
Math.random
()
*
1000
)
;
}
public static
void
main
(
String
[]
args
) {
// 能容纳100个文件
final
BlockingQueue<File> queue =
new
LinkedBlockingQueue<File>
(
100
)
;
// 线程池
final
ExecutorService exec = Executors.newFixedThreadPool
(
5
)
;
final
File root =
new
File
(
"F:\\JavaLib"
)
;
// 完成标志
final
File exitFile =
new
File
(
""
)
;
// 读个数
final
AtomicInteger rc =
new
AtomicInteger
()
;
// 写个数
final
AtomicInteger wc =
new
AtomicInteger
()
;
// 读线程
Runnable read =
new
Runnable
() {
public
void
run
() {
scanFile
(
root
)
;
scanFile
(
exitFile
)
;
}
public
void
scanFile
(
File file
) {
if
(
file.isDirectory
()) {
File
[]
files = file.listFiles
(
new
FileFilter
() {
public
boolean
accept
(
File pathname
) {
return
pathname.isDirectory
()
|| pathname.getPath
()
.endsWith
(
".java"
)
;
}
})
;
for
(
File one : files
)
scanFile
(
one
)
;
}
else
{
try
{
int
index = rc.incrementAndGet
()
;
System.out.println
(
"Read0: "
+ index +
" "
+ file.getPath
())
;
queue.put
(
file
)
;
}
catch
(
InterruptedException e
) {
}
}
}
}
;
exec.submit
(
read
)
;
// 四个写线程
for
(
int
index =
0
; index <
4
; index++
) {
// write thread
final
int
NO = index;
Runnable write =
new
Runnable
() {
String threadName =
"Write"
+ NO;
public
void
run
() {
while
(
true
) {
try
{
Thread.sleep
(
randomTime
())
;
int
index = wc.incrementAndGet
()
;
File file = queue.take
()
;
// 队列已经无对象
if
(
file == exitFile
) {
// 再次添加"标志",以让其他线程正常退出
queue.put
(
exitFile
)
;
break
;
}
System.out.println
(
threadName +
": "
+ index +
" "
+ file.getPath
())
;
}
catch
(
InterruptedException e
) {
}
}
}
}
;
exec.submit
(
write
)
;
}
exec.shutdown
()
;
}
}
分享到:
相关推荐
"JDK1.5中的线程池(java.util.concurrent.ThreadPoolExecutor)使用" JDK1.5中的线程池(java.util.concurrent.ThreadPoolExecutor)使用是Java多线程编程中的一种重要概念。随着多线程编程的普及,线程池的使用变得...
- **java.util.concurrent**:并发编程的支持,包括`ExecutorService`、`Future`、`BlockingQueue`等,提高了多线程环境下的效率。 3. **I/O流**: - **java.io**:提供输入/输出流,支持文件操作、网络通信和...
这个库使得开发者在不支持Java 5新特性的环境中也能使用高级的并发控制机制,极大地提升了多线程编程的效率和可靠性。本文将深入探讨backport-util-concurrent的源码,揭示其核心设计理念与实现原理。 首先,...
- **java.concurrent**:在JDK1.5引入,提供了并发控制、线程池、同步容器和并发集合等高级并发工具,如ExecutorService、Semaphore、Future、BlockingQueue等。 4. **反射与注解** - **java.lang.reflect**:...
BlockingQueue 是 Java 并发包(java.util.concurrent)中的一个接口,它扩展了 Queue 接口,并引入了线程安全的特性,特别适合于多线程环境下的数据共享。 BlockingQueue 的核心设计是其在并发环境下提供了高效的...
Java并发编程包(java.util.concurrent,简称JUC)封装了大量用于高并发编程的工具类和接口,其中涉及了线程池、阻塞队列、同步器、原子操作类等。在并发环境下,可以有效降低线程创建和管理的复杂性。 #### Java...
标签 "源码" 提示我们可能会涉及Java并发库的底层实现,例如分析`java.util.concurrent`包中的类,如`ExecutorService`, `Semaphore`, `BlockingQueue`, `CountDownLatch`等的源代码。这些类在处理线程间通信、任务...
- **java.util.concurrent**包:添加了许多并发工具类,如`ExecutorService`、`Future`和`BlockingQueue`,简化了多线程编程。 - **java.nio**包:增加了`Path`、`Files`和`ByteChannel`等类,增强了文件操作功能...
随着Java 1.5的发布,Sun公司(现在是Oracle公司的一部分)引入了`java.util.concurrent`包,这是一个革命性的进步,极大地简化了并发编程的工作,并增强了程序的稳定性和效率。通过`java.util.concurrent`提供的...
4. **并发工具类**:`java.util.concurrent`包新增了许多并发工具,如`ExecutorService`、`Future`、`BlockingQueue`等,简化了多线程编程。 5. **改进的内存模型**:提供了更强的内存一致性保证,提高了多处理器...
- **并发工具包(Concurrent Utilities)**:提供了丰富的并发编程工具类,如`java.util.concurrent`包中的`ExecutorService`、`Future`、`BlockingQueue`等,简化了多线程编程。 - **编译器优化**:JDK 1.5的Javac...
- **JDK 7及更高版本的新特性**:例如Fork/Join框架、Parallel Streams等,这些都是Java并发编程的最新进展。 随书附带的`concurrentbook`和`concurrentbook-jdk7`文件夹可能包含了与上述知识点对应的示例代码,...
3. **并发工具**:添加了`java.util.concurrent`包,包含各种线程安全的数据结构和并发编程工具,如`ExecutorService`、`Future`和`BlockingQueue`等。 4. **动态代理**:通过`java.lang.reflect.Proxy`类,可以创建...
此外,还引入了java.util.concurrent包,包含如ExecutorService、Future、Callable和BlockingQueue等高级并发工具。 12. **String的优化**: String类在JDK 1.5中得到了优化,新增了`substring()`的高效实现,以及...
在Java中,我们可以使用JDK提供的`java.util.concurrent`包中的`BlockingQueue`接口来实现线程安全的队列。`BlockingQueue`提供了一种在多线程环境下安全插入、删除和检查元素的方法,同时支持阻塞操作,当队列为空...
- `java.util.concurrent`包引入了大量的并发工具类,如Executor框架、Future接口、BlockingQueue等,使得多线程编程更加高效和安全。 5. **注解(Annotations):** - 注解是一种元数据,可以用于提供编译器或...
Java.util.concurrent包是JDK5引入的一个重要更新,它包含了Doug Lea设计的并发库,极大地提升了Java处理并发的能力。这个库提供了高效且易用的多线程工具,包括线程池、同步器和定时任务管理等。 线程池是Java多...
1. **并发工具类**:JDK 1.6引入了`java.util.concurrent`包,包含如`ExecutorService`、`Future`和`BlockingQueue`等高效并发处理工具。 2. **改进的垃圾回收**:引入了Parallel GC和CMS(Concurrent Mark Sweep)...
3. **并发与多线程**:`java.util.concurrent`包提供了高级并发工具,如`ExecutorService`、`Future`、`BlockingQueue`等,这些工具的源码能帮助理解并发编程的最佳实践。 4. **JNI接口**:JNI是Java与本地代码交互...
`java.util.concurrent`包增加了许多新的类和接口,如`ExecutorService`、`Future`、`BlockingQueue`,这些工具使得多线程编程更为高效和安全。此外,`java.util.concurrent.atomic`包中的原子变量类,如`...