版权声明：本文为博主原创文章，未经博主允许不得转载。

1. sundh@linhaoIPTV:~$ ulimit -a
2. core file size          (blocks, -c) 0
3. data seg size           (kbytes, -d) unlimited
4. scheduling priority             (-e) 0
5. file size               (blocks, -f) unlimited
6. pending signals                 (-i) 31675
7. max locked memory       (kbytes, -l) 64
8. max memory size         (kbytes, -m) unlimited
9. open files                      (-n) 1024
10. pipe size            (512 bytes, -p) 8
11. POSIX message queues     (bytes, -q) 819200
12. real-time priority              (-r) 0
13. stack size              (kbytes, -s) 8192
14. cpu time               (seconds, -t) unlimited
15. max user processes              (-u) 31675
16. virtual memory          (kbytes, -v) unlimited
17. file locks                      (-x) unlimited

1. //test2.cpp
2. #include <iostream>
3. #include <string.h>
4. #include <pthread.h>
5. #include <stdio.h>
6. using namespace std;
7. void* func(void*a)
8. {
9. cout << "enter func" << endl;
10. cout << "enter func" << endl;
11. int b[1024*1024*2] = {0};
12. }
13. int main()
14. {
15. int a[1024*1024*3/2]={0};
16. pthread_t  pthread ;
17. pthread_create(&pthread, NULL, func, NULL);
18. cout << "This is a test" << endl;
19. //pthread_join(pthread, NULL);
20. return 0;
21. }

1. //test1.cpp
2. #include <iostream>
3. #include <string.h>
4. #include <pthread.h>
5. #include <stdio.h>
6. using namespace std;
7. void* func(void*a)
8. {
9. cout << "enter func" << endl;
10. cout << "enter func" << endl;
11. int b[1024*1024*5] = {0};
12. }
13. int main()
14. {
15. int a[1024*1024*5]={0};
16. pthread_t  pthread ;
17. pthread_create(&pthread, NULL, func, NULL);
18. cout << "This is a test" << endl;
19. //pthread_join(pthread, NULL);
20. return 0;
21. }

1. #include <pthread.h>
2. #include <string.h>
3. #include <stdio.h>
4. #include <stdlib.h>
5. #include <unistd.h>
6. #include <errno.h>
7. #include <ctype.h>
8. #define handle_error_en(en, msg) \
9. do { errno = en; perror(msg); exit(EXIT_FAILURE); } while (0)
10. #define handle_error(msg) \
11. do { perror(msg); exit(EXIT_FAILURE); } while (0)
12. struct thread_info {    /* Used as argument to thread_start() */
13. pthread_t thread_id;        /* ID returned by pthread_create() */
14. int       thread_num;       /* Application-defined thread # */
15. char     *argv_string;      /* From command-line argument */
16. };
17. /* Thread start function: display address near top of our stack,
18. and return upper-cased copy of argv_string */
19. static void *
20. thread_start(void *arg)
21. {
22. struct thread_info *tinfo = arg;
23. char *uargv, *p;
24. <span style="color:#FF0000;">int a[1024*1024*5] = {0};</span>
25. printf("Thread %d: top of stack near %p; argv_string=%s\n",
26. tinfo->thread_num, &p, tinfo->argv_string);
27. uargv = strdup(tinfo->argv_string);
28. if (uargv == NULL)
29. handle_error("strdup");
30. for (p = uargv; *p != '\0'; p++)
31. *p = toupper(*p);
32. return uargv;
33. }
34. int
35. main(int argc, char *argv[])
36. {
37. int s, tnum, opt, num_threads;
38. struct thread_info *tinfo;
39. pthread_attr_t attr;
40. int stack_size;
41. void *res;
42. /* The "-s" option specifies a stack size for our threads */
43. stack_size = -1;
44. while ((opt = getopt(argc, argv, "s:")) != -1) {
45. switch (opt) {
46. case 's':
47. stack_size = strtoul(optarg, NULL, 0);
48. break;
49. default:
50. fprintf(stderr, "Usage: %s [-s stack-size] arg...\n",
51. argv[0]);
52. exit(EXIT_FAILURE);
53. }
54. }
55. num_threads = argc - optind;
56. /* Initialize thread creation attributes */
57. s = pthread_attr_init(&attr);
58. if (s != 0)
59. handle_error_en(s, "pthread_attr_init");
60. if (stack_size > 0) {
61. s = <span style="color:#FF0000;">pthread_attr_setstacksize</span>(&attr, stack_size);
62. if (s != 0)
63. handle_error_en(s, "pthread_attr_setstacksize");
64. }
65. /* Allocate memory for pthread_create() arguments */
66. tinfo = calloc(num_threads, sizeof(struct thread_info));
67. if (tinfo == NULL)
68. handle_error("calloc");
69. /* Create one thread for each command-line argument */
70. for (tnum = 0; tnum < num_threads; tnum++) {
71. tinfo[tnum].thread_num = tnum + 1;
72. tinfo[tnum].argv_string = argv[optind + tnum];
73. /* The pthread_create() call stores the thread ID into
74. corresponding element of tinfo[] */
75. s = pthread_create(&tinfo[tnum].thread_id, &attr,
76. &thread_start, &tinfo[tnum]);
77. if (s != 0)
78. handle_error_en(s, "pthread_create");
79. }
80. /* Destroy the thread attributes object, since it is no
81. longer needed */
82. s = pthread_attr_destroy(&attr);
83. if (s != 0)
84. handle_error_en(s, "pthread_attr_destroy");
85. /* Now join with each thread, and display its returned value */
86. for (tnum = 0; tnum < num_threads; tnum++) {
87. s = pthread_join(tinfo[tnum].thread_id, &res);
88. if (s != 0)
89. handle_error_en(s, "pthread_join");
90. printf("Joined with thread %d; returned value was %s\n",
91. tinfo[tnum].thread_num, (char *) res);
92. free(res);      /* Free memory allocated by thread */
93. }
94. free(tinfo);
95. exit(EXIT_SUCCESS);
96. }