GDB多进程/多线程调试实战例子

在gcc编译的时候，记得附加 -lpthread参数, 否则会出现 undefined reference to ‘pthread_create’ 的错误.
(因为在链接的时候，无法找到phread库中哥函数的入口地址，于是链接会失败。)

例程

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63

#include <stdio.h>
#include <pthread.h>
#include <unistd.h>

void processA();
void processB();
void *processAworker(void *arg);

int main(int argc, const char *argv[])
{
		int pid;

		pid = fork();

		if (pid != 0)
				processA();
		else
				processB();

		return 0;
}

void processA()
{
		pid_t pid = getpid();
		char prefix[] = "ProcessA: ";
		char tprefix[] = "thread ";
		int tstatus;
		pthread_t pt;

		printf("%s%lu %s\n", prefix, pid, "step1");

		tstatus = pthread_create(&pt, NULL, processAworker, NULL);
		if (tstatus != 0)
		{
				printf("ProcessA: Can not create new thread.");
		}

		processAworker(NULL);
		sleep(1);
}

void *processAworker(void *arg)
{
		pid_t pid = getpid();
		pthread_t tid = pthread_self();
		char prefix[] = "ProcessA: ";
		char tprefix[] = "thread ";

		printf("%s%lu %s%lu %s\n", prefix, pid, tprefix, tid, "step2");
		printf("%s%lu %s%lu %s\n", prefix, pid, tprefix, tid, "step3");

		return NULL;
}

void processB()
{
		pid_t pid = getpid();
		char prefix[] = "ProcessB: ";
		printf("%s%lu %s\n", prefix, pid, "step1");
		printf("%s%lu %s\n", prefix, pid, "step2");
		printf("%s%lu %s\n", prefix, pid, "step3");
}

输出

[cnwuwil@centos c-lab]$ ./test
ProcessA: 802 step1
ProcessB: 803 step1
ProcessB: 803 step2
ProcessB: 803 step3
ProcessA: 802 thread 3077555904 step2
ProcessA: 802 thread 3077555904 step3
ProcessA: 802 thread 3077553008 step2
ProcessA: 802 thread 3077553008 step3

GDB多进程调试命令

• set follow-fork-mode [parent|child] set detach-on-fork [on|off]

• 查询正在调试的进程：info inferiors
• 切换调试的进程： inferior +inferior number
• catch fork命令可以捕获进程的创建
• attach + pid ， 可以附到一个正在运行的进程上进行调试

. . .

• 01 SIGHUP 挂起（hangup）
• 02 SIGINT 中断，当用户从键盘按^c键或^break键时
• 03 SIGQUIT 退出，当用户从键盘按quit键时
• 04 SIGILL 非法指令
• 05 SIGTRAP 跟踪陷阱（trace trap），启动进程，跟踪代码的执行
• 06 SIGIOT IOT指令
• 07 SIGEMT EMT指令
• 08 SIGFPE 浮点运算溢出
• 09 SIGKILL 杀死、终止进程
• 10 SIGBUS 总线错误
• 11 SIGSEGV 段违例（segmentation violation），进程试图去访问其虚地址空间以外的位置
• 12 SIGSYS 系统调用中参数错，如系统调用号非法
• 13 SIGPIPE 向某个非读管道中写入数据
• 14 SIGALRM 闹钟。当某进程希望在某时间后接收信号时发此信号
• 15 SIGTERM 软件终止（software termination）
• 16 SIGUSR1 用户自定义信号1
• 17 SIGUSR2 用户自定义信号2
• 18 SIGCLD 某个子进程死
• 19 SIGPWR 电源故障

基本解释

基本解释：extern可以置于变量或者函数前，以标示变量或者函数的定义在别的文件中，提示编译器遇到此变量和函数时在其他模块中寻找其定义。此外extern也可用来进行链接指定。

也就是说extern有两个作用:

• 当它与”C”一起连用时，如: extern “C” void fun(int a, int b);则告诉编译器在编译fun这个函数名时按着C的规则去翻译相应的函数名而不是C++的，C++的规则在翻译这个函数名时会把fun这个名字变得面目全非，可能是fun@aBc_int_int#%$也可能是别的，这要看编译器的”脾气”了(不同的编译器采用的方法不一样)，为什么这么做呢，因为C++支持函数的重载啊，在这里不去过多的论述这个问题，如果你有兴趣可以去网上搜索，相信你可以得到满意的解释!

• 当extern不与”C”在一起修饰变量或函数时，如在头文件中: extern int g_Int; 它的作用就是声明函数或全局变量的作用范围的关键字，其声明的函数和变量可以在本模块或其他模块中使用，记住它是一个声明不是定义!也就是说B模块(编译单元)要是引用模块(编译单元)A中定义的全局变量或函数时，它只要包含A模块的头文件即可,在编译阶段，模块B虽然找不到该函数或变量，但它不会报错，它会在链接时从模块A生成的目标代码中找到此函数。

extern 变量

在一个源文件里定义了一个数组：char a[6];
在另外一个文件里用下列语句进行了声明：extern char *a；
请问，这样可以吗？
答案与分析：

• 不可以，程序运行时会告诉你非法访问。原因在于，指向类型T的指针并不等价于类型T的数组。extern char *a声明的是一个指针变量而不是字符数组，因此与实际的定义不同，从而造成运行时非法访问。应该将声明改为extern char a[ ]。
• 例子分析如下，如果a[] = “abcd”,则外部变量a=0x61626364 (abcd的ASCII码值)，*a显然没有意义显然a指向的空间（0x61626364）没有意义，易出现非法内存访问。
• 这提示我们，在使用extern时候要严格对应声明时的格式，在实际编程中，这样的错误屡见不鲜。
• extern用在变量声明中常常有这样一个作用，你在.c文件中声明了一个全局的变量，这个全局的变量如果要被引用，就放在.h中并用extern来声明。

extern “c”

在C++环境下使用C函数的时候，常常会出现编译器无法找到obj模块中的C函数定义，从而导致链接失败的情况，应该如何解决这种情况呢
答案与分析：

C++语言在编译的时候为了解决函数的多态问题，会将函数名和参数联合起来生成一个中间的函数名称，而C语言则不会，因此会造成链接时找不到对应函数的情况，此时C函数就需要用extern “C”进行链接指定，这告诉编译器，请保持我的名称，不要给我生成用于链接的中间函数名。
下面是一个标准的写法：

1
2
3
4
5
6
7
8
9
10
11
12
13
14

//在.h文件的头上
#ifdef __cplusplus
#if __cplusplus
extern "C"{
　#endif
　#endif /* __cplusplus */ 
　…
　…
　//.h文件结束的地方
　#ifdef __cplusplus
　#if __cplusplus
}
#endif
#endif /* __cplusplus */

定义放在头文件还是源文件中?

常常见extern放在函数的前面成为函数声明的一部分，那么，C语言的关键字extern在函数的声明中起什么作用？
答案与分析：

如果函数的声明中带有关键字extern，仅仅是暗示这个函数可能在别的源文件里定义，没有其它作用。即下述两个函数声明没有明显的区别：
extern int f(); 和int f();
当然，这样的用处还是有的，就是在程序中取代include “*.h”来声明函数，在一些复杂的项目中，我比较习惯在所有的函数声明前添加extern修饰。关于这样做的原因和利弊可见下面的这个例子：“用extern修饰的全局变量”

(1)在test1.h中有下列声明 :

1
2
3
4
5

#ifndef TEST1H
#define TEST1H
extern char g_str[]; // 声明全局变量g_str
void fun1();
#endif

(2)在test1.cpp中 :

1
2
3

#include "test1.h"
char g_str[] = "123456"; // 定义全局变量g_str
void fun1() { cout << g_str << endl; }

(3)以上是test1模块， 它的编译和链接都可以通过,如果我们还有test2模块也想使用g_str,只需要在原文件中引用就可以了 :

1
2

#include "test1.h"
void fun2()    { cout << g_str << endl;    }

以上test1和test2可以同时编译链接通过，如果你感兴趣的话可以用ultraEdit打开test1.obj,你可以在里面找到”123456”这个字符串,但是你却不能在test2.obj里面找到，这是因为g_str是整个工程的全局变量，在内存中只存在一份,test2.obj这个编译单元不需要再有一份了，不然会在链接时报告重复定义这个错误!

(4) 有些人喜欢把全局变量的声明和定义放在一起，这样可以防止忘记了定义，如把上面test1.h改为

extern char g_str[] = "123456"; // 这个时候相当于没有extern

然后把test1.cpp中的g_str的定义去掉,这个时候再编译链接test1和test2两个模块时，会报链接错误，这是因为你把全局变量g_str的定义放在了头文件之后，

test1.cpp这个模块包含了test1.h所以定义了一次g_str,而test2.cpp也包含了test1.h所以再一次定义了g_str,这个时候链接器在链接test1和test2时发现两个g_str。如果你非要把g_str的定义放在test1.h中的话，那么就把test2的代码中#include “test1.h”去掉 换成:

1
2

extern char g_str[];
void fun2()   {  cout << g_str << endl;   }

这个时候编译器就知道g_str是引自于外部的一个编译模块了，不会在本模块中再重复定义一个出来，但是我想说这样做非常糟糕，因为你由于无法在test2.cpp中使用#include “test1.h”,那么test1.h中声明的其他函数你也无法使用了，除非也用都用extern修饰，这样的话你光声明的函数就要一大串，而且头文件的作用就是要给外部提供接口使用的，所以 请记住， 只在头文件中做声明，真理总是这么简单。

extern 和 static

• extern 表明该变量在别的地方已经定义过了,在这里要使用那个变量.
• static 表示静态的变量，分配内存的时候, 存储在静态区,不存储在栈上面.

static 作用范围是内部链接的关系, 和extern有点相反.它和对象本身是分开存储的,extern也是分开存储的,但是extern可以被其他的对象用extern 引用,而static 不可以,只允许对象本身用它. 具体差别首先，static与extern是一对“水火不容”的家伙，也就是说extern和static不能同时修饰一个变量；其次，static修饰的全局变量声明与定义同时进行，也就是说当你在头文件中使用static声明了全局变量后，它也同时被定义了；最后，static修饰全局变量的作用域只能是本身的编译单元，也就是说它的“全局”只对本编译单元有效，其他编译单元则看不到它,如:

(1)test1.h :

1
2
3
4
5

#ifndef TEST1H
#define TEST1H
static char g_str[] = "123456"; 
void fun1();
#endif

(2)test1.cpp :

1
2

#include "test1.h"
void fun1()  {   cout << g_str << endl;  }

(3)test2.cpp :

1
2

#include "test1.h"
void fun2()  {   cout << g_str << endl;  }

以上两个编译单元可以链接成功, 当你打开test1.obj时，你可以在它里面找到字符串”123456”,同时你也可以在test2.obj中找到它们，它们之所以可以链接成功而没有报重复定义的错误是因为虽然它们有相同的内容，但是存储的物理地址并不一样，就像是两个不同变量赋了相同的值一样，而这两个变量分别作用于它们各自的编译单元。 也许你比较较真，自己偷偷的跟踪调试上面的代码,结果你发现两个编译单元（test1,test2）的g_str的内存地址相同，于是你下结论static修饰的变量也可以作用于其他模块，但是我要告诉你，那是你的编译器在欺骗你，大多数编译器都对代码都有优化功能，以达到生成的目标程序更节省内存，执行效率更高，当编译器在链接各个编译单元的时候，它会把相同内容的内存只拷贝一份，比如上面的”123456”, 位于两个编译单元中的变量都是同样的内容，那么在链接的时候它在内存中就只会存在一份了，如果你把上面的代码改成下面的样子，你马上就可以拆穿编译器的谎言:

(1)test1.cpp:

1
2
3
4
5
6

#include "test1.h"
void fun1()
{
    g_str[0] = 'a';
    cout << g_str << endl;
}

(2)test2.cpp :

1
2

#include "test1.h"
void fun2()  {  cout << g_str << endl;  }

(3) :

1
2
3
4

void main()     {
    fun1(); // a23456
    fun2(); // 123456
}

这个时候你在跟踪代码时，就会发现两个编译单元中的g_str地址并不相同，因为你在一处修改了它，所以编译器被强行的恢复内存的原貌，在内存中存在了两份拷贝给两个模块中的变量使用。正是因为static有以上的特性，所以一般定义static全局变量时，都把它放在原文件中而不是头文件，这样就不会给其他模块造成不必要的信息污染，同样记住这个原则吧！

extern 和const

C++中const修饰的全局常量据有跟static相同的特性，即它们只能作用于本编译模块中，但是const可以与extern连用来声明该常量可以作用于其他编译模块中, 如extern const char g_str[];
然后在原文件中别忘了定义: const char g_str[] = “123456”;

所以当const单独使用时它就与static相同，而当与extern一起合作的时候，它的特性就跟extern的一样了！所以对const我没有什么可以过多的描述，我只是想提醒你，const char* g_str = "123456" 与 const char g_str[] ="123465"是不同的， 前面那个const 修饰的是

char *

而不是g_str,它的g_str并不是常量，它被看做是一个定义了的全局变量（可以被其他编译单元使用）， 所以如果你像让char*g_str遵守const的全局常量的规则，最好这么定义const char* const g_str="123456".

PHP 超级全局变量概绍

PHP中预定义了几个超级全局变量（superglobals） ，

这意味着它们在一个脚本的全部作用域中都可用。

你不需要特别说明，就可以在函数及类中使用。

PHP 超级全局变量列表:

• $GLOBALS
• $_SERVER
• $_REQUEST
• $_POST
• $_GET
• $_FILES
• $_ENV
• $_COOKIE
• $_SESSION

$GLOBALS

$GLOBALS 是PHP的一个超级全局变量组，

在一个PHP脚本的全部作用域中都可以访问。

$GLOBALS 是一个包含了全部变量的全局组合数组。变量的名字就是数组的键。

以下实例介绍了如何使用超级全局变量 $GLOBALS:

1
2
3
4
5
6
7
8
9
10
11
12

<?php 
$x = 75; 
$y = 25;
 
function addition() 
{ 
$GLOBALS['z'] = $GLOBALS['x'] + $GLOBALS['y']; 
}
 
addition(); 
echo $z; 
?>

以上实例中 z 是一个$GLOBALS数组中的超级全局变量，
该变量同样可以在函数外访问。

$_SERVER

$_SERVER 是一个包含了诸如头信息(header)、路径(path)、以及脚本位置(script locations)等等信息的数组。

这个数组中的项目由 Web 服务器创建。

不能保证每个服务器都提供全部项目；服务器可能会忽略一些，或

者提供一些没有在这里列举出来的项目。

以下实例中展示了如何使用$_SERVER中的元素:

1
2
3
4
5
6
7
8
9
10
11
12
13

<?php 
echo $_SERVER['PHP_SELF'];
echo "<br>";
echo $_SERVER['SERVER_NAME'];
echo "<br>";
echo $_SERVER['HTTP_HOST'];
echo "<br>";
echo $_SERVER['HTTP_REFERER'];
echo "<br>";
echo $_SERVER['HTTP_USER_AGENT'];
echo "<br>";
echo $_SERVER['SCRIPT_NAME'];
?>

$_REQUEST

PHP $_REQUEST 用于收集HTML表单提交的数据。

以下实例显示了一个输入字段（input）及提交按钮(submit)的表单(form)。

当用户通过点击 “Submit” 按钮提交表单数据时,

表单数据将发送至

在这个实例中，我们指定文件来处理表单数据。

如果你希望其他的PHP文件来处理该数据，你可以修改该指定的脚本文件名。

然后，我们可以使用超级全局变量 $_REQUEST 来收集表单中的 input 字段数据:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

 <html>
<body>

<form method="post" action="<?php echo $_SERVER['PHP_SELF'];?>">
Name: <input type="text" name="fname">
<input type="submit">
</form>

<?php 
$name = $_REQUEST['fname']; 
echo $name; 
?>

</body>
</html>

$_POST

PHP $_POST 被广泛应用于收集表单数据，

在HTML form标签的指定该属性：”method=”post”。

以下实例显示了一个输入字段（input）及提交按钮(submit)的表单(form)。

当用户通过点击 “Submit” 按钮提交表单数据时,

表单数据将发送至

在这个实例中，我们指定文件来处理表单数据。

如果你希望其他的PHP文件来处理该数据，你可以修改该指定的脚本文件名。

然后，我们可以使用超级全局变量 $_POST 来收集表单中的 input 字段数据:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

<html>
<body>

<form method="post" action="<?php echo $_SERVER['PHP_SELF'];?>">
Name: <input type="text" name="fname">
<input type="submit">
</form>

<?php 
$name = $_POST['fname']; 
echo $name; 
?>

</body>
</html>

$_GET

PHP $_GET 同样被广泛应用于收集表单数据，

在HTML form标签的指定该属性：”method=”get”。

$_GET 也可以收集URL中发送的数据。

假定我们有一个包含参数的超链接HTML页面：

1
2
3
4
5
6
7

<html>
<body>

<a href="test_get.php?subject=PHP&web=runoob.com">Test $GET</a>

</body>
</html>

当用户点击链接 “Test $GET”, 参数 “subject” 和 “web” 将发送至”test_get.php”,

你可以在 “test_get.php” 文件中使用 $_GET 变量来获取这些数据。

以下实例显示了 “test_get.php” 文件的代码:

1
2
3
4
5
6
7
8
9

<html>
<body>

<?php 
echo "Study " . $_GET['subject'] . " at " . $_GET['web'];
?>

</body>
</html>

$_REQUEST、$_POST、$_GET的区别和联系小结

1. $_REQUEST

php中$_REQUEST可以获取以POST方法和GET方法提交的数据，但是速度比较慢

2. $_GET

用来获取由浏览器通过GET方法提交的数据。GET方法他是通过把参数数据加在提交表单的action属性所指的URL中，值和表单内每个字段一一对应，然后在URL中可以看到，但是有如下缺点：

• 1. 安全性不好，在URL中可以看得到
• 1. 传送数据量较小，不能大于2KB。

3. $_POST

用来获取由浏览器通过POST方法提交的数据。POST方法他是通过HTTP POST机制，将表单的各个字段放置在HTTP HEADER内一起传送到action属性所指的URL地址中，用户看不到这个过程。他提交的大小一般来说不受限制，但是具体根据服务器的不同，还是略有不同。相对于_GET方式安全性略高

4. $_REQUEST、$_POST、$_GET 的区别和联系

$_REQUEST[“参数”]具用$_POST[“参数”] $_GET[“参数”]的功能,但是$_REQUEST[“参数”]比较慢。通过post和get方法提交的所有数据都可以通过$_REQUEST数组[“参数”]获得