c++多线程编程

一直对多线程编程这一块很陌生，决定花一点时间整理一下。

os:ubuntu 10.04  c++

1.最基础，进程同时创建5个线程，各自调用同一个函数

[html] view plain copy
  1. #include <iostream>  
  2. #include <pthread.h> //多线程相关操作头文件，可移植众多平台  
  3.   
  4. using namespace std;  
  5.   
  6. #define NUM_THREADS 5 //线程数  
  7.   
  8. void* say_hello( void* args )  
  9. {  
  10.     cout << "hello..." << endl;  
  11. } //函数返回的是函数指针，便于后面作为参数  
  12.   
  13. int main()  
  14. {  
  15.     pthread_t tids[NUM_THREADS]; //线程id  
  16.     for( int i = 0; i < NUM_THREADS; ++i )  
  17.     {  
  18.         int ret = pthread_create( &tids[i], NULL, say_hello, NULL ); //参数：创建的线程id，线程参数，线程运行函数的起始地址，运行函数的参数  
  19.         if( ret != 0 ) //创建线程成功返回0  
  20.         {  
  21.             cout << "pthread_create error:error_code=" << ret << endl;  
  22.         }  
  23.     }  
  24.     pthread_exit( NULL ); //等待各个线程退出后，进程才结束，否则进程强制结束，线程处于未终止的状态  
  25. }  
输入命令：g++ -o muti_thread_test_1 muti_thread_test_1.cpp -lpthread

注意：

1）此为c++程序，故用g++来编译生成可执行文件，并且要调用处理多线程操作相关的静态链接库文件pthread。

2）-lpthread 编译选项到位置可任意，如g++ -lpthread -o muti_thread_test_1 muti_thread_test_1.cpp

3）注意gcc和g++的区别，转到此文：点击打开链接

测试结果：

[html] view plain copy
  1. wq@wq-desktop:~/coding/muti_thread$ ./muti_thread_test_1  
  2. hello...hello...  
  3. hello...  
  4. hello...  
  5.   
  6. hello...  
[html] view plain copy
  1. wq@wq-desktop:~/coding/muti_thread$ ./muti_thread_test_1  
  2. hello...hello...hello...  
  3.   
  4. hello...  
  5. hello...  

可知，两次运行的结果会有差别，这不是多线程的特点吧？这显然没有同步？还有待进一步探索...

多线程的运行是混乱的，混乱就是正常？


2.线程调用到函数在一个类中，那必须将该函数声明为静态函数函数

因为静态成员函数属于静态全局区，线程可以共享这个区域，故可以各自调用。

[html] view plain copy
  1. #include <iostream>  
  2. #include <pthread.h>  
  3.   
  4. using namespace std;  
  5.   
  6. #define NUM_THREADS 5  
  7.   
  8. class Hello  
  9. {  
  10. public:  
  11.     static void* say_hello( void* args )  
  12.     {  
  13.         cout << "hello..." << endl;  
  14.     }  
  15. };  
  16.   
  17. int main()  
  18. {  
  19.     pthread_t tids[NUM_THREADS];  
  20.     for( int i = 0; i < NUM_THREADS; ++i )  
  21.     {  
  22.         int ret = pthread_create( &tids[i], NULL, Hello::say_hello, NULL );  
  23.         if( ret != 0 )  
  24.         {  
  25.             cout << "pthread_create error:error_code" << ret << endl;  
  26.         }  
  27.     }  
  28.     pthread_exit( NULL );  
  29. }  

测试结果：

[html] view plain copy
  1. wq@wq-desktop:~/coding/muti_thread$ ./muti_thread_test_2  
  2. hello...  
  3. hello...  
  4. hello...  
  5. hello...  
  6. hello...  
[html] view plain copy
  1. wq@wq-desktop:~/coding/muti_thread$ ./muti_thread_test_2  
  2. hello...hello...hello...  
  3.   
  4.   
  5. hello...  
  6. hello...  

3.如何在线程调用函数时传入参数呢？

先看下面修改的代码，传入线程编号作为参数：

[html] view plain copy
  1. #include <iostream>  
  2. #include <pthread.h> //多线程相关操作头文件，可移植众多平台  
  3.   
  4. using namespace std;  
  5.   
  6. #define NUM_THREADS 5 //线程数  
  7.   
  8. void* say_hello( void* args )  
  9. {  
  10.     int i = *( (int*)args ); //对传入的参数进行强制类型转换，由无类型指针转变为整形指针，再用*读取其指向到内容  
  11.     cout << "hello in " << i <<  endl;  
  12. } //函数返回的是函数指针，便于后面作为参数  
  13.   
  14. int main()  
  15. {  
  16.     pthread_t tids[NUM_THREADS]; //线程id  
  17.     cout << "hello in main.." << endl;  
  18.     for( int i = 0; i < NUM_THREADS; ++i )  
  19.     {  
  20.         int ret = pthread_create( &tids[i], NULL, say_hello, (void*)&i ); //传入到参数必须强转为void*类型，即无类型指针，&i表示取i的地址，即指向i的指针  
  21.         cout << "Current pthread id = " << tids[i] << endl; //用tids数组打印创建的进程id信息  
  22.         if( ret != 0 ) //创建线程成功返回0  
  23.         {  
  24.             cout << "pthread_create error:error_code=" << ret << endl;  
  25.         }  
  26.     }  
  27.     pthread_exit( NULL ); //等待各个线程退出后，进程才结束，否则进程强制结束，线程处于未终止的状态  
  28. }  
测试结果：
[html] view plain copy
  1. wq@wq-desktop:~/coding/muti_thread$ ./muti_thread_test_3  
  2. hello in main..  
  3. Current pthread id = 3078458224  
  4. Current pthread id = 3070065520  
  5. hello in hello in 2  
  6. 1  
  7. Current pthread id = hello in 2  
  8. 3061672816  
  9. Current pthread id = 3053280112  
  10. hello in 4  
  11. Current pthread id = hello in 4  
  12. 3044887408  
显然不是想要的结果，调用顺序很乱，这是为什么呢？

这是因为多线程到缘故，主进程还没开始对i赋值，线程已经开始跑了...?

修改代码如下：

[html] view plain copy
  1. #include <iostream>  
  2. #include <pthread.h> //多线程相关操作头文件，可移植众多平台  
  3.   
  4. using namespace std;  
  5.   
  6. #define NUM_THREADS 5 //线程数  
  7.   
  8. void* say_hello( void* args )  
  9. {  
  10.     cout << "hello in thread " << *( (int *)args ) <<  endl;  
  11. } //函数返回的是函数指针，便于后面作为参数  
  12.   
  13. int main()  
  14. {  
  15.     pthread_t tids[NUM_THREADS]; //线程id  
  16.     int indexes[NUM_THREADS]; //用来保存i的值避免被修改  
  17.   
  18.     for( int i = 0; i < NUM_THREADS; ++i )  
  19.     {  
  20.         indexes[i] = i;  
  21.         int ret = pthread_create( &tids[i], NULL, say_hello, (void*)&(indexes[i]) );  
  22.         if( ret != 0 ) //创建线程成功返回0  
  23.         {  
  24.             cout << "pthread_create error:error_code=" << ret << endl;  
  25.         }  
  26.     }  
  27.     for( int i = 0; i < NUM_THREADS; ++i )  
  28.         pthread_join( tids[i], NULL ); //pthread_join用来等待一个线程的结束，是一个线程阻塞的函数  
  29. }  
测试结果：

[html] view plain copy
  1. wq@wq-desktop:~/coding/muti_thread$ ./muti_thread_test_3  
  2. hello in thread hello in thread hello in thread hello in thread hello in thread 30124  

这是正常的吗？感觉还是有问题...待续

代码中如果没有pthread_join主线程会很快结束从而使整个进程结束，从而使创建的线程没有机会开始执行就结束了。加入pthread_join后，主线程会一直等待直到等待的线程结束自己才结束，使创建的线程有机会执行。


4.线程创建时属性参数的设置pthread_attr_t及join功能的使用

线程的属性由结构体pthread_attr_t进行管理。

typedef struct
{
    int                           detachstate;     线程的分离状态
    int                          schedpolicy;   线程调度策略
    struct sched_param      schedparam;   线程的调度参数
    int inheritsched; 线程的继承性 
    int scope; 线程的作用域 
    size_t guardsize; 线程栈末尾的警戒缓冲区大小 
    int stackaddr_set; void * stackaddr; 线程栈的位置 
    size_t stacksize; 线程栈的大小
}pthread_attr_t;

[html] view plain copy
  1. #include <iostream>  
  2. #include <pthread.h>  
  3.   
  4. using namespace std;  
  5.   
  6. #define NUM_THREADS 5  
  7.   
  8. void* say_hello( void* args )  
  9. {  
  10.     cout << "hello in thread " << *(( int * )args) << endl;  
  11.     int status = 10 + *(( int * )args); //线程退出时添加退出的信息，status供主程序提取该线程的结束信息  
  12.     pthread_exit( ( void* )status );   
  13. }  
  14.   
  15. int main()  
  16. {  
  17.     pthread_t tids[NUM_THREADS];  
  18.     int indexes[NUM_THREADS];  
  19.       
  20.     pthread_attr_t attr; //线程属性结构体，创建线程时加入的参数  
  21.     pthread_attr_init( &attr ); //初始化  
  22.     pthread_attr_setdetachstate( &attr, PTHREAD_CREATE_JOINABLE ); //是设置你想要指定线程属性参数，这个参数表明这个线程是可以join连接的，join功能表示主程序可以等线程结束后再去做某事，实现了主程序和线程同步功能  
  23.     for( int i = 0; i < NUM_THREADS; ++i )  
  24.     {  
  25.         indexes[i] = i;  
  26.         int ret = pthread_create( &tids[i], &attr, say_hello, ( void* )&( indexes[i] ) );  
  27.         if( ret != 0 )  
  28.         {  
  29.         cout << "pthread_create error:error_code=" << ret << endl;  
  30.     }  
  31.     }   
  32.     pthread_attr_destroy( &attr ); //释放内存   
  33.     void *status;  
  34.     for( int i = 0; i < NUM_THREADS; ++i )  
  35.     {  
  36.     int ret = pthread_join( tids[i], &status ); //主程序join每个线程后取得每个线程的退出信息status  
  37.     if( ret != 0 )  
  38.     {  
  39.         cout << "pthread_join error:error_code=" << ret << endl;  
  40.     }  
  41.     else  
  42.     {  
  43.         cout << "pthread_join get status:" << (long)status << endl;  
  44.     }  
  45.     }  
  46. }  
测试结果：

[html] view plain copy
  1. wq@wq-desktop:~/coding/muti_thread$ ./muti_thread_test_4  
  2. hello in thread hello in thread hello in thread hello in thread 0hello in thread 321  
  3.   
  4.   
  5.   
  6. 4  
  7. pthread_join get status:10  
  8. pthread_join get status:11  
  9. pthread_join get status:12  
  10. pthread_join get status:13  
  11. pthread_join get status:14  

5.互斥锁的实现
互斥锁是实现线程同步的一种机制，只要在临界区前后对资源加锁就能阻塞其他进程的访问。

[html] view plain copy
  1. #include <iostream>  
  2. #include <pthread.h>  
  3.   
  4. using namespace std;  
  5.   
  6. #define NUM_THREADS 5  
  7.   
  8. int sum = 0; //定义全局变量，让所有线程同时写，这样就需要锁机制  
  9. pthread_mutex_t sum_mutex; //互斥锁  
  10.   
  11. void* say_hello( void* args )  
  12. {  
  13.     cout << "hello in thread " << *(( int * )args) << endl;  
  14.     pthread_mutex_lock( &sum_mutex ); //先加锁，再修改sum的值，锁被占用就阻塞，直到拿到锁再修改sum;  
  15.     cout << "before sum is " << sum << " in thread " << *( ( int* )args ) << endl;  
  16.     sum += *( ( int* )args );  
  17.     cout << "after sum is " << sum << " in thread " << *( ( int* )args ) << endl;  
  18.     pthread_mutex_unlock( &sum_mutex ); //释放锁，供其他线程使用  
  19.     pthread_exit( 0 );   
  20. }  
  21.   
  22. int main()  
  23. {  
  24.     pthread_t tids[NUM_THREADS];  
  25.     int indexes[NUM_THREADS];  
  26.       
  27.     pthread_attr_t attr; //线程属性结构体，创建线程时加入的参数  
  28.     pthread_attr_init( &attr ); //初始化  
  29.     pthread_attr_setdetachstate( &attr, PTHREAD_CREATE_JOINABLE ); //是设置你想要指定线程属性参数，这个参数表明这个线程是可以join连接的，join功能表示主程序可以等线程结束后再去做某事，实现了主程序和线程同步功能  
  30.     pthread_mutex_init( &sum_mutex, NULL ); //对锁进行初始化      
  31.   
  32.     for( int i = 0; i < NUM_THREADS; ++i )  
  33.     {  
  34.         indexes[i] = i;  
  35.         int ret = pthread_create( &tids[i], &attr, say_hello, ( void* )&( indexes[i] ) ); //5个进程同时去修改sum  
  36.         if( ret != 0 )  
  37.         {  
  38.         cout << "pthread_create error:error_code=" << ret << endl;  
  39.     }  
  40.     }   
  41.     pthread_attr_destroy( &attr ); //释放内存   
  42.     void *status;  
  43.     for( int i = 0; i < NUM_THREADS; ++i )  
  44.     {  
  45.     int ret = pthread_join( tids[i], &status ); //主程序join每个线程后取得每个线程的退出信息status  
  46.     if( ret != 0 )  
  47.     {  
  48.         cout << "pthread_join error:error_code=" << ret << endl;  
  49.     }  
  50.     }  
  51.     cout << "finally sum is " << sum << endl;  
  52.     pthread_mutex_destroy( &sum_mutex ); //注销锁  
  53. }  
测试结果：
[html] view plain copy
  1. wq@wq-desktop:~/coding/muti_thread$ ./muti_thread_test_5  
  2. hello in thread hello in thread hello in thread 410  
  3. before sum is hello in thread 0 in thread 4  
  4. after sum is 4 in thread 4hello in thread   
  5.   
  6.   
  7. 2  
  8. 3  
  9. before sum is 4 in thread 1  
  10. after sum is 5 in thread 1  
  11. before sum is 5 in thread 0  
  12. after sum is 5 in thread 0  
  13. before sum is 5 in thread 2  
  14. after sum is 7 in thread 2  
  15. before sum is 7 in thread 3  
  16. after sum is 10 in thread 3  
  17. finally sum is 10  
可知，sum的访问和修改顺序是正常的，这就达到了多线程的目的了，但是线程的运行顺序是混乱的，混乱就是正常？

6.信号量的实现
信号量是线程同步的另一种实现机制，信号量的操作有signal和wait，本例子采用条件信号变量pthread_cond_t tasks_cond;
信号量的实现也要给予锁机制。

[html] view plain copy
  1. #include <iostream>  
  2. #include <pthread.h>  
  3. #include <stdio.h>  
  4.   
  5. using namespace std;  
  6.   
  7. #define BOUNDARY 5  
  8.   
  9. int tasks = 10;  
  10. pthread_mutex_t tasks_mutex; //互斥锁  
  11. pthread_cond_t tasks_cond; //条件信号变量，处理两个线程间的条件关系，当task>5，hello2处理，反之hello1处理，直到task减为0  
  12.   
  13. void* say_hello2( void* args )  
  14. {  
  15.     pthread_t pid = pthread_self(); //获取当前线程id  
  16.     cout << "[" << pid << "] hello in thread " <<  *( ( int* )args ) << endl;  
  17.       
  18.     bool is_signaled = false; //sign  
  19.     while(1)  
  20.     {  
  21.     pthread_mutex_lock( &tasks_mutex ); //加锁  
  22.     if( tasks > BOUNDARY )  
  23.     {  
  24.         cout << "[" << pid << "] take task: " << tasks << " in thread " << *( (int*)args ) << endl;  
  25.         --tasks; //modify  
  26.     }  
  27.     else if( !is_signaled )  
  28.     {  
  29.         cout << "[" << pid << "] pthread_cond_signal in thread " << *( ( int* )args ) << endl;  
  30.         pthread_cond_signal( &tasks_cond ); //signal:向hello1发送信号，表明已经>5  
  31.         is_signaled = true; //表明信号已发送，退出此线程  
  32.     }  
  33.     pthread_mutex_unlock( &tasks_mutex ); //解锁  
  34.     if( tasks == 0 )  
  35.         break;  
  36.     }      
  37. }  
  38.   
  39. void* say_hello1( void* args )  
  40. {  
  41.     pthread_t pid = pthread_self(); //获取当前线程id  
  42.     cout << "[" << pid << "] hello in thread " <<  *( ( int* )args ) << endl;  
  43.   
  44.     while(1)  
  45.     {  
  46.         pthread_mutex_lock( &tasks_mutex ); //加锁  
  47.         if( tasks > BOUNDARY )  
  48.         {  
  49.         cout << "[" << pid << "] pthread_cond_signal in thread " << *( ( int* )args ) << endl;  
  50.         pthread_cond_wait( &tasks_cond, &tasks_mutex ); //wait:等待信号量生效，接收到信号，向hello2发出信号，跳出wait,执行后续   
  51.         }  
  52.         else  
  53.         {  
  54.         cout << "[" << pid << "] take task: " << tasks << " in thread " << *( (int*)args ) << endl;  
  55.             --tasks;  
  56.     }  
  57.         pthread_mutex_unlock( &tasks_mutex ); //解锁  
  58.         if( tasks == 0 )  
  59.             break;  
  60.     }   
  61. }  
  62.   
  63.   
  64. int main()  
  65. {  
  66.     pthread_attr_t attr; //线程属性结构体，创建线程时加入的参数  
  67.     pthread_attr_init( &attr ); //初始化  
  68.     pthread_attr_setdetachstate( &attr, PTHREAD_CREATE_JOINABLE ); //是设置你想要指定线程属性参数，这个参数表明这个线程是可以join连接的，join功能表示主程序可以等线程结束后再去做某事，实现了主程序和线程同步功能  
  69.     pthread_cond_init( &tasks_cond, NULL ); //初始化条件信号量  
  70.     pthread_mutex_init( &tasks_mutex, NULL ); //初始化互斥量  
  71.     pthread_t tid1, tid2; //保存两个线程id  
  72.     int index1 = 1;  
  73.     int ret = pthread_create( &tid1, &attr, say_hello1, ( void* )&index1 );  
  74.     if( ret != 0 )  
  75.     {  
  76.         cout << "pthread_create error:error_code=" << ret << endl;  
  77.     }  
  78.     int index2 = 2;  
  79.     ret = pthread_create( &tid2, &attr, say_hello2, ( void* )&index2 );  
  80.     if( ret != 0 )  
  81.     {  
  82.         cout << "pthread_create error:error_code=" << ret << endl;  
  83.     }  
  84.     pthread_join( tid1, NULL ); //连接两个线程  
  85.     pthread_join( tid2, NULL );   
  86.   
  87.     pthread_attr_destroy( &attr ); //释放内存   
  88.     pthread_mutex_destroy( &tasks_mutex ); //注销锁  
  89.     pthread_cond_destroy( &tasks_cond ); //正常退出  
  90. }  
测试结果：
先在线程2中执行say_hello2，再跳转到线程1中执行say_hello1，直到tasks减到0为止。

[html] view plain copy
  1. wq@wq-desktop:~/coding/muti_thread$ ./muti_thread_test_6  
  2. [3069823856] hello in thread 2  
  3. [3078216560] hello in thread 1[3069823856] take task: 10 in thread 2  
  4.   
  5. [3069823856] take task: 9 in thread 2  
  6. [3069823856] take task: 8 in thread 2  
  7. [3069823856] take task: 7 in thread 2  
  8. [3069823856] take task: 6 in thread 2  
  9. [3069823856] pthread_cond_signal in thread 2  
  10. [3078216560] take task: 5 in thread 1  
  11. [3078216560] take task: 4 in thread 1  
  12. [3078216560] take task: 3 in thread 1  
  13. [3078216560] take task: 2 in thread 1  
  14. [3078216560] take task: 1 in thread 1  
到此，对多线程编程有了一个初步的了解，当然还有其他实现线程同步的机制，有待进一步探索。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mzph.cn/news/458723.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

ajax当页post请求,tag落地页--通过ajax-post请求数据

ajax当页post请求,tag落地页--通过ajax-post请求数据

查询所有tag及其对应跳转链接$tags get_tags(array(get>all));$output . ;if($tags) {foreach ($tags as $tag):$output . . $tag->name .;endforeach;} else {_e(No tags created., text-domain);}$output . ;echo $output;交互tag查询image场景如下&#xff0c;通过页…
阅读更多...
GIT的PUSH指令

GIT的PUSH指令

### GIT的PUSH指令 $ git push <远程主机名> <本地分支名>:<远程分支名> * git push命令用于将本地分支的更新&#xff0c;推送到远程主机。 * 如果省略远程分支名&#xff0c;则表示将本地分支推送到与之对应的远程分支&#xff08;通常两者同名&#xff…
阅读更多...
Android 编程下 Touch 事件的分发和消费机制

Android 编程下 Touch 事件的分发和消费机制

Android 中与 Touch 事件相关的方法包括&#xff1a;dispatchTouchEvent(MotionEvent ev)、onInterceptTouchEvent(MotionEvent ev)、onTouchEvent(MotionEvent ev)&#xff1b;能够响应这些方法的控件包括&#xff1a;ViewGroup、View、Activity。方法与控件的对应关系如下表所…
阅读更多...
ios微信本地视频上传到服务器,ios本地视频wx.uploadFile上传

ios微信本地视频上传到服务器,ios本地视频wx.uploadFile上传

//上传视频uploadVideo:function(){let _this this;let list [camera, album];wx.showActionSheet({itemList: [拍摄视频,从相册选择视频,从视频库选择视频],success: function (res) {if(res.tapIndex0 || res.tapIndex1){wx.chooseVideo({sourceType:[list[res.tapIndex]],…
阅读更多...
如何手工抓取dump文件及分析

如何手工抓取dump文件及分析

在生产环境下进行故障诊断时&#xff0c;为了不终止正在运行的服务或应用程序&#xff0c;有两种方式可以对正在运行的服务或应用程序的进程进行分析和调试。 首先一种比较直观简洁的方式就是用WinDbg等调试器直接attach到需要调试的进程&#xff0c;调试完毕之后再detach即可。…
阅读更多...
Java 类加载机制详解

Java 类加载机制详解

2019独角兽企业重金招聘Python工程师标准>>> 一、类加载器 类加载器&#xff08;ClassLoader&#xff09;&#xff0c;顾名思义&#xff0c;即加载类的东西。在我们使用一个类之前&#xff0c;JVM需要先将该类的字节码文件&#xff08;.class文件&#xff09;从磁盘…
阅读更多...
JAVA vo pojo javabean dto区别

JAVA vo pojo javabean dto区别

JavaBean 是一种JAVA语言写成的可重用组件。为写成JavaBean&#xff0c;类必须是具体的和公共的&#xff0c;并且具有无参数的构造器。JavaBean 通过提供符合一致性设计模式的公共方法将内部域暴露成员属性。众所周知&#xff0c;属性名称符合这种模式&#xff0c;其他Java 类可…
阅读更多...
编写的windows程序，崩溃时产生crash dump文件的办法

编写的windows程序，崩溃时产生crash dump文件的办法

一、引言 dump文件是C程序发生异常时&#xff0c;保存当时程序运行状态的文件&#xff0c;是调试异常程序重要的方法&#xff0c;所以程序崩溃时&#xff0c;除了日志文件&#xff0c;dump文件便成了我们查找错误的最后一根救命的稻草。windows程序产生dump文件和linux程序产生…
阅读更多...
Nginx+PHP实时生成不同尺寸图片

Nginx+PHP实时生成不同尺寸图片

原来图片服务器采用Windows .net架构&#xff0c;鉴于需求需要生成各种尺寸图片。流程说明:用户从Nginx请求对应的图片,判断是否存在_200x300的对应参数&#xff0c;如果没有就直接请求到对应目录的原图&#xff0c;否则继续判断是否在本地已经生成了对应的缓存图片&#xff0c…
阅读更多...
JavaScript设计模式 Item 2 -- 接口的实现

JavaScript设计模式 Item 2 -- 接口的实现

1、接口概述 1。什么是接口&#xff1f; 接口是提供了一种用以说明一个对象应该具有哪些方法的手段。尽管它可以表明这些方法的语义&#xff0c;但它并不规定这些方法应该如何实现。 2. 接口之利 促进代码的重用。 接口可以告诉程序员一个类实现了哪些方法&#xff0c;从而帮助…
阅读更多...
Spring Boot 乐观锁加锁失败 - 集成AOP

Spring Boot 乐观锁加锁失败 - 集成AOP

Spring Boot with AOP 手头上的项目使用了Spring Boot&#xff0c; 在高并发的情况下&#xff0c;经常出现乐观锁加锁失败的情况&#xff08;OptimisticLockingFailureException&#xff0c;同一时间有多个线程在更新同一条数据&#xff09;。为了减少直接向服务使用者直接返回…
阅读更多...
掌握VS2010调试 -- 入门指南

掌握VS2010调试 -- 入门指南

1 导言 在软件开发周期中&#xff0c;测试和修正缺陷&#xff08;defect&#xff0c;defect与bug的区别&#xff1a;Bug是缺陷的一种表现形式&#xff0c;而一个缺陷是可以引起多种Bug的&#xff09;的时间远多于写代码的时间。通常&#xff0c;debug是指发现缺陷并改正的过程。…
阅读更多...
151031

151031

create or replace procedure pr_test1 is v_case number(3): 100; beginif 2>1 thendbms_output.put_line(成立);elsif 4>3 thenif 7>6 thendbms_output.put_line(不成立);end if; elsif 6>5 thendbms_output.put_line(也行);elsedbms_output.put_line(也不成立);…
阅读更多...
postgresql9.5 run 文件linux安装后配置成开机服务

postgresql9.5 run 文件linux安装后配置成开机服务

网上出现的比较多安装方法要么是源码安装&#xff0c;要么是yum安装&#xff0c;我发觉都要配置很多属性&#xff0c;比较麻烦&#xff0c;所以现在我在centos7长用 run文件来安装 http://get.enterprisedb.com/postgresql/postgresql-9.5.1-1-linux-x64.run 这里的安装shell整…
阅读更多...
Windows API GetProcAddress 及demo code

Windows API GetProcAddress 及demo code

GetProcAddress函数检索指定的动态链接库(DLL)中的输出库函数地址。 函数原型&#xff1a; FARPROC GetProcAddress( HMODULE hModule, // DLL模块句柄 LPCSTR lpProcName// 函数名 ); 参数&#xff1a; hModule [in] 包含此函数的DLL模块的句柄。LoadLibrary、AfxLoadLibrary …
阅读更多...
【操作系统】进程管理

【操作系统】进程管理

进程管理 进程的基本概念 程序的顺序执行及其特征 程序的顺序执行:仅当前一操作(程序段)执行完后&#xff0c;才能执行后续操作。 程序顺序执行时的特征&#xff1a;顺序性&#xff0c;封闭性&#xff0c;可再见性。 前趋图 前趋图(Precedence Graph)是一个有向无循环图&#…
阅读更多...
va_list va_start va_end的使用

va_list va_start va_end的使用

<pre name"code" class"cpp" style"color: rgb(51, 51, 51); white-space: pre-wrap; word-wrap: break-word;"><strong>一、 从printf()开始</strong> 从大家都很熟悉的格式化字符串函数开始介绍可变参数函数。 原型&#xf…
阅读更多...
Linux学习之CentOS(三)----将Cent0S 7的网卡名称eno16777736改为eth0

Linux学习之CentOS(三)----将Cent0S 7的网卡名称eno16777736改为eth0

【正文】 Linux系统版本&#xff1a;CentOS_7&#xff08;64位&#xff09; 一、前言&#xff1a; 今天又从Centos 6.5装回了Centos 7&#xff0c;毕竟还是要顺应潮流嘛。安装完成之后&#xff0c;发现发现CentOS 7默认的网卡名称是eno16777736&#xff0c;如图所示&#xff1a…
阅读更多...
本地音频播放，使用AVFoundation.framework中的AVAudioPlayer来实现

本地音频播放，使用AVFoundation.framework中的AVAudioPlayer来实现

本地音频播放,使用AVfoundation.framework中的AVAudioPlayer来实现 /*AVAudioPlayer的使用比较简单: 1、初始化AVAudioPlayer对象&#xff0c;此时通常指定本地文件路径 2、设置播放器属性&#xff0c;例如重复次数、音量大小等 3、调用play方法播放。 */
阅读更多...
AngularJS操作DOM——angular.element

AngularJS操作DOM——angular.element

addClass()-为每个匹配的元素添加指定的样式类名after()-在匹配元素集合中的每个元素后面插入参数所指定的内容&#xff0c;作为其兄弟节点append()-在每个匹配元素里面的末尾处插入参数内容attr() - 获取匹配的元素集合中的第一个元素的属性的值bind() - 为一个元素绑定一个事…
阅读更多...
最新文章

Copyright @ 2022~2023