例如,这是来自Tomcat服务器的堆栈跟踪:
"RMI TCP Accept-0" daemon prio=10 tid=0x091a5800 nid=0x8f1 runnable [0x8b305000]
java.lang.Thread.State: RUNNABLE
at java.net.PlainSocketImpl.socketAccept(Native Method)
at java.net.PlainSocketImpl.accept(PlainSocketImpl.java:408)
- locked <0x911d3c30> (a java.net.SocksSocketImpl)
at java.net.ServerSocket.implAccept(ServerSocket.java:462)
at java.net.ServerSocket.accept(ServerSocket.java:430)
at sun.management.jmxremote.LocalRMIServerSocketFactory$1.accept(LocalRMIServerSocketFactory.java:34)
at sun.rmi.transport.tcp.TCPTransport$AcceptLoop.executeAcceptLoop(TCPTransport.java:369)
at sun.rmi.transport.tcp.TCPTransport$AcceptLoop.run(TCPTransport.java:341)
at java.lang.Thread.run(Thread.java:662)
我的猜测是"锁定"意味着CPU正在等待某种锁定.但是,如果是这种情况,为什么线程的状态列为RUNNABLE而不是BLOCKED？
谢谢.
有什么方法可以覆盖bash陷阱处理程序,这些陷阱处理程序不会永久地删除可能已经设置或可能尚未设置的现有处理程序？如何动态管理陷阱例程的任意链？
有没有办法保存陷阱处理程序的当前状态,以便以后可以恢复？
我正在将应用程序从x86移植到x64.我正在使用Visual Studio 2009; 大多数代码都是C++,有些部分是纯粹的C.在编译x64时我们不支持__asm关键字,而我们的应用程序包含一些内联汇编程序.我没有写这段代码所以我不确切知道应该做什么:
int CallStackSize() {
DWORD Frame;
PDWORD pFrame;
__asm
{
mov EAX, EBP
mov Frame, EAX
}
pFrame = (PDWORD)Frame;
/*... do stuff with pFrame here*/
}
EBP是指向当前函数堆栈的基指针.有没有办法在不使用内联asm的情况下获取堆栈指针？我一直在关注微软提供的内在函数作为内联asm的替代品,但我找不到任何能给我带来帮助的东西.有任何想法吗？
安德烈亚斯询问用pFrame做了什么.这是完整的功能:
int CallStackSize(DWORD frameEBP = 0)
{
DWORD pc;
int tmpint = 0;
DWORD Frame;
PDWORD pFrame, pPrevFrame;
if(!frameEBP) // No frame supplied. Use current.
{
__asm
{
mov EAX, EBP
mov Frame, EAX
}
}
else Frame = frameEBP;
pFrame = (PDWORD)Frame;
do
{
pc = pFrame[1];
pPrevFrame …我正在制作自己的类似Lisp的解释语言,我想做尾调优化.我想从C堆栈中释放我的解释器,这样我就可以管理自己从函数到函数的跳转以及我自己的堆栈魔法来实现TCO.(我真的不是指无堆栈本身,只是调用不向C堆栈添加帧的事实.我想使用我自己的堆栈,不会随着尾调用而增长).就像Stackless Python一样,不像Ruby或者......标准Python我猜.
但是,由于我的语言是Lisp派生词,所有对s表达式的评估目前都是以递归方式完成的(因为这是我想到的最明显的方式来做这种非线性,高度分层的过程).我有一个eval函数,每次遇到函数调用时都会调用Lambda :: apply函数.apply函数然后调用eval来执行函数体,依此类推.相互堆栈饥饿的非尾部C递归.我目前使用的唯一迭代部分是评估一系列连续的s表达式.
(defun f (x y)
(a x y)) ; tail call! goto instead of call.
; (do not grow the stack, keep return addr)
(defun a (x y)
(+ x y))
; ...
(print (f 1 2)) ; how does the return work here? how does it know it's supposed to
; return the value here to be used by print, and how does it know
; how to continue execution here??
那么,我如何避免使用C递归？或者我可以使用跳过c函数的某种goto吗？也许是longjmp？我真的不知道.请耐心等待,我主要是自编(Internet)教程.
为什么下面的代码没有任何崩溃@ runtime？
而且尺寸完全取决于机器/平台/编译器!! 我甚至可以在64位机器上放弃200.如何在OS中检测到主函数中的分段错误？
int main(int argc, char* argv[])
{
int arr[3];
arr[4] = 99;
}
这个缓冲空间来自哪里？这是分配给进程的堆栈吗？
假设someClass是在C#中使用某种方法定义的类int doSomething(void),为简单起见,提供不带参数的构造函数.然后,在C#中,必须在gc堆上创建实例:
someClass c; // legit, but only a null pointer in C#
// c->doSomething() // would not even compile.
c = new someClass(); // now it points to an instance of someclass.
int i = c->doSomething();
现在,如果someClass编译成一些.Net库,你也可以在C++/CLI中使用它:
someClass^ cpp_gcpointer = gcnew someClass();
int i = cpp_gcpointer->doSomething();
那简单!漂亮!这当然假设已经将.Net库的引用添加到项目中并且已经进行了相应的使用声明.
我的理解是,这是前一个C#示例的精确C++/CLI等效(缩写为单行,这不是我感兴趣的点).正确？(对不起,我是这个话题的新手)
但是,在C++中也是如此
someClass cpp_cauto; // in C++ declaration implies instantiation
int i = cpp_cauto.doSomething();
是有效的语法.出于好奇,我今天试了这个.一位同事,看着我的肩膀,愿意打赌它甚至不会编译.他本可以输掉赌注.(这仍然是C#程序集中的类).实际上它产生的结果i与前面例子中的代码相同.
也很漂亮,但是 - 嗯 - 究竟是什么,这里创造了什么？我的第一个猜测是,在我的背后,.Net在gc堆上动态创建一个实例,并且cpp_auto是这个对象的某种包装器,其行为类似于类的实例someClass.但后来我找到了这个页面 …
std::vector和之间有什么区别std::stack？
显然,向量可以删除集合中的项目(虽然比列表慢得多),而堆栈则构建为仅限LIFO的集合.
但是,对于最终项目操作,堆栈更快吗？它是链表还是动态重新分配的数组？
我找不到很多关于堆栈的信息,但是如果我正确地描绘它们(它们类似于实际的线程堆栈;推送,弹出等等 - 以及该top()方法)那么它们似乎非常适合窗口堆叠管理.
cassandra升级后启动时出现此错误.任何的想法？
# cassandra -f
xss = -ea -javaagent:/usr/share/cassandra/lib/jamm-0.2.5.jar -XX:+UseThreadPriorities
-XX:ThreadPriorityPolicy=42 -Xms1920M -Xmx1920M -Xmn200M -XX:+HeapDumpOnOutOfMemoryError -Xss180k
The stack size specified is too small, Specify at least 228k
Error: Could not create the Java Virtual Machine.
Error: A fatal exception has occurred. Program will exit.
要澄清这个问题,请观察c/c ++代码片段:
int a = 10, b = 20, c = 30, d = 40; //consecutive 4 int data values.
int* p = &d; //address of variable d.
现在,在visual studio(2013年测试)中,如果p == hex_value的值(可以在调试器内存窗口中查看),那么,您可以观察到,其他变量a,b,c和d的地址是每个都有12个字节的差异!
那么,如果p == hex_value,则遵循:
&c == hex_value + 0xC (注意十六进制C是十进制的12)
&b == &c + 0xC
&a == &b + 0xC
那么,为什么有12个字节的偏移而不是4个字节 - int只有4个字节？
现在,如果我们声明一个数组:
int array[] = {10,20,30,40};
值10,20,30,40每个都按预期位于4个字节的差异!
任何人都可以解释这种行为吗？
我有一个从大型数组中读取数据的程序,我最初在Visual Studio中将程序划分为两个独立的项目,每个项目分别工作正常,但是当我尝试将它们组合在一起时,程序在调试时滑动了一些步骤.我对C++很新,所以我开始做一些研究,我发现也许我正在用那些巨大的数组填充堆栈,我应该尝试将它们放在堆上.
我决定更改每个数组std::vector并以这种方式初始化它们:
std::vector<double> meanTimeAO = { 0.4437, 0.441, 0.44206, 0.44632, 0.4508, 0.45425,...}
但是当我尝试编译编译器崩溃堆栈溢出后现在更改所有数组后,我以为我通过将数组更改为向量来释放堆栈中的内存空间但是看起来我有相反的结果,为什么呢??
我该如何处理这些大数组呢？(它们是固定不变的值或大小)