Java自定义屏障的实现
Java自定义屏障是一种多线程同步工具，用于控制多个线程在某个点上等待，直到所有线程都到达该点后才能继续执行。它可以帮助开发人员实现线程间的协调和同步。
Java自定义屏障的实现可以通过使用CyclicBarrier类来完成。CyclicBarrier类提供了一个计数器，当计数器的值达到指定的数量时，所有等待的线程将被释放。以下是Java自定义屏障的实现步骤：
- 创建一个CyclicBarrier对象，指定等待的线程数量和达到屏障时要执行的动作。
- 创建一个CyclicBarrier对象，指定等待的线程数量和达到屏障时要执行的动作。
- 在需要等待的线程中调用CyclicBarrier的await()方法，使线程进入等待状态。
- 在需要等待的线程中调用CyclicBarrier的await()方法，使线程进入等待状态。
- 当所有线程都调用了await()方法后，计数器的值达到指定数量，所有等待的线程将被释放，继续执行后续操作。
Java自定义屏障的优势在于可以实现多个线程之间的同步和协调，特别适用于需要等待其他线程完成某个任务后再继续执行的场景，例如多线程计算任务的结果合并、并行计算的阶段同步等。
在腾讯云的产品中，可以使用云服务器（CVM）来部署Java应用程序，并使用云数据库MySQL（CDB）来存储数据。此外，腾讯云还提供了云原生应用引擎（TKE）和容器服务（CVM）等产品，用于支持容器化部署和管理Java应用程序。
更多关于腾讯云产品的信息，请访问腾讯云官方网站：https://cloud.tencent.com/
相关·内容
1回答
例如，在标准和中，6类型的内存屏障：
memory_order_relaxed
memory_order_consume
memory_order_acquire
memory_order_release
memory_order_acq_rel
memory_order_seq_cst
这些指令决定编译器可以重新排序指令的方向，以及需要插入哪些处理器指令来限制处理器流水线中的重新排序。例如，前五个障碍只影响编译器，但不生成任何CPU指令(不包括S/L/ MFENCE)，因为在x86 -获取-发布语义中自动提供。
Java中有多少类型的内存屏障可用？还是只有两种
浏览 2提问于2014-02-27得票数 4
1回答
我想为Java开发某种反向调试器(在执行过程中可以退一步)。要做到这一点，我必须知道JVM的初始状态(这可以很容易地通过核心转储获得)。然后，我必须拦截JVM正在执行的每一个内存访问，这样我就可以得到JVM在执行过程中所做的事情的时间线，这样我就可以重建JVM的每个状态。
因此，我需要一种方法来拦截内存访问，但是使用低性能开销的，这意味着解决方案不应该给JVM的执行增加超过200-300%的开销，这已经是很多了。
我脑海中浮现的一些想法：
使用ptrace，但它确实很慢
开发某种简单的虚拟机，在其中运行JVM (在客户操作系统之上)，并且这个虚拟机拦截JVM可执行文件的所有内存访问，这
浏览 5提问于2020-05-17得票数 0
回答已采纳
我正在研究同步变量和易失性变量在java中是如何工作的，我遇到了一个叫做读写屏障的概念。有谁能帮助我理解这些术语的含义吗？
浏览 1提问于2013-08-28得票数 9
现在我们有了
Load A
StoreStore
Store B
是否有可能实际执行命令如下
StoreStore
Store B
Load A
如果可能的话，如何解释似乎违反了The Java volatile Happens-Before Guarantee的情况。
据我所知，易失性语义是使用以下JMM内存屏障添加策略实现的
insert a StoreStore before volatile variable write operation
insert a StoreLoad after volatile variable write operation
insert a LoadL
浏览 9提问于2019-10-01得票数 0
回答已采纳
1回答
我正在为一个生产者和多个消费者运行代码。我想对使用者线程的执行进行优先级排序。例如，如果我有consThread1、consThread2、consThread3。我的问题是如何限制consThread3在consThread1和consThread2之前消费
Producer.java
import java.util.concurrent.BlockingQueue;
import org.json.simple.JSONObject;
public class Producer implements Runnable {
private final BlockingQueue&
浏览 0提问于2017-09-03得票数 0
1回答
锁与记忆屏障
、、、、
什么时候可以通过使用内存屏障来避免锁？与本例中的情况一样： (最后一个实现是使用内存屏障和rest，它们都使用锁或信号量)。
在这种情况下使用内存屏障比使用锁更好吗？如果是，为什么？
使用内存屏障可以避免锁的最常见情况是什么？
浏览 2提问于2016-08-01得票数 2
我在学习循环障碍。
我正在尝试编写代码示例：
public class Main {
public static final int PARSER_COUNT = 15;
public static final int PRODUCT_TRESHOLD = 5;
public static void main(String args[]) {
ProductImporter productImporter = new ProductImporter(PRODUCT_TRESHOLD);
for (int i = 0; i <
浏览 3提问于2015-08-07得票数 4
回答已采纳
2回答
我想实现新的屏障函数。
首先，我想了解一下默认屏障的实现。(phtread，linux)
我找到了pthread.h (/usr/include)
但是在这个文件中，我找不到屏障实现。唯一的声明。
1040 /* Functions to handle barriers. */
1041
1042 /* Initialize BARRIER with the attributes in ATTR. The barrier is
1043 opened when COUNT waiters arrived.
浏览 1提问于2012-03-22得票数 4
1回答
上面有一些 。但他们只问了一个问题。
相对于std::barrier有一个优势，与后者不同，前者可以通过一个多个参与线程减少一次。
与不同的是，与std::latch不同，与后者不同的是，一旦到达的线程在一个阶段的同步点被解除阻塞，前者就可以被重用。
但我的问题是，为什么一开始有两个几乎相同的东西？为什么他们决定不将两者合并成一个，类似于Java 。
Phaser是在Java7中引入的，作为比CountDownLatch和CyclicBarrier更灵活的选择，后者是在Java5中引入的。它的API几乎与前两个类的API相同。(这里我以Java为例，只是为了说明将它们结合起来确实是可能的。)
浏览 4提问于2022-07-12得票数 2
我在实践中阅读Java并发时，遇到了以下代码片段。清单12.5 https://jcip.net/listings/PutTakeTest.java // Listing 12.5. Producer-consumer test program for BoundedBuffer.
package net.jcip.examples;
import java.util.concurrent.*;
import java.util.concurrent.atomic.*;
import junit.framework.TestCase;
/**
* PutTakeTest
* <
浏览 19提问于2020-09-27得票数 0
回答已采纳
1回答
内存屏障可以通过代码实现吗(不使用CAS或其他锁定原语，如易失性、原子类等)？
我相信颠覆者能够做到这一点，而不需要对任何锁定原语进行实际的排序。
理解这一点的任何指针或参考资料都会很有帮助。
关于其它编程模式的建议(最好是在java中)也很受欢迎。
浏览 0提问于2013-10-16得票数 1
1回答
我知道这是一种反模式，但在我的RESTful应用程序中，我想记录并抛出。
我有这个密码
log.warn("Cannot determine provider from name: " + name);
throw X.bad("Cannot determine provider from name: " + name);
这是一种不应该发生的情况--这只是一系列if/else if中的最后一个。但是，如果确实发生这种情况，则可能表示前端错误/错误。
我的restful堆栈可以处理异常并将它们映射到HTTP响应。
我还想要一个具有良好堆栈跟踪的日志条目。
浏览 3提问于2014-03-20得票数 0
在CyclicBarrier或CountDownLatch允许我们在不使用synchronized关键字的情况下继续(就像synchronized关键字那样)之前，有没有办法确保java刷新已经完成的写操作的缓存？
浏览 0提问于2011-09-21得票数 2
回答已采纳
1回答
同步工作线程
、、、
我有一个场景，我正试图想出最好的同步方法。我们假设C++11中存在std：：线程，所以不需要担心不同线程库之间的差异等等。
情况是这样的。线程a，主线程，希望将任务分发给一组工作线程。然后，在给出它的最后指示之后，它需要等待所有的线程完成他们的工作。我们不想加入他们，只是等待他们完成他们的任务。然后，线程a必须分析从所有线程收集到的数据，然后向工作人员发出命令，以便再次开始该过程。
简而言之，这就是步骤。
线程a向所有工作线程发送命令x。
线程a等待直到所有的工人完成。
线程a进行处理。
回到1。
你建议我用什么？简单的互斥？条件变量？两者的结合？任何关于如何构造同步尽
浏览 0提问于2013-03-17得票数 4
回答已采纳
我想知道memoryBarrierShared的用处。
实际上，当我查看文档中的屏障函数时:我读到：
对于计算机着色器中任何给定的屏障静态实例，单个工作组中的所有调用都必须在允许任何调用继续进行之前输入它。这确保了在给定的屏障静态实例之前由一次调用编写的值可以在调用相同的屏障静态实例后被其他调用安全地读取。因为调用可能在这些屏障调用之间以未定义的顺序执行，因此在许多情况下，每个顶点或每个修补程序输出变量或任何共享变量的值都将未定义。
因此，如果我们在使用屏障后能够安全地读取值，为什么我们会在一些代码中看到？
memoryBarrierShared();
barrier();
或者是一些
浏览 2提问于2016-09-08得票数 14
回答已采纳
1回答
在Mike的中，他提到：“自定义队列可以作为同步机制来代替锁。”
问题：
1) dispatch_barrier_async的工作方式如何与dispatch_async不同？dispatch_async不是实现了与dispatch_barrier_async同步相同的功能吗？
2)定制队列是唯一的选择吗？我们不能使用主队列进行同步吗？
浏览 7提问于2015-05-23得票数 0
回答已采纳
我有一个使用CyclicBarrier的方法，如下所示：
public void getMessage(Message obj){
CyclicBarrier barrier = new CyclicBarrier(1, new Runnable() {
@Override
public void run() {
synchronized(obj){
System.out.println("--The End --");
}
}
})
浏览 0提问于2010-12-03得票数 2
回答已采纳
2回答
我正在阅读有关垃圾收集器实现的文章，特别是关于动态标记和清除收集器的实现，以及必须使用内存屏障才能允许转变器在标记阶段未完成时工作(从而避免停止世界)的事实。
因此，例如，如果标记的(黑色)对象被mutator修改为指向未标记的(白色)对象，则白色对象必须标记为灰色(标记为活动，但尚未扫描)。
但我找不到如何实现这一点的任何细节:我如何检测黑色对象何时发生变化并在该时刻执行操作？
浏览 0提问于2011-03-15得票数 13
回答已采纳
2回答
Unix信号量问题
、、、
有没有办法用unix信号量来设置它们的值？我需要总是从多个使用者调用post()，并且偶尔调用一个wait()，它将一直等到下一个post()发生。
如何才能做到这一点？
这样做的原因是我正在实现生产者/消费者问题(1个生产者/最多2个消费者)。每个消费者都有一个内部队列，它在其中存储似乎还不能放到输出上的项目，因为仍然有来自其他消费者的其他包丢失，以便它们都以正确的顺序输出(因为它们来自生产者)。当任何一个队列被认为是满的(假设有10个项目)，我希望这个进程等到另一个进程完成它的工作(因为只有2个进程，所以我可以保证其他进程产生的数据包就是我需要开始输出的数据包！)。
我的想法是，每当消费者
浏览 3提问于2010-12-07得票数 0
回答已采纳
3回答
我正在阅读这篇的文章，文章中写道：
事实上，大多数函数调用都充当编译器屏障，无论它们包含自己的编译器屏障还是not.This都排除了内联函数、使用纯属性声明的函数以及使用链接时代码生成的情况。除了这些情况之外，对外部函数的调用甚至比编译器屏障更强，因为编译器不知道该函数的副作用是什么。
这是真实的说法吗？想想这个样本-
std::atomic_bool flag = false;
int value = 0;
void th1 () { // running in thread 1
value = 1;
// use atomic & release to preve
浏览 6提问于2016-11-16得票数 7
回答已采纳
我的目的很简单。我想使用CyclicBarrier和它的reset()方法4次运行3个线程，使用下面的代码。研究了网络中的所有可能的资源，在实践中的并发性，以及Java中的思考。无法以我想要的方式解决它。在Java中，在HorseRace.Java下有一种这样的解决方案，但是已经使用了Executor服务。我只想用CyclicBarrier和reset()方法来做这件事。下面是我的代码和输出，它一直运行到最后，但是在reset()方法之后抛出BrokenBarrierException。
package com.apal.barrier;
import java.util.concurren
浏览 3提问于2014-09-16得票数 3
我无意中发现了CyclicBarrier和Phaser实用程序在中的区别。
我理解CyclicBarrier允许一组线程等待直到所有线程到达一个特定的点。相位器也这样做，但它支持多个阶段。我也明白，CyclicBarrier可以重用。--我认为这个重用工具使它的功能与Phaser相同。
考虑下列方案：
测试相位:
import java.util.concurrent.Phaser;
public class PhaserTest {
public static void main(String[] args) {
Phaser p = new Phaser(3);
浏览 0提问于2018-03-27得票数 7
1回答
现在我实现了我的障碍。但它的效果并不好。
当我运行障碍时间计算代码pthread_barrier_wait消耗180000微秒时，我的障碍消耗390000微秒
我不知道为什么，我想做更快的屏障
这是我的屏障代码
82 pthread_mutex_t mutexwait1;
83 int wait_count = NUM_THREADS;
84 int barrier1234(void) {
85
86 int status, cancel, tmp;
87
浏览 3提问于2012-04-10得票数 0
回答已采纳
当易失性变量读取时，缓存/寄存器数据被刷新，并直接从RAM(主存)读取--这称为读屏障。
Qs执行上述任务的是JVM还是OS？
这些缓存/寄存器是堆栈/堆的一部分吗？
还有一个问题：
堆由JVM(由OS管理)管理？
Java堆栈是由OS(而不是JMV)管理的？
浏览 6提问于2013-09-21得票数 2
我有一个多线程应用程序，它使用屏障来同步工作线程。
在compute()函数的末尾，线程被取消：
...
for(int i=0;i<p; i++){
printf("Thread %lu completed in %d passes\n",threads[i],find_tstat(threads[i])->count);
pthread_cancel(threads[i]);
}
printf("========================================================
浏览 7提问于2021-11-11得票数 0
4回答
我在各种地方(论坛等)都看到了这个参数。常见的答案是帮助高度并发的服务器。尽管如此，我还是找不到sun的官方文件来解释它的功能。另外，它是在Java 6中添加的还是在Java 5中存在的？
(顺便说一句，是许多热点VM参数的好地方)
更新： Java 5不使用此参数启动。
浏览 4提问于2009-07-13得票数 13
回答已采纳
我有一条涉及多个jms队列交互的消息。为了将所有日志关联起来，我希望将java /message.id设置为日志前缀。因此，我将其设置为出站属性。
但是在第二个队列接收器之后，当我想要打印这个属性时，它会给出null。如果我将任何字符串放入它的工作中，但是当我放置uuid时，它会给出空值。
你能不能提供任何建议。
浏览 0提问于2016-05-26得票数 0
回答已采纳
boost::shared_ptr<A> a = boost::shared_ptr<A>(new A);
a->i = 2;
strand.post([a](){assert(a->i == 2)});
或
io_service.post([a](){assert(a->i == 2)});
当我将处理程序发布到thread1中的strand或thread1中时，执行处理程序的thread2是否会在发布之前看到数据更改？
Java有类似的东西执行器，它们会在关系发生之前发生：
在将可运行的线程提交给执行器之前，线程中的操作会在执行开始之前发生。类似
浏览 5提问于2015-08-18得票数 4
回答已采纳
3回答
java中的障碍
、、、、
与c++一样，在访问std::atomics时，使用memory_order_acquire或memory_order_release结合std::atomics::load()和std::atomics::store()，可以部分削弱顺序保证。或者使用std::memory_order_relaxed
我的问题是:在java中这是可能的吗？我的意思是，在java中有什么障碍概念吗？
如果我想错了，请纠正我。
浏览 4提问于2013-11-20得票数 2
回答已采纳
这些天我读到了关于内存栅栏和屏障的文章，它们是同步多线程代码和避免代码重新排序的一种方法。
我通常在Linux操作系统下使用C++进行开发，并且大量使用boost库，但是我找不到任何与它相关的类。您是否知道boost中是否存在记忆屏障，或者是否有实现相同概念的方法？如果不是，我可以看看什么好的库？
浏览 0提问于2010-10-04得票数 2
我的意思是，当我写信给java.util.concurrent.LinkedBlockingQueue，我有一个可见性保证发生-之前。放在队列中的单个对象会发生--在从队列中拉出同一个对象之前。因此，我可以在读取线程中假设，任何其他变量状态都不会比将对象放置到LBQueue的时间更长。
我们在纪事队列中有同样的可见性保证吗？
在任何一种使用风格( methodReader/writer和wire().read().object() )中，我们都有相同的可见性保证吗？
浏览 2提问于2020-01-23得票数 0
回答已采纳
3回答
有人告诉我，volatile关键字可能会在变量的写操作之前增加内存屏障。所以我写了代码：
public class Test {
private Object o;
public Test() {
this.o = new Object();
}
private volatile static Test t;
public static void createInstance() {
t = new Test(); // volatile would insert memory barrier
浏览 1提问于2013-06-03得票数 7
回答已采纳
4回答
我有一个关于使用无锁队列的问题。
假设我有一个单生产者单消费者队列，其中生产者和消费者被绑定到不同的核心。队列元素是共享内存的缓冲区，生产者和消费者在开始时都会对其进行mmapped。
生产者获取一个队列元素，用数据填充缓冲区并将其入队，消费者将该元素出队，读取它并以某种方式处理它。
作为无锁队列的用户，我是否必须显式地确保生产者写入的缓冲区对用户可见？或者，算法核心的CAS (或其他类似的)原语会自动提供屏障吗？
我看到的几个示例使用整数作为有效负载，因此不会出现内存同步的问题。
谢谢,
浏览 5提问于2011-08-08得票数 1
安装程序(安卓设备上的OpenGL ES 3.1 )：
Compute_shader_clear (以PROGRAM_A表示)：
layout (local_size_x = 8, local_size_y = 8) in;
layout(rgba32f, binding=0) writeonly uniform mediump image2D write00;
void main() {
...
imageStore(write00, pixel, vec4(0.0));
}
Compute_shader_main (以PROGRAM_B表示)：
layout (local_size_x
浏览 4提问于2016-04-27得票数 1
回答已采纳
我有以下C代码：
...
data[index] = something;
a_write_memory_barrier();
index = new_index;
...
代码不受锁保护(其他人只读取data和index)，我希望确保在更新data[index]之前存储index。这段代码周围还有对其他变量的内存读写操作，但这些都无关紧要，所以GCC可以自由地对它们进行重新排序(我希望它这样做是为了优化)。只要保证data[index]和index的顺序就足够了。应该如何实现a_write_memory_barrier()来实现这一目标？
浏览 0提问于2012-11-04得票数 2
回答已采纳
我已经阅读了Bloch的第69条(有效的Java)，有一个简单的定时执行框架的例子，它使用3个CountDownLatch来同步线程。另外，Bloch说这个例子可以用1个CyclicBarrier重写。我已经尝试过这样做，并获得了下一个代码：
public static long time(ExecutorService exec, int count) throws InterruptedException, BrokenBarrierException {
CyclicBarrier cyclicBarrier = new CyclicBarrier(co
浏览 0提问于2012-09-13得票数 2
回答已采纳
3回答
我正面临一个循环障碍的问题，请查看下面的代码-
MeetingPoint1.java
public class MeetingPoint1 implements Runnable{
@Override
public void run() {
System.out.println(" MeetingPoint1 one cleared... ");
}
}
MeetingPoint2.java
public class MeetingPoint2 implements Runnable{
@Override
publi
浏览 2提问于2015-05-27得票数 1
2回答
是否有消息队列实现允许通过在消息流中插入“消息屏障”将工作分解为“批处理”？让我澄清一下。在消息屏障之后的消息不应该传递给队列的任何使用者，直到所有消息都被消耗掉为止。有点像同步点。我也希望所有的消费者在他们到达障碍时都能收到通知。
外面有这样的东西吗？
浏览 3提问于2010-03-07得票数 5
回答已采纳
TL/博士:4次重订货中只有1次(而不是2次)被允许进行获取/释放操作，这是真的吗？如果是，为什么？
就目前而言，根据我对获取发布语义的理解，(基本上)
获取操作不允许负载/存储在其上方浮动
发布操作不允许其上方的负载/存储在其下方滑动
但是关于相反的方向的说法却很少。
从一些来源(Jeff的博客和其他的博客，以及一些体系结构手册似乎暗示)，我读到获取/发布操作与相应的(在给定内存位置上的原子op +内存屏障)/(内存屏障+原子op)相当。
他们描述了4种内存障碍，例如，获取操作使用类似于LoadLoad + LoadStore的屏障(发布时类似)。
据我所知，这些障碍(Loa
浏览 0提问于2018-06-30得票数 2
回答已采纳
LMX disruptor的屏障是如何工作的？我知道如何在DSL中使用disruptor。但我找不到一个很好的参考来说明屏障或序列屏障是如何工作的。
例如，我找到了下面的链接，但不确定如何使用Barrier数据结构。
例如，新的BatchEventProcessor()接受一个SequenceBarrier。为什么？我怎样才能创建一个。
浏览 5提问于2013-06-27得票数 1
我读过有关PTX同步功能的详细信息的。
它说有16个“屏障逻辑资源”，您可以指定参数"a“使用哪个屏障。什么是障碍逻辑资源？
我有一段来自外部来源的代码，我知道这是可行的。但是，我无法理解"asm“中使用的语法以及”内存“的功能。我假设"name“代替"%0”，"numThreads“代替"%1"，但是”内存“是什么?冒号在做什么？
__device__ __forceinline__ void namedBarrierSync(int名称，int numThreads) {bar.sync %0，%1；：：“r”(名称)，
浏览 0提问于2018-12-07得票数 2
回答已采纳
我有一个类，代码如下
private readonly object m_lock = new object();
private IClient m_client
private object m_context;
在设置客户端和上下文时，我按如下方式锁定
lock(m_lock)
{
m_client = theClientFromSomewhere;
m_context = contextObject;
}
我的问题是，如果我只需要自己获取m_client，这样做安全吗？
var localClient = m_client;
Debug.Assert(localCl
浏览 3提问于2009-07-23得票数 5
回答已采纳
2回答
如果我有一个初始化的pthread_barrier_t，什么时候可以安全地销毁它？下面的例子安全吗？
pthread_barrier_t barrier;
...
int rc = pthread_barrier_wait(b);
if (rc != PTHREAD_BARRIER_SERIAL_THREAD && rc != 0){
perror("pthread_barrier_wait");
exit(1);
}
if (id == 0){
if(pthread_barrier_destroy(&(threads[t_root].in
浏览 0提问于2009-05-17得票数 6
回答已采纳
3回答
在回收时，垃圾收集器将所有活动对象复制到另一个内存空间，从而丢弃进程中的所有垃圾对象。指向新空间中被复制对象的前向指针被安装到对象的“旧”版本中，以确保收集器正确地更新对该对象的所有剩余引用，并且不会错误地将同一对象复制两次。
显然，这对于“停止世界”的收集者来说非常有效。然而，由于stop- the -world的停顿时间很长，现在大多数垃圾收集器都允许mutator线程与收集器并发运行，只是为了进行初始堆栈扫描而短时间停止mutator。
那么，收集器如何确保对象的“旧”版本在复制时/之后不会被赋值器访问呢？我想象着赋值器可以使用某种类型的读障碍来检查前向指针，然而这对我来说似乎代价很高，
浏览 2提问于2013-01-21得票数 11
回答已采纳
2回答
例如，我有一个独占的基于原子操作的自旋锁实现，如下所示：
bool TryLock(volatile TInt32 * pFlag)
{
return !(AtomicOps::Exchange32(pFlag, 1) == 1);
}
void Lock (volatile TInt32 * pFlag)
{
while (AtomicOps::Exchange32(pFlag, 1) == 1) {
AtomicOps::ThreadYield();
}
}
void Unlock (volatile TInt32 * pFlag)
浏览 2提问于2015-09-19得票数 2
我正在从页面学习JSR-133食谱，在“类别”一节中，作者给出了一个关于内存barriers.Below的示例代码：
我只是不明白为什么在“load u”和“load b”之间有一个“LoadStore”。有人能帮我吗？谢谢。
浏览 1提问于2019-07-22得票数 3
我正试图把我的注意力集中在内存屏障和易失性读写之间的微妙之处。我在这里阅读约瑟夫·阿尔巴哈里的线程文章：
在读/写之前什么时候需要一个内存屏障，以及在什么时候需要它，这是一个绊脚石。在“满栏”一节中的这一节中，他在每次写入后和每次读取之前都设置了一个内存屏障：
class Foo
{
int _answer;
bool _complete;
void A()
{
_answer = 123;
Thread.MemoryBarrier(); // Barrier 1
_complete = true;
Thread.MemoryBarri
浏览 1提问于2017-03-12得票数 3
回答已采纳
boost库(在C++11标准之前)为线程提供了支持。作为其支持的一部分，它还提供了一个“屏障”的实现，这是一个允许同步的简单类。引用
“屏障是一个简单的概念。也被称为会合点，它是多个线程之间的同步点。这个屏障是为特定数量的线程(n)配置的，当线程到达屏障时，它们必须等到所有n个线程都到达。一旦第n个线程到达屏障，所有等待的线程都可以继续运行，并且重新设置屏障。”
截止到Boost 1.54，屏障主要功能的实现情况如下：
bool wait()
{
boost::mutex::scoped_lock lock(m_mutex);
unsigned int gen = m_gen
浏览 0提问于2014-10-04得票数 2
回答已采纳
2回答
文献讨论了在对象的构造器完成其数据结构的分配和初始化之前通告对该对象的引用。这通常涉及到将它放在其他线程可以过早地看到它的地方。据我所知，它涉及一种明确的广告行为，比如当使用听众时。
我的问题与构造函数的实现以及类似情况发生的可能性有关。我可以想象一个构造函数可以用类似如下的东西来实现：
Type t = new Type(...);
在C中的实现可能会这样做：
t = malloc(sizeOf Type);
然后继续初始化所有字段。
如果它可以像这样实现，那么在初始化数据之前，引用t将是非空的。如果另一个线程检查它是否是非空的，那么它将在它完全初始化之前继续使用它。结果将是混乱。
我找不到
浏览 0提问于2020-05-15得票数 1
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
实时音视频
对象存储
即时通信 IM活动推荐
腾讯云开发者
