也许从平台到平台不同,但是
当我使用gcc编译并运行下面的代码时,我每次都在ubuntu 11.10中得到0.
#include <stdio.h>
#include <stdlib.h>
int main()
{
double *a = (double*) malloc(sizeof(double)*100)
printf("%f", *a);
}
为什么malloc表现得像这样,即使有calloc？
是不是意味着只是将值初始化为0会产生不必要的性能开销,即使您有时不想要它也是如此？
编辑:哦,我之前的例子不是initiazling,但碰巧使用"新鲜"块.
我正在寻找的是为什么它在分配一个大块时初始化它:
int main()
{
int *a = (int*) malloc(sizeof(int)*200000);
a[10] = 3;
printf("%d", *(a+10));
free(a);
a = (double*) malloc(sizeof(double)*200000);
printf("%d", *(a+10));
}
OUTPUT: 3
0 (initialized)
但感谢您指出在进行mallocing时存在安全原因!(没想过).当分配新块或大块时,它必须初始化为零.
Linux内核代码使用"statement-expression"和typeof扩展,使其只能在gcc下编译.
我想的更多,更没有意义.
它违背了可移植性和标准C的目的.(现在linux内核代码需要一个支持gcc扩展的特定编译器).
这是一个糟糕的设计选择还是有特定的理由让linux内核代码特定于gcc？
编辑:当我说它破坏了可移植性时,我在不同的环境中使用它.我在思考,通过符合标准C,它将被任何支持标准C的编译器所接受(这正是创建标准的目的 - 统一C的所有不同方言),因此更加便携.当然,由于gcc如此受欢迎,并且gcc支持zillion架构,因此这条线几乎毫无意义.我只是问是否有一个特定的理由背后不符合标准C.
好的,所以我正在阅读有关同步的内容,并且我阅读了各种算法,例如自旋锁,信号量和互斥锁,以避免竞争条件.
但是,当多个进程完全同时访问数据时,这些算法无法阻止SMP中的竞争条件.
例如,假设处理器A中的线程1运行锁定(mutex1); 退出(1000); 解锁(mutex1);
处理器B中的线程2运行锁定(mutex1); 存款(1000); 存款(1000); 解锁(mutex1);
当两个线程在相同时间运行时,两个线程将同时处于临界区.
唯一的解决方案(应该是硬件级别)将使每个处理器彼此略微偏离,但它会破坏并行性的目的.
是否有任何硬件级别支持以避免多个处理器尝试在同一时间获取锁定的情况？
(这不是原子性问题,而是精确并行问题,我想知道SMP如何处理它).
(标题是误导性的,因为垃圾收集器只收集对象,但我发现这个标题更直接)
假设我有一个Android应用程序,在名为Global的类中有一个名为"userid"的静态变量(初始化时为null).
如果我将"userid"变量设置为Android应用程序生命周期的某个值,比如说Global.userid ="myid",那么当Android应用程序还活着时,这个变量是否可能变为null？
换句话说,Android VM是否有可能卸载Global类并由于低内存问题而"杀死"这个全局静态变量而不会杀死整个Android应用程序？
我担心在应用程序运行时userid突然变为null(由于内存不足问题),因此崩溃了整个应用程序.
编辑 我误解了一些概念(在申请流程与活动之间).谢谢你的回答!
GCC具有一个表达式表达式功能,允许将宏定义为:
#define maxint(a,b) \
({int _a = (a), _b = (b); _a > _b ? _a : _b; })
这在Visual Studio中是非法的.
在microsoft visual studio中是否有相同的功能？(我知道,我最好使用GCC.但我只是好奇).
或者,我们是否只需要使用内联函数？
try
{
Connection conn = ... MySQL connection ...;
conn.setAutoCommit(false); // transaction starts
.... do something ....
}
catch (MySQLException e)
{
try {
conn.rollback();
}
catch (Exception e)
{
// What happens now?
}
}
对于MySQL服务器(InnoDB Engine),如果事务的rollback()失败会发生什么？(即当rollback()正在运行时网络正常运行,等等...)
这是否意味着数据库仍然存在损坏,或者MySQL服务器是否有办法从"未完成"的回滚中恢复？
可能重复:
为什么不能在抱着螺旋锁的情况下睡觉？
据我所知,自旋锁应该在短时间内使用,并且只能在代码中选择,例如中断处理程序,其中不允许休眠(抢占).
但是,我不知道为什么会出现这样的"规则",即拿着螺旋锁时根本不应该睡觉.我知道这不是推荐的做法(因为它对性能有害),但我认为没有理由为什么睡眠不应该被允许进入自旋锁.
获取信号量时无法保持自旋锁,因为在等待信号量时可能需要休眠,而且在持有自旋锁时无法入睡(来自Robert Love的"Linux内核开发").
我能看到的唯一原因是出于可移植性的原因,因为在单处理器中,自旋锁被实现为禁用中断,并且通过禁用中断,当然不允许休眠(但是休眠不会破坏SMP系统中的代码).
但我想知道我的推理是否正确或是否还有其他原因.
在linux中,container_of宏被包含在看似"额外"的括号中:
#define container_of(ptr, type, member) ({ \
const typeof( ((type *)0)->member ) *__mptr = (ptr);
(type *)( (char *)__mptr - offsetof(type,member) );})
而不是它,我们可以使用
#define container_of(ptr, type, member) { \
const typeof( ((type *)0)->member ) *__mptr = (ptr);
(type *)( (char *)__mptr - offsetof(type,member) );}
？
括号是强制性的还是只是为了预防？
在静态方法URL.setURLStreamHandlerFactory的Java文档中,有一条警告"在给定的Java虚拟机中最多可以调用一次此方法".
我简要地看了一下源代码,在URL类中有一个静态实例变量:
static URLStreamHandlerFactory factory;
和setURLStreamHandlerFactory只是将工厂分配给这个变量:
public static void setURLStreamHandlerFactory(URLStreamHandlerFactory fac) {
synchronized (streamHandlerLock) {
if (factory != null) {
throw new Error("factory already defined");
}
SecurityManager security = System.getSecurityManager();
if (security != null) {
security.checkSetFactory();
}
handlers.clear();
factory = fac;
}
}
允许多次调用此方法将导致覆盖此工厂实例变量,但我不明白为什么Java会想要阻止此行为.
为什么Java要求每个JVM只能调用一次此方法？
假设我们有以下代码:
if (timeout > jiffies)
{
/* we did not time out, good ... */
}
else
{
/* we timed out, error ...*
}
当jiffies值不溢出时,此代码工作正常.但是,当jiffies溢出并回绕到零时,此代码无法正常工作.
Linux显然提供了用于处理此溢出问题的宏
#define time_before(unknown, known) ((long)(unkown) - (long)(known) < 0)
当用这个宏替换时,上面的代码应该是安全的溢出:
// SAFE AGAINST OVERFLOW
if (time_before(jiffies, timeout)
{
/* we did not time out, good ... */
}
else
{
/* we timed out, error ...*
}
但是,time_before(和其他时间_宏)背后的理由是什么？
time_before(jiffies,timeout)将扩展为
((long)(jiffies) - (long)(timeout) < 0)
这段代码如何防止溢出问题？