java中实现线程同步可能让人想到join方法。但这里说的不是它。而是说的两个工具类。我直接从jd文档拷贝到这里来。
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
java.util.concurrent
类 CountDownLatch
java.lang.Object
java.util.concurrent.CountDownLatch
public class
CountDownLatch
extends
Object
一个同步辅助类,在完成一组正在其他线程中执行的操作之前,它允许一个或多个线程一直等待。
用给定的
计数
初始化
CountDownLatch
。由于调用了
countDown()
方法,所以在当前
计数
到达零之前,
await
方法会一直受阻塞。之后,会释放所有等待的线程,
await
的所有后续调用都将立即返回。这种现象只出现一次——计数无法被重置。如果需要重置计数,请考虑使用
CyclicBarrier
。
CountDownLatch
是一个通用同步工具,它有很多用途。将计数 1 初始化的
CountDownLatch
用作一个简单的开/关锁存器,或入口:在通过调用
countDown()
的线程打开入口前,所有调用
await
的线程都一直在入口处等待。用
N
初始化的
CountDownLatch
可以使一个线程在
N
个线程完成某项操作之前一直等待,或者使其在某项操作完成 N 次之前一直等待。
CountDownLatch
的一个有用特性是,它不要求调用
countDown
方法的线程等到计数到达零时才继续,而在所有线程都能通过之前,它只是阻止任何线程继续通过一个
await
。
示例用法:
下面给出了两个类,其中一组 worker 线程使用了两个倒计数锁存器:
-
第一个类是一个启动信号,在 driver 为继续执行 worker 做好准备之前,它会阻止所有的 worker 继续执行。
-
第二个类是一个完成信号,它允许 driver 在完成所有 worker 之前一直等待。
class Driver { // ...
void main() throws InterruptedException {
CountDownLatch startSignal = new CountDownLatch(1);
CountDownLatch doneSignal = new CountDownLatch(N);
for (int i = 0; i < N; ++i) // create and start threads
new Thread(new Worker(startSignal, doneSignal)).start();
doSomethingElse(); // don't let run yet
startSignal.countDown(); // let all threads proceed
doSomethingElse();
doneSignal.await(); // wait for all to finish
}
}
class Worker implements Runnable {
private final CountDownLatch startSignal;
private final CountDownLatch doneSignal;
Worker(CountDownLatch startSignal, CountDownLatch doneSignal) {
this.startSignal = startSignal;
this.doneSignal = doneSignal;
}
public void run() {
try {
startSignal.await();
doWork();
doneSignal.countDown();
} catch (InterruptedException ex) {} // return;
}
void doWork() { ... }
}
另一种典型用法是,将一个问题分成 N 个部分,用执行每个部分并让锁存器倒计数的 Runnable 来描述每个部分,然后将所有 Runnable 加入到 Executor 队列。当所有的子部分完成后,协调线程就能够通过 await。(当线程必须用这种方法反复倒计数时,可改为使用
CyclicBarrier
。)
class Driver2 { // ...
void main() throws InterruptedException {
CountDownLatch doneSignal = new CountDownLatch(N);
Executor e = ...
for (int i = 0; i < N; ++i) // create and start threads
e.execute(new WorkerRunnable(doneSignal, i));
doneSignal.await(); // wait for all to finish
}
}
class WorkerRunnable implements Runnable {
private final CountDownLatch doneSignal;
private final int i;
WorkerRunnable(CountDownLatch doneSignal, int i) {
this.doneSignal = doneSignal;
this.i = i;
}
public void run() {
try {
doWork(i);
doneSignal.countDown();
} catch (InterruptedException ex) {} // return;
}
void doWork() { ... }
}
java.util.concurrent
类 CyclicBarrier
java.lang.Object
java.util.concurrent.CyclicBarrier
public class CyclicBarrier
extends Object
一个同步辅助类,它允许一组线程互相等待,直到到达某个公共屏障点 (common barrier point)。在涉及一组固定大小的线程的程序中,这些线程必须不时地互相等待,此时 CyclicBarrier 很有用。因为该 barrier 在释放等待线程后可以重用,所以称它为循环
的 barrier。
CyclicBarrier
支持一个可选的
Runnable
命令,在一组线程中的最后一个线程到达之后(但在释放所有线程之前),该命令只在每个屏障点运行一次。若在继续所有参与线程之前更新共享状态,此屏障操作
很有用。
示例用法:
下面是一个在并行分解设计中使用 barrier 的例子:
class Solver {
final int N;
final float[][] data;
final CyclicBarrier barrier;
class Worker implements Runnable {
int myRow;
Worker(int row) { myRow = row; }
public void run() {
while (!done()) {
processRow(myRow);
try {
barrier.await();
} catch (InterruptedException ex) {
return;
} catch (BrokenBarrierException ex) {
return;
}
}
}
}
public Solver(float[][] matrix) {
data = matrix;
N = matrix.length;
barrier = new CyclicBarrier(N,
new Runnable() {
public void run() {
mergeRows(...);
}
});
for (int i = 0; i < N; ++i)
new Thread(new Worker(i)).start();
waitUntilDone();
}
}
在这个例子中,每个 worker 线程处理矩阵的一行,在处理完所有的行之前,该线程将一直在屏障处等待。处理完所有的行之后,将执行所提供的
Runnable
屏障操作,并合并这些行。如果合并者确定已经找到了一个解决方案,那么
done()
将返回
true
,所有的 worker 线程都将终止。
如果屏障操作在执行时不依赖于正挂起的线程,则线程组中的任何线程在获得释放时都能执行该操作。为方便此操作,每次调用
await()
都将返回能到达屏障处的线程的索引。然后,您可以选择哪个线程应该执行屏障操作,例如:
if (barrier.await() == 0) {
// log the completion of this iteration
}
对于失败的同步尝试,CyclicBarrier
使用了一种快速失败的、要么全部要么全不 (all-or-none) 的破坏模式:如果因为中断、失败或者超时等原因,导致线程过早地离开了屏障点,那么其他所有线程(甚至是那些尚未从以前的
await()
中恢复的线程)也将通过BrokenBarrierException
(如果它们几乎同时被中断,则用
InterruptedException
)以反常的方式离开。
分享到:
相关推荐
在这个“关于线程同步VC程序源代码”的压缩包中,我们可以期待找到与关键区、内核对象、多线程以及互斥对象相关的源代码示例。 1. **关键区(Critical Section)**: 关键区是一种简单的线程同步机制,它允许一次...
在C#编程中,线程同步是一个至关重要的概念,特别是在多线程环境下,它用于管理和控制多个线程的执行顺序,以确保数据的一致性和完整性。线程同步可以帮助避免竞态条件、死锁等问题,提高程序的稳定性和性能。本文将...
关于线程同步,需要牢牢记住的第一点是:线程同步就是线程排队。同步就是排队。线程同步的真实意思和字面意思恰好相反。线程同步的目的就是避免线程“同步”执行。 关于线程同步,需要牢牢记住的第二点是 “共享”...
以下是关于线程同步和`Lock()`对象的详细解释: 1. **线程同步的必要性**: 当多个线程共享同一块内存(如变量A)时,如果没有适当的同步机制,可能导致数据不一致或者错误的结果。例如,两个线程同时修改A的值,...
在多线程编程中,线程同步是一种关键的技术,它用于控制多个线程对共享资源的访问,确保数据的一致性和避免竞态条件。本文将深入探讨如何使用两种不同的方法来实现线程同步等待,主要关注"Event"方式。我们将通过...
标题与描述概述的知识点主要集中在C#中的线程同步技术,包括`volatile`关键字、`lock`关键字以及`System.Threading.Interlocked`类的使用。在深入探讨这些知识点之前,我们首先需要理解为什么线程同步在多线程环境中...
在VC++编程环境中,线程同步是一个至关重要的概念,特别是在多线程程序设计中,以确保并发执行的线程能够安全地访问共享资源,避免数据竞争和其他潜在的问题。本篇文章将详细探讨线程锁在VC++中的应用,以及如何通过...
MFC 多线程及线程同步 MFC 多线程及线程同步 MFC 多线程及线程同步
根据题目描述中的内容,我们可以总结出关于线程同步的基本原则: 1. **单线程访问无需同步**:如果一个对象或变量仅被单个线程访问,则不需要进行线程同步。 2. **无交叉访问无需同步**:即使有多个线程访问同一...
在编程领域,线程同步是多线程编程中的一个核心概念,它涉及到如何有效地管理和协调多个并发执行的线程,确保它们能正确地共享资源,避免数据竞争和死锁等问题。这个“线程同步小例子”是基于孙鑫先生著作中的示例...
线程同步是多线程编程中的重要概念,用于协调多个并发执行的线程,确保它们在访问共享资源时不会产生竞态条件或数据不一致性。在Windows编程中,提供了多种线程同步机制,包括互斥量、临界区、原子操作、事件以及...
TestThreadEvent这个文件名可能表示它包含了一个关于线程同步的示例,特别是使用事件(Event)进行同步的例子。事件是一种线程间通信的机制,通过设置和重置事件状态,线程可以等待特定条件发生后再继续执行。这在...
"Java多线程同步.pdf" Java多线程同步是指在Java语言中,如何使用synchronized关键字和其他同步机制来确保多线程程序的正确执行。在Java语言中,synchronized关键字用于对方法或者代码块进行同步,但是仅仅使用...
在编程领域,线程同步是多线程编程中的一个重要概念,它确保了多个线程在访问共享资源时的正确性和一致性。在这个“VC++线程同步实例”中,我们将探讨如何利用VC++(Visual C++)来实现线程间的同步,以避免数据竞争...
"多线程的批量线程同步解决方案"这个标题暗示我们探讨的是如何在多线程环境下有效地管理和同步多个任务,确保数据一致性与程序正确性。下面将详细阐述相关知识点。 一、多线程基础 多线程是指在一个进程中同时执行...
操作系统中的线程同步是多线程编程中一个关键的概念,它确保了多个线程在访问共享资源时的正确性,防止数据竞争和其他并发问题。在Windows操作系统中,提供了多种线程同步机制,如临界区、事件、信号量以及互斥量等...
在多线程编程中,线程同步是一种控制多个线程并发执行时访问共享资源的方式,以避免数据不一致和死锁等问题。以下是对线程同步的四种主要方式的详细解释: 1. **事件(Event)** 事件是Windows API提供的一种线程...
然而,多线程环境下也带来了一些问题,尤其是资源竞争和数据一致性问题,这些问题需要通过线程同步机制来解决。本文将详细介绍如何通过临界区、互斥内核对象、事件内核对象和信号量内核对象来实现线程同步。 1. ...