SPARK中不允许在干扰上下文中调用易失性函数
SPARK是一种快速、通用的大数据处理框架，它提供了高效的数据处理能力和易于使用的API。在SPARK中，易失性函数指的是具有副作用的函数，即函数执行会改变其外部环境或状态的函数。由于SPARK的分布式计算特性，它需要确保计算的可重复性和一致性，因此不允许在干扰上下文中调用易失性函数。
干扰上下文是指在并行计算中，多个任务同时执行时共享的上下文环境。当一个任务调用易失性函数时，可能会改变共享的上下文环境，导致其他任务的计算结果不确定或产生错误。为了保证计算的正确性和可靠性，SPARK禁止在干扰上下文中调用易失性函数。
在SPARK中，可以使用纯函数来替代易失性函数。纯函数是指不依赖于外部环境或状态，并且对于相同的输入始终产生相同的输出的函数。纯函数不会引起计算结果的不确定性，因此在SPARK中更加安全和可靠。
总结起来，SPARK中不允许在干扰上下文中调用易失性函数是为了保证计算的可重复性和一致性。在编写SPARK应用程序时，应避免使用易失性函数，而是使用纯函数来进行数据处理和计算。
腾讯云提供了一系列与SPARK相关的产品和服务，例如腾讯云数据分析平台（Tencent Cloud DataWorks）、腾讯云弹性MapReduce（Tencent Cloud EMR）等。这些产品和服务可以帮助用户在腾讯云上快速搭建和管理SPARK集群，进行大数据处理和分析。
更多关于腾讯云数据分析平台的信息，请访问：腾讯云数据分析平台
更多关于腾讯云弹性MapReduce的信息，请访问：腾讯云弹性MapReduce
相关·内容
我正在尝试编译类似这样的东西：
#include <list>
class thread
{
public:
static volatile std::list<thread *> threadList; //This is also protected by a mutex
};
volatile std::list<thread *> thread::threadList;
void main()
{
thread A;
thread::threadList.push_back(&A);
thread::threadList.r
浏览 3提问于2011-01-27得票数 0
回答已采纳
1回答
在单线程程序中使用:volatile-mutable限定符和deftype是安全的吗？这是对、和的后续。(这是一个Clojure问题，但我添加了" Java“标记，因为Java程序员也可能对此有深刻的见解。)
我发现，通过在:volatile-mutable中而不是在原子中使用deftype字段，可以显著提高程序的性能，但我很担心，因为deftype的docstring是这样写的：
请注意，要正确使用可变字段非常困难，而且这些字段的出现只是为了便于在Clojure本身中构建更高级别的结构，例如Clojure的引用类型。它们仅供专家使用--如果不稳定-可变或:不同步-可变的语义和含义对
浏览 1提问于2015-05-27得票数 6
回答已采纳
volatile XmlDocument d;
只是想知道为什么这不是编译时错误。我读到过，我们不能使一个局部的字段成为不稳定的。请帮我理解一下。
浏览 1提问于2013-12-01得票数 0
回答已采纳
我对SUMPRODUCT函数有问题。我已经找到了一个不太理想的工作，我想看看是否有人能解释为什么我的理想公式不起作用。下面是我的电子表格的简化视图：
第一个表tabCheckout是我退房的书籍列表和数量(我真的很喜欢随风而去)。(没有公式)
第二个表tabBooks是我的库存。(没有公式)
第五行是一月一日至三十一日(无公式)。
第6行是问题发生的地方。它应该告诉我一个月中每一天的可用数量。
下面是在单元格C6中运行良好的公式：
=INDEX(tabBooks,MATCH($B6,tabBooks[Book],0),2)-SUMPRODUCT((tabCheckout[Checko
浏览 1提问于2015-04-17得票数 0
回答已采纳
考虑以下示例： #include <iostream>
class C {
int intArray[2] { 1, 2 };
int *firstElementPt;
public:
int getFirstElement() volatile {
firstElementPt = intArray;
return *firstElementPt;
};
};
int main()
{
volatile C c;
std::cout << c
浏览 42提问于2019-10-01得票数 3
回答已采纳
我想我理解单变量之前发生的关系。如果我编写了一个易失性字段，那么该字段的所有后续读取都将包含这个新值。编写一个volatile跨越内存障碍并将新值刷新到主内存。
我仍然不清楚在所有其他情况下会发生什么--例如Thread.start()、synchronized或java.util.concurrent中的新锁。他们也跨越了记忆障碍是什么意思？哪些数据从本地缓存刷新到主存？换句话说，跨的范围是什么？
一切都会变红吗？现在回到volatile，它不仅仅刷新单个volatile字段吗？
浏览 6提问于2012-04-02得票数 15
回答已采纳
2回答
我对稀疏很陌生。在稀疏运行过程中，我看到了这样的警告：
警告:参数2中的类型不正确(不同的地址空间)
expected void volatile [noderef] <asn:2>*addr
got void *
基本上，发生这种情况的原因如下：
struct context{
void __iomem *base;
};
readl(const volatile void __iomem* add){
....
....
}
function: foo(){
struct context *var;
readl(var->base); /
浏览 1提问于2014-10-13得票数 3
有时(相当频繁地)当我尝试从iPad应用程序调试崩溃时，LLDB决定不提供太多帮助，并且打印变量(堆栈或类成员)失败。
如果我右击(或CTRL+click)左侧调试窗口中的一个变量，然后"Print description“，我会得到如下错误消息：
Printing description of error:
(NSURLError *) error = <register sp is not available>
或
Printing description of error:
(NSURLError *) error = <register ebp is not
浏览 1提问于2012-12-05得票数 3
回答已采纳
3回答
很多人说“易失性成员函数完全类似于const的工作方式”。
它们的相似之处在于，如果指针被标记为常量/易失性，那么它只能访问标记为常量/易失性的成员函数。
但实际上将一个成员函数定义为const有一个额外的效果，它使该函数成为只读的。在函数中对对象的任何修改都将导致编译器错误。在易失性成员函数中有类似的东西吗？
浏览 0提问于2013-12-06得票数 5
我目前正在做一个示例练习，我发现了一个奇怪的观察，如果我用易失性程序替换AutomicInteger，运行速度会更快。注:我只做阅读操作。
代码：
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.atomic.AtomicInteger;
public class Main {
AtomicInteger integer = new AtomicInteger(100000000);
// volatile int integer= 100000000;
public stat
浏览 5提问于2012-08-18得票数 5
回答已采纳
我读过以下经典的著名文章：
我有一个问题要问：
实际上，假设computeHashCode函数总是返回相同的结果，并且没有副作用(即幂等)，那么甚至可以消除所有的同步。
// Lazy initialization 32-bit primitives
// Thread-safe if computeHashCode is idempotent
class Foo {
private int cachedHashCode = 0;
public int hashCode() {
int h = cachedHashCode;
if (h == 0) {
浏览 2提问于2019-09-19得票数 1
回答已采纳
如何避免在下一个示例中为易失性和非易失性bar++;方法编写相同的主体( foo )？
#include <iostream>
struct A {
int bar = 0;
void foo() { bar++; }
void foo() volatile { bar++; }
};
int main() {
A a;
a.foo();
volatile A va;
va.foo();
}
这个问题完全类似于，但是由于const和non版本不会影响编译器的优化，我想知道:如果对挥发性应用同样的答案，那么对于非易
浏览 3提问于2020-01-05得票数 1
回答已采纳
更新这些易失性函数不能用IF()语句减轻。见下面的答案。1
我刚听说我的excel表需要在马铃薯速度笔记本电脑上运行.
会；
=IF(A1="Test"** ; OFFSET(B5 ; MATCH(C8 ; G10:G15) ; OFFSET(B5 ; MATCH(C8 ; G9:F9)) ; 0)
比仅仅是偏移函数更快
=OFFSET(B5 ; MATCH(C8 ; G10:G15) ; OFFSET(B5 ; MATCH(C8 ; G9:F9)) ; 0)
我的直觉说是..。但是，如果IF()函数的“未使用”部分没有计算或“易失性”，我就找不到明确的答案。
我在单张上有大约
浏览 1提问于2018-01-22得票数 0
回答已采纳
5回答
在过去的几天里，我调试了一个多线程，其中一个线程正在删除另一个线程仍在使用的对象，我意识到，如果我可以让“this”易失性，这个问题会更容易、更快地诊断出来。它会将系统(Symbian OS)上的崩溃转储更改为更具信息性的内容。
那么，有没有什么理由不能，或者不应该呢？
编辑:因此，对于这种情况，确实没有安全的方法来防止或检查。说访问陈旧的类指针的一种解决方案是有一个保存指针的全局变量，并且任何被调用的函数都应该是使用全局变量替代'this‘的静态函数，这是正确的吗？
static TAny* gGlobalPointer = NULL;
#define Harness static
浏览 1提问于2011-07-01得票数 5
回答已采纳
我已经知道自动移动不是使用从Rvalue引用输入返回值的函数。但是为什么呢？
下面是自动移动不使用的示例代码。
Widget makeWidget(Widget&& w) {
....
return w; // Compiler copies w. not move it.
}
如果函数输入来自复制值，自动移动工作。
Widget makeWidget(Widget w) {
....
return w; // Compiler moves w. not copy it.
}
浏览 1提问于2021-12-08得票数 2
回答已采纳
考虑以下代码：
#include <iostream>
#include <type_traits>
struct type {};
int main(int argc, char* argv[]) {
std::cout << std::is_convertible_v<volatile int, int> << " ";
std::cout << std::is_convertible_v<volatile int, volatile int> << "
浏览 0提问于2020-07-03得票数 4
回答已采纳
根据cp首选项，在返回语句中，应该从C++20中移出本地rvalue引用：
从局部变量和参数自动移动
如果表达式是一个(可能是括号大小的)id表达式，该表达式指定类型为
非易失性对象类型或非易失性rvalue引用对象类型(自C++20)。
我尝试了第二个要点()：
#include <cstdio>
struct Foo {};
struct Bar {
Bar() = default;
Bar(const Foo &) {
printf("copy!\n");
}
Bar
浏览 2提问于2020-05-20得票数 4
回答已采纳
1回答
在下面的代码片段中，一个中断例程使用许多数组中的一个来执行它。所使用的数组是同步选择的，而不是异步选择的(在ISR执行时，它永远不会改变)。在单个核心微控制器上(如果体系结构很重要，这个问题假定为STM32L496 )，foo声明中是否需要volatile说明符？
int a[] = {1, 2, 3};
int b[] = {4, 5, 6};
int * foo; //int * volatile foo? int volatile * volatile foo?
main(){
disable_interrupt();
foo = a;
enable_inter
浏览 4提问于2017-10-01得票数 0
回答已采纳
1回答
我需要在公式中使用indirect函数，因为它引用了可以删除的工作表2。我不想在不需要的时候触发间接函数，因为它的易变性。所以我写了这个公式：
=IF(abc=1;"";INDIRECT("Sheet 2!zzz"))
我得到了我想要的结果("“或zzz值)。但它似乎总是不稳定的！我使用这个宏来测试它(可以在上找到)：
Option Base 1
Option Compare Text
'-----------------------
Public jCalcSeq As Long ''' calc
浏览 3提问于2018-03-23得票数 0
1回答
作为初级SQA，我没有对Teradata中表的读写访问权限，只对视图进行读访问。我最近发现了不稳定的表，它们使我的生活变得轻松多了。虽然它们非常有用，但我想知道是否可以使用自动递增的主键(或索引)以及引用完整性约束来创建易失性表？
下面是我一直在使用的SQL。
CREATE VOLATILE TABLE Article (
user_id INTEGER GENERATED BY DEFAULT AS IDENTITY
(
START WITH 1
INCREMENT BY 20
MAXVALUE 2147483647
)
浏览 3提问于2016-02-10得票数 3
回答已采纳
7回答
指针会不稳定吗？
、、
考虑以下代码：
int square(volatile int *p)
{
return *p * *p;
}
现在，volatile关键字指示可以以编译器不知道的方式更改内存位置中的值，或者具有其他未知的副作用(例如，通过信号中断、硬件寄存器或内存映射的I/O进行修改)，即使程序代码中没有修改内容。
那么，当我们将指针声明为易失性时，会发生什么呢？
上面提到的代码是否总是有效的，还是与此有任何不同：
int square(volatile int *p)
{
int a = *p;
int b = *p
return a*b;
}
由于指针是不稳定的，我们最终
浏览 7提问于2015-10-22得票数 23
回答已采纳
1回答
GCC原子内置和易失性
、、、
我在多线程程序中使用了一些全局结构，其中一些成员被多个线程同时修改，另一些则不是。
我没有定义任何这个成员的易失性，但是每当我使用这个成员进行读写时，我都会使用原子内置，比如__sync_fetch_and_add。
问题是，我应该定义这个成员还是整个结构的易失性？
我认为编译器必须访问内存，而不是任何寄存器，因为这个内置(lock前缀)，我应该担心其他成员不会导致竞争条件。
我检查了我的编译器(gcc 4.6.2)的汇编输出，似乎我的假设是正确的。
这是测试代码。
int sum = 0;
for (i=0; i<2000000000; i++) {
sum += i;
}
浏览 1提问于2013-02-04得票数 4
回答已采纳
constvolatile.cpp:91:9:错误:使用T= COMPLETION_WAIT，GENERIC_COMMAND = GENERIC_COMMANDâ将易失性GENERIC_COMMANDâ作为const GENERIC_COMMAND& GENERIC_COMMAND::operator=(const T&)的此参数传递将丢弃限定符-fpermissive
#include <iostream>
using namespace std;
typedef unsigned i
浏览 2提问于2012-07-24得票数 0
2回答
不稳定的int？
、、
在Java中易失性需要int类型吗？据我所知，32位平台读写4字节类型的数据为原子数据。如果我要在并发程序中使用int数据类型，我会有问题吗？
浏览 2提问于2016-12-07得票数 1
回答已采纳
2回答
我们有一个表示原子整数的包装器。在内部，它是使用Windows的InterlockedIncrement()和InterlockedDecrement()函数实现的，这两个函数作用于volatile long变量：
class AtomicInt {
public:
...
operator long() const { return m_value; }
private:
volatile long m_value;
};
我的问题是，上面查询当前值的运算符是否正确(即您总是获得当前值)，或者我是否需要将该方法也声明为volatile，以防止缓存值出现任何问题？
浏览 0提问于2012-02-21得票数 1
回答已采纳
5回答
在C++中，volatile的处理方式与const相同:将指向易失性数据的指针传递给不希望volatile修饰符触发编译错误的函数。
int foo(int* bar) { /* snip */ }
int main()
{
volatile int* baz;
foo(baz); // error: invalid conversion from ‘volatile int*’ to ‘int*’
}
为什么这么危险？显然，对于const修饰符来说，删除它会破坏const正确性；但是存在"volatile正确性“这样的东西吗？我不知道如何将指向易失性数据的指针传递为
浏览 5提问于2010-08-04得票数 7
回答已采纳
我正在编写一个即时编译器，我惊讶地发现，在Win64调用约定中，如此多的x86-64寄存器是非易失性的(被调用方保留的)。在我看来，在所有可以使用非易失性寄存器的函数中，非易失性寄存器只是意味着更多的工作。这在数值计算的情况下尤其如此，在这种情况下，你想在一个叶函数中使用许多寄存器，比如某种高度优化的矩阵乘法。但是，例如，16个SSE寄存器中只有6个是易失性寄存器，因此如果您需要使用更多寄存器，则需要进行大量溢出操作。
所以，是的，我不明白。这里的权衡是什么？
浏览 0提问于2012-05-01得票数 3
回答已采纳
1回答
JMM (Java内存模型)可以自由地重新排序语句。
当然，这在处理多线程环境时特别棘手。
JMM规则规定，volatile和final变量总是在构造函数完成之前完全初始化，并且只有当引用没有从构造函数中“转义”时才能完成。
这意味着“正常”变量(非final和非volatile)不会被任何并发线程看到。
乍一看，我的问题似乎很愚蠢，但实际上并非如此：
在构造函数完成后，是否有任何对象的引用设置为(完成时已经完成了所有变量的初始化，而是简单地到达了‘构造函数’过程的末尾)？在任何JSR中是否有断言它的规则？或者是否存在一种特殊情况，即在客户端构造函数完成之前可以将任何引用发送回客户端？
事实上
浏览 4提问于2012-10-22得票数 3
回答已采纳
在我的平台上(X86，Fedora，gcc 9.1.1)，sig_atomic_t是一个普通的int。
在C++标准中，sig_atomic_t总是与volatile限定符一起使用。
我理解为什么需要volatile，但是为什么它不是类型的一部分呢？
类似于：
using sig_atomic_t = volatile int;
浏览 0提问于2019-06-15得票数 5
2回答
依赖于CPU架构？
、、、、
我想确定下面的代码是否允许CPU获取两次unsafe_variable？让我们假设编译器不会因为volatile和_ReadWriteBarrier (在VS上)而重新排序或优化代码。互斥不能在这里使用，我只关心潜在的双重获取的情况。
我不是CPU设计方面的专家，但我关心的是:推测性执行(包括分支预测和预取技术的性能优化技术)，寄存器和内存位置重命名，以及在一个或两个CPU内使用重新排序缓冲区和存储缓冲区？如果可能的话，请让我知道这里是不是可以进行两次获取。
int function(void* Data) {
size_t _varSize = ((volatile DATA *)D
浏览 0提问于2012-06-11得票数 0
回答已采纳
4回答
我在我的大学里用ARM微控制器上实时系统课程。在我目前正在进行的项目中，我正在实现向量场直方图(VFH)算法。
问题是:我需要在线程之间通信；更具体地说，我希望有一个线程从测距仪获取传感器数据，对其进行必要的转换，并将其存放在队列中。它们，另一个线程必须获得这个数据并处理它，等等。
目前，我使用的是它的一个更简单的版本--一个线程从ADC (SensorAcquisitionHandler)获取数据，另一个线程(至多)将前5个项目的平均值输出到显示器(ControlSignalHandler)。
/* Queue used to store data from the rangefinder
浏览 0提问于2012-10-26得票数 4
回答已采纳
2回答
我正在处理现有的C++代码，该代码具有对对象的volatile引用
volatile vClass & vobj;
我来自C，所以在使用volatile访问内存映射的IO时非常熟悉，如下所示：
*((volatile unsigned int *) 0x12345678) = 0x5
问题
将volatile应用于(对对象的引用)有什么效果？
我猜想它的所有数据成员都继承了volatile，但是如果一个成员函数具有非易失性内存访问(例如
void vClass::AccessMem() {*((unsigned int *) 0x12345678) = 0x5;}
内存访问是否也会变得
浏览 0提问于2018-01-19得票数 1
回答已采纳
3回答
在约翰有价值的回答之后编辑和提炼了我的问题
bool b = true;
volatile bool vb = true;
void f1() { }
void f2() { b = false; }
void(* volatile pf)() = &f1; //a volatile pointer to function
int main()
{
//different threads start here, some of which may change pf
while(b && vb)
{
pf();
}
}
浏览 0提问于2010-10-16得票数 5
回答已采纳
2回答
对所用术语的澄清：
对于静态数组，我指的是静态分配的数组，如: int x10。
问题
我需要声明一个包含易失性元素的静态数组。如果我完全理解易失性限定符是如何工作的，它应该是：
volatile uint8_t *x; // x is a pointer to volatile uint8_t
uint8_t *volatile x; // x is a volatile pointer to uint8_t
volatile uint8_t *volatile x; // x is a volatile pointer to volatile uint8_t
好的，但是现在我需要对静态数
浏览 0提问于2018-06-27得票数 0
这是File类(jdk7)的toPath()方法
private volatile transient Path filePath;
public Path toPath() {
Path result = filePath;
if (result == null) {
synchronized (this) {
result = filePath;
if (result == null) {
result = Fil
浏览 5提问于2013-11-30得票数 1
1回答
挥发性资格损失
、、
我有一个代码运行在一些安全关键汽车模块。以下是对代码的粗略估计：
下面的代码是模块“主模块”的一部分，该模块拥有易失性变量/数组"x_ast“
Main Module.c
//The structure x contains the major data that needs to be stored in case of a crash event. i.e. a real car crash
// x contains data such a vehicle speed, environment data, sensor data, CAN related data,etc. B
浏览 4提问于2016-03-21得票数 0
我通常会看到用于指示const成员函数的const说明符。但是当使用volatile关键字时意味着什么呢？
void f() volatile {}
这对我来说很好，但我不明白这是干什么用的。我在我的搜索中找不到任何有关这方面的信息，所以任何帮助都是非常感谢的。
更新:为了说明这一点，我知道volatile是干什么用的。我只是不知道在这种情况下这意味着什么。
浏览 4提问于2013-05-25得票数 11
回答已采纳
1回答
C函数中静态变量的返回值
、、、
有两种情况：
返回静态易失性变量值的函数。
直接访问易失性变量
Q1:来自函数调用的赋值与直接从易失性变量分配的行为不同吗？
Q2:如果是的话，有标准的方法通过函数返回访问易失性吗？
/*timer.h*/
extern volatile uint8_t directFlag;
uint8_t getReturnFlag(void);
/*timer.c*/
volatile uint8_t directFlag = 0;
static volatile uint8_t returnFlag = 0;
uint8_t getReturnFlag(void)
{
浏览 0提问于2018-01-18得票数 3
回答已采纳
在java中，我们通常使锁变量成为最终的静态变量，这样它就只存在一个副本(尽管我记得我曾经读过，即使是静态变量也可以复制到两个方法的调用堆栈中！)
但我正在处理C和数据同步问题。我已经声明了一个pthread_mutex_t变量，其中N个线程将锁定以访问公共资源。
我不确定的是，这个变量是否是防重复的( java中的静态变量可能被复制，也可能不会被复制到两个方法的调用堆栈中)。因为如果编译器复制了它们，那么我担心锁不起作用。那么，我们是否需要更激进的访问修饰符(如“易失性”)才能使其真正奇异呢？
浏览 1提问于2019-06-21得票数 2
回答已采纳
3回答
为什么volatile对象不能调用非volatile成员函数？
在const的情况下，调用非const成员函数违反了对象的一致性，因此是被禁止的。但是为什么在volatile的案例中
浏览 0提问于2011-11-08得票数 6
回答已采纳
1回答
java中断是否具有易失性？
、、、、
如果一个线程中断另一个线程，中断状态是否立即可见(例如，它是否存在可见性问题)？
最重要的是，我想知道你有没有用过干扰？一个易失性的布尔标志似乎更可靠。
浏览 1提问于2015-02-12得票数 6
回答已采纳
2回答
写入时复制的“标准”代码如下所示：
...
private volatile SomeClass object;
private ReentrantLock lock = new ReentrantLock();
public change (...) {
lock.lock(); //set lock on write
try {
SomeClass newObject = new SomeClass();
//do something with new object
...
//set new objec
浏览 7提问于2016-07-17得票数 1
我正在创建一个小程序来度量boost::shared_ptr和boost::intrusive_ptr类型容器之间的性能差异。为了防止编译器优化复制，我将变量声明为易失性。循环如下所示：
// TestCopy measures the time required to create n copies of the given container.
// Returns time in milliseconds.
template<class Container>
time_t TestCopy(const Container & inContainer, std::siz
浏览 6提问于2011-05-25得票数 9
回答已采纳
2回答
考虑以下示例：
{
int x;
(void)x; // silence the "unused" warning
...
}
这是否会因为x未初始化而导致未定义的行为？如果是，那么这是否意味着在下面的代码中，编译器必须发出内存读取指令(以读取指针对象)？
volatile char* p=getP();
(void)*p;
我对与此相关的C和C++规则都很感兴趣，以防它们不同。
浏览 1提问于2019-10-15得票数 7
阅读的雪花文档，结果重用必须满足的条件之一是：
查询不包括用户定义函数(UDF)或外部函数.
在对这个微不足道的UDF和视图进行了一些实验之后：
create function trivial_function(x number)
returns number
as
$$
x
$$
;
create view redo as select trivial_function($1) as col1, $2 as col2
from values (1,2), (3,4);
我认为这个条
浏览 3提问于2021-05-01得票数 1
1回答
该数据库包含一个用户表。只要用户的用户名是发送到数据库的数据的一部分(即:通过函数)，就会将用户添加到表中，并且用户名在表中应该是唯一的。在任何给定的函数调用中，单个用户名也可能出现多次。
对于每个用户名，我希望获取其现有ID或将其插入到users表中并返回ID。
我提出的解决方案是一个稳定的函数，它首先尝试从users表中进行选择，如果失败，它将调用一个易失性助手函数，该函数试图插入到用户的表中。我更喜欢稳定，因为函数的结果对于事务的其余部分是相同的，所以我希望在多次包含用户名的情况下，或者在将其传递给也在查找其ID的其他函数的情况下，对其进行优化。
我的问题是:我的初始函数的稳定是否意味着
浏览 2提问于2011-09-10得票数 0
public class Stuff {
private final Timer timer = new Timer(true);
public static final int DEFAULT_TIMEOUT = 1500;
private volatile int timeout = DEFAULT_TIMEOUT;
public void doStuff(OtherStuff) {
...
timer.schedule(timeout, ...);
}
public void setTimeout(int timeout) {
浏览 4提问于2012-11-27得票数 4
问题是：。使用std::fill()本身并不总是有帮助-编译器可能会决定以后不会访问内存块，因此擦除它是浪费时间和消除擦除代码。
建议
{
char buffer[size];
//obtain and use password
std::fill_n( (volatile char*)buffer, size, 0);
}
目的是在看到volatile关键字时，编译器不会试图消除对std::fill_n()的调用。
volatile关键字是否总是阻止编译器修改代码删除的内存？
浏览 6提问于2010-09-24得票数 8
回答已采纳
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
对象存储
即时通信 IM
腾讯会议活动推荐
腾讯云开发者
