介绍
Clang的线程安全分析模块是C++语言的一个扩展,能对代码中潜在的竞争条件进行警告。这种分析是完全静态的(即编译时进行),没有运行时的消耗。当前这个功能还在开发中,但它已经具备了足够的成熟度,可以被部署到生产环境中。它由Google开发,同时受到CERT(United States Computer Emergency Readiness Team,美国互联网应急中心)/SEI(Software Engineering Institute,软件工程中心)的协助,并在Google的内部代码中被广泛应用。
对于多线程的程序来说,线程安全分析很像一个类型系统。在一个多线程的环境中,程序员除了可以声明一个数据的类型(比如,int, float等)之外,还可以声明对数据的访问是如何被控制的。例如,如果变量foo受到互斥锁mu的监控,那么如果如果一段代码在读或者写foo之前没有加锁,就会发出警告。同样,如果一段仅应被GUI线程访问的代码被其它线程访问了,也会发出警告。
 
入门
  1. #include "mutex.h"
  2.  
  3. class BankAccount {
  4. private:
  5. Mutex mu;
  6. int balance GUARDED_BY(mu);
  7.  
  8. void depositImpl(int amount) {
  9. balance += amount; // WARNING! Cannot write balance without locking mu.
  10. }
  11.  
  12. void withdrawImpl(int amount) REQUIRES(mu) {
  13. balance -= amount; // OK. Caller must have locked mu.
  14. }
  15.  
  16. public:
  17. void withdraw(int amount) {
  18. mu.Lock();
  19. withdrawImpl(amount); // OK. We've locked mu.
  20. } // WARNING! Failed to unlock mu.
  21.  
  22. void transferFrom(BankAccount& b, int amount) {
  23. mu.Lock();
  24. b.withdrawImpl(amount); // WARNING! Calling withdrawImpl() requires locking b.mu.
  25. depositImpl(amount); // OK. depositImpl() has no requirements.
  26. mu.Unlock();
  27. }
  28. };
这段代码说明了线程安全分析背后的基本概念。GUARDED_BY属性声明,一个线程在读或写balance变量之前,必须先锁住mu,由此保证对balance的增加和降低操作都是原子的。同样,REQUIRES声明了在调用线程调用withdrawImpl方法之前,必须先锁住mu。因为调用者已经在方法调用之前锁住了mu,因此在方法体内部修改balance就是安全的了。
depositeImpl方法没有REQUIRES生命,因此分析模块给出了一个警告。线程安全分析模块并不是进程内部的,因此对调用者的需求必须被显式的声明。在transferFrom方法内部也有一个警告,因为尽管方法锁住了this->mu,它没有锁住b.mu,分析模块知道这是两个不同的锁,分属两个不同的对象。
最后,在withdraw方法内部也有一个警告,因为它没有解锁mu。每一个上锁操作必须有一个配对的解锁操作,分析模块将检测成对的上锁和解锁操作。一个函数可以仅上锁而不解锁(反之亦然),但这必须被显式标注(使用ACQUIRE/RELEASE)。
 
运行分析
为了运行分析模块,只需要加入编译选项 -Wthread-safety,比如
  1. clang -c -Wthread-safety example.cpp
注意,这段代码假设已经有一个正确的标注文件mutex.h存在,这个文件中声明了哪个方法执行了上锁、解锁的操作。
 
基本概念:监护权
线程安全分析提供了一种使用“监护权”保护资源的方法。“资源”可以是数据成员,或者可以访问底层资源的过程或方法。分析模块保证了,除非调用者线程拥有了对于资源的监护权(调用一个方法,或者读/写一个数据),否则它是无法访问到资源的。监护权被绑定到一些具名的C++对象上,这些对象声明了专用的方法来获取和释放监护权。这些对象的名称被用来识别监护权。最常见的例子就是互斥锁。例如,如果mu是一个互斥锁,那么调用mu.Lock()使得调用者线程拥有了mu所保护的数据的监护权。同样的,调用mu.Unlock()释放监护权。
线程可以排他的或者共享的拥有监护权。一个排他的监护权每次仅能被一个线程拥有,而一个共享的监护权可以同时被多个线程拥有。这个机制使得多读一写的模式成为可能。写操作需要排他的监护权,而读操作仅需要共享的监护权。
在程序执行的给定时刻,每个线程拥有各自的监护权集合(该线程锁住的互斥锁的集合)。它们类似于钥匙或者令牌,允许线程访问这些资源。跟物理上的安全钥匙一样,线程不能复制、也不能销毁监护权。一个线程只能把监护权释放给另外一个线程,或者从另外一个线程获得监护权。安全起见,分析模块的标识不清楚具体获取和释放监护权的机制,它假设底层实现(例如,互斥锁的实现)能够恰当的完成这个任务。
在程序运行的某个具体时刻,某个线程拥有的监护权集合是一个运行时的概念。静态的任务是对这个集合(也被称为监护权环境)进行估计。分析模块会通过静态分析描述程序任何执行节点的监护权环境。这个估计,是对实际运行时监护权环境的保守估计。
 
应用指导
线程安全分析模块使用属性来声明线程约束。属性必须被绑定到具名的声明,比如类、方法、数据成员。我们强烈建议用户为这些不同的属性定义宏,示例请参见以下的mutex.h文件。接下来的说明将假设使用了宏。
由于历史原因,线程安全分析模块的早期版本是用了以锁为中心的宏名称。为了适应更普适的模型,这些宏被更改了名称。之前的名称仍然在使用,在接下来的文档里会特别指明。
 
GUARDED_BY(c) 和 PT_GUARDED_BY(c)
GUARDED_BY是一个应用在数据成员上的属性,它声明了数据成员被给定的监护权保护。对于数据的读操作需要共享的访问权限,而写操作需要独占的访问权限。
PT_GUARDED_BY与之类似,只不过它是为指针和智能指针准备的。对数据成员(指针)本身没有任何限制,它保护的是指针指向的数据。
  1. Mutex mu;
  2. int *p1 GUARDED_BY(mu);
  3. int *p2 PT_GUARDED_BY(mu);
  4. unique_ptr<int> p3 PT_GUARDED_BY(mu);
  5.  
  6. void test() {
  7. p1 = 0; // Warning!
  8.  
  9. *p2 = 42; // Warning!
  10. p2 = new int; // OK.
  11.  
  12. *p3 = 42; // Warning!
  13. p3.reset(new int); // OK.
  14. }
 
REQUIRES(...),REQUIRES_SHARED(...)
早期的版本是EXCLUSIVE_LOCKS_REQUIRED,SHARED_LOCKS_REQUIRED
REQUIRES是作用于方法或者函数上的属性,它表明了调用线程必须独享给定的监护权。可以指定不止一个监护权。监护权必须在函数的入口处、出口处同时被声明。
REQUIRES_SHARED与之类似,只不过仅需要共享的访问权限。
  1. Mutex mu1, mu2;
  2. int a GUARDED_BY(mu1);
  3. int b GUARDED_BY(mu2);
  4.  
  5. void foo() REQUIRES(mu1, mu2) {
  6. a = 0;
  7. b = 0;
  8. }
  9.  
  10. void test() {
  11. mu1.Lock();
  12. foo(); // Warning! Requires mu2.
  13. mu1.Unlock();
  14. }
 
ACQUIRE(...),ACQUIRE_SHARED(...),RELEASE(...),RELEASE_SHARED(...)
早期版本是EXECLUSIVE_LOCK_FUNCTION,SHARED_LOCK_FUNCTION,UNLOCK_FUNCTION
ACQUIRE是一个作用在函数或者方法上的属性,它声明了这个函数或方法需要一个监护权,但不会释放它。调用者在调用之前不能拥有监护权,在调用之后需要获得监护权。ACQUIRE_SHARED与之类似。
RELEASE和RELEASE_SHARED声明,函数必须释放监护权。调用者在调用之前必须拥有监护权,在调用之后将失去监护权。监护权是共享还是排他的,并不重要。
  1. Mutex mu;
  2. MyClass myObject GUARDED_BY(mu);
  3.  
  4. void lockAndInit() ACQUIRE(mu) {
  5. mu.Lock();
  6. myObject.init();
  7. }
  8.  
  9. void cleanupAndUnlock() RELEASE(mu) {
  10. myObject.cleanup();
  11. } // Warning! Need to unlock mu.
  12.  
  13. void test() {
  14. lockAndInit();
  15. myObject.doSomething();
  16. cleanupAndUnlock();
  17. myObject.doSomething(); // Warning, mu is not locked.
  18. }
如果没有向ACQUIRE或RELEASE传递参数,那么this将会成为它的默认参数,分析模块将不会检查它修饰的函数体。这种模式通常被在抽象接口下隐藏具体锁细节的类使用(译者注:为了不向外界暴露锁的实现细节,将锁作为类的私有数据,因此,对共有函数声明不带参数的ACQUIRE/RELEASE,相当于对当前对象——也相当于对这个私有的锁——进行加锁/释放锁操作),示例如下:
  1. template <class T>
  2. class CAPABILITY("mutex") Container {
  3. private:
  4. Mutex mu;
  5. T* data;
  6.  
  7. public:
  8. // Hide mu from public interface.
  9. void Lock() ACQUIRE() { mu.Lock(); }
  10. void Unlock() RELEASE() { mu.Unlock(); }
  11.  
  12. T& getElem(int i) { return data[i]; }
  13. };
  14.  
  15. void test() {
  16. Container<int> c;
  17. c.Lock();
  18. int i = c.getElem(0);
  19. c.Unlock();
  20. }
 
EXCLUDES(...)
早期版本LOCKS_EXCLUDED
EXCLUDES是一种函数或方法的属性,用来声明调用者绝对不能拥有监护权。这样做的目的是为了防止死锁。很多互斥锁的实现是不允许重入的,因此如果一个函数二次申请一个互斥锁,会引起死锁。
  1. Mutex mu;
  2. int a GUARDED_BY(mu);
  3.  
  4. void clear() EXCLUDES(mu) {
  5. mu.Lock();
  6. a = 0;
  7. mu.Unlock();
  8. }
  9.  
  10. void reset() {
  11. mu.Lock();
  12. clear(); // Warning! Caller cannot hold 'mu'.
  13. mu.Unlock();
  14. }
与REQUIRES不同,EXCLUDES是可选的。如果该属性缺失的话,分析模块不会发出警告,这在某些情况下可能会产生某些错误的负样本(本来应该在函数内部进行加锁和释放锁,但没有这么做,分析系统也没有警告,这样在实际运行中可能会出现错误)。这个问题将在“负监护权”章节中讨论。
 
NO_THREAD_SAFETY_ANALYSIS
NO_THREAD_SAFETY_ANALYSIS是一种函数或方法的属性,它意味着对该函数关闭线程安全分析。它为以下两种函数的实现提供了可能,第一,故意设计的线程不安全的代码,第二,代码是线程安全的,但是对于线程安全分析模块来说太复杂,模块无法理解。第二种情况将在“已知限制”章节中讨论。
  1. class Counter {
  2. Mutex mu;
  3. int a GUARDED_BY(mu);
  4.  
  5. void unsafeIncrement() NO_THREAD_SAFETY_ANALYSIS { a++; }
  6. };
与其它属性不同的是,NO_THREAD_SAFETY_ANALYSIS不是函数接口的一部分,它需要被放在源文件(cc或cpp)而不是头文件(h)中。
 
RETURN_CAPABILITY(c)
早期版本LOCK_RETURNED
RETURN_CAPABILITY是一种函数或方法的属性,它声明了该函数将返回一个给定监护权的引用。通常用来修饰会返回互斥锁的getter方法。
  1. class MyClass {
  2. private:
  3. Mutex mu;
  4. int a GUARDED_BY(mu);
  5.  
  6. public:
  7. Mutex* getMu() RETURN_CAPABILITY(mu) { return &mu; }
  8.  
  9. // analysis knows that getMu() == mu
  10. void clear() REQUIRES(getMu()) { a = 0; }
  11. };
 
ACQUIRED_BEFORE(...),ACQUIRED_AFTER(...)
ACQUIRED_BEFORE和ACQUIRED_AFTER是成员变量的属性,特别是用来声明互斥锁或其他监护权。这种声明在互斥锁之间强加了一个获取的优先级,目的是为了防止死锁。
  1. Mutex m1;
  2. Mutex m2 ACQUIRED_AFTER(m1);
  3.  
  4. // Alternative declaration
  5. // Mutex m2;
  6. // Mutex m1 ACQUIRED_BEFORE(m2);
  7.  
  8. void foo() {
  9. m2.Lock();
  10. m1.Lock(); // Warning! m2 must be acquired after m1.
  11. m1.Unlock();
  12. m2.Unlock();
  13. }
 
CAPABILITY(<string>)
早期版本LOCKABLE
CAPABILITY是一种类的属性,它意味着该类的对象可以被当做监护权使用。string参数使用错误信息指定了监护权的类型,例如“mutex"。参见之前给出的”Container"示例,或者mutex.h文件中的Mutex类。
 
SCOPED_CAPABILITY
早期版本SCOPED_LOCKABLE
SCOPED_CAPABILITY是一种类的属性,这种类实现了RAII风格的锁,监护权在构造函数中获取,在析构函数中释放。这种类需要被特别指出,因为构造和析构函数指定的监护权的名称是不一样的,参见mutex.h文件中的MutexLocker类。
 
TRY_ACQUIRE(<bool>,...),TRY_ACQUIRE_SHARED(<bool>,...)
早期版本EXECLUSIVE_TRYLOCK_FUNCTION,SHARED_TRYLOCK_FUNCTION
这是一种函数或方法的属性,这些函数或方法试图获取指定的监护权,并且返回一个布尔值表明是否成功。函数的第一个参数必须是true或者false,来说明哪个值表示监护权获取成功,剩余参数等同于ACQUIRE。具体示例参见mutex.h。
 
ASSERT_CAPABILITY(...)和ASSERT_SHARED_CAPABILITY(...)
早期版本ASSERT_EXECLUSIVE_LOCK,ASSERT_SHARED_LOCK
这是一种函数或方法的属性,它表明该函数将在运行时进行一个安全检查,判断调用线程是否拥有监护权。如果调用线程没有监护权,该函数将会返回空表明调用失败。具体示例详见mutex.h
 
GUARDED_VAR和PT_GUARDED_VAR
该属性的使用已被抛弃。
 
(还有部分细节,时间原因就不讲了,详见参考链接)
 
线程安全分析模块可以被任何线程库使用,不过它要求线程的API被包装在有合适注释的类或者方法里。以下的mutex.h提供了一个示例,这些函数需要被实现,以便调用合适的底层实现。
  1. #ifndef THREAD_SAFETY_ANALYSIS_MUTEX_H
  2. #define THREAD_SAFETY_ANALYSIS_MUTEX_H
  3.  
  4. // Enable thread safety attributes only with clang.
  5. // The attributes can be safely erased when compiling with other compilers.
  6. #if defined(__clang__) && (!defined(SWIG))
  7. #define THREAD_ANNOTATION_ATTRIBUTE__(x) __attribute__((x))
  8. #else
  9. #define THREAD_ANNOTATION_ATTRIBUTE__(x) // no-op
  10. #endif
  11.  
  12. #define CAPABILITY(x) \
  13. THREAD_ANNOTATION_ATTRIBUTE__(capability(x))
  14.  
  15. #define SCOPED_CAPABILITY \
  16. THREAD_ANNOTATION_ATTRIBUTE__(scoped_lockable)
  17.  
  18. #define GUARDED_BY(x) \
  19. THREAD_ANNOTATION_ATTRIBUTE__(guarded_by(x))
  20.  
  21. #define PT_GUARDED_BY(x) \
  22. THREAD_ANNOTATION_ATTRIBUTE__(pt_guarded_by(x))
  23.  
  24. #define ACQUIRED_BEFORE(...) \
  25. THREAD_ANNOTATION_ATTRIBUTE__(acquired_before(__VA_ARGS__))
  26.  
  27. #define ACQUIRED_AFTER(...) \
  28. THREAD_ANNOTATION_ATTRIBUTE__(acquired_after(__VA_ARGS__))
  29.  
  30. #define REQUIRES(...) \
  31. THREAD_ANNOTATION_ATTRIBUTE__(requires_capability(__VA_ARGS__))
  32.  
  33. #define REQUIRES_SHARED(...) \
  34. THREAD_ANNOTATION_ATTRIBUTE__(requires_shared_capability(__VA_ARGS__))
  35.  
  36. #define ACQUIRE(...) \
  37. THREAD_ANNOTATION_ATTRIBUTE__(acquire_capability(__VA_ARGS__))
  38.  
  39. #define ACQUIRE_SHARED(...) \
  40. THREAD_ANNOTATION_ATTRIBUTE__(acquire_shared_capability(__VA_ARGS__))
  41.  
  42. #define RELEASE(...) \
  43. THREAD_ANNOTATION_ATTRIBUTE__(release_capability(__VA_ARGS__))
  44.  
  45. #define RELEASE_SHARED(...) \
  46. THREAD_ANNOTATION_ATTRIBUTE__(release_shared_capability(__VA_ARGS__))
  47.  
  48. #define TRY_ACQUIRE(...) \
  49. THREAD_ANNOTATION_ATTRIBUTE__(try_acquire_capability(__VA_ARGS__))
  50.  
  51. #define TRY_ACQUIRE_SHARED(...) \
  52. THREAD_ANNOTATION_ATTRIBUTE__(try_acquire_shared_capability(__VA_ARGS__))
  53.  
  54. #define EXCLUDES(...) \
  55. THREAD_ANNOTATION_ATTRIBUTE__(locks_excluded(__VA_ARGS__))
  56.  
  57. #define ASSERT_CAPABILITY(x) \
  58. THREAD_ANNOTATION_ATTRIBUTE__(assert_capability(x))
  59.  
  60. #define ASSERT_SHARED_CAPABILITY(x) \
  61. THREAD_ANNOTATION_ATTRIBUTE__(assert_shared_capability(x))
  62.  
  63. #define RETURN_CAPABILITY(x) \
  64. THREAD_ANNOTATION_ATTRIBUTE__(lock_returned(x))
  65.  
  66. #define NO_THREAD_SAFETY_ANALYSIS \
  67. THREAD_ANNOTATION_ATTRIBUTE__(no_thread_safety_analysis)
  68.  
  69. // Defines an annotated interface for mutexes.
  70. // These methods can be implemented to use any internal mutex implementation.
  71. class CAPABILITY("mutex") Mutex {
  72. public:
  73. // Acquire/lock this mutex exclusively. Only one thread can have exclusive
  74. // access at any one time. Write operations to guarded data require an
  75. // exclusive lock.
  76. void Lock() ACQUIRE();
  77.  
  78. // Acquire/lock this mutex for read operations, which require only a shared
  79. // lock. This assumes a multiple-reader, single writer semantics. Multiple
  80. // threads may acquire the mutex simultaneously as readers, but a writer
  81. // must wait for all of them to release the mutex before it can acquire it
  82. // exclusively.
  83. void ReaderLock() ACQUIRE_SHARED();
  84.  
  85. // Release/unlock an exclusive mutex.
  86. void Unlock() RELEASE();
  87.  
  88. // Release/unlock a shared mutex.
  89. void ReaderUnlock() RELEASE_SHARED();
  90.  
  91. // Try to acquire the mutex. Returns true on success, and false on failure.
  92. bool TryLock() TRY_ACQUIRE(true);
  93.  
  94. // Try to acquire the mutex for read operations.
  95. bool ReaderTryLock() TRY_ACQUIRE_SHARED(true);
  96.  
  97. // Assert that this mutex is currently held by the calling thread.
  98. void AssertHeld() ASSERT_CAPABILITY(this);
  99.  
  100. // Assert that is mutex is currently held for read operations.
  101. void AssertReaderHeld() ASSERT_SHARED_CAPABILITY(this);
  102.  
  103. // For negative capabilities.
  104. const Mutex& operator!() const { return *this; }
  105. };
  106.  
  107. // MutexLocker is an RAII class that acquires a mutex in its constructor, and
  108. // releases it in its destructor.
  109. class SCOPED_CAPABILITY MutexLocker {
  110. private:
  111. Mutex* mut;
  112.  
  113. public:
  114. MutexLocker(Mutex *mu) ACQUIRE(mu) : mut(mu) {
  115. mu->Lock();
  116. }
  117. ~MutexLocker() RELEASE() {
  118. mut->Unlock();
  119. }
  120. };
  121.  
  122. #ifdef USE_LOCK_STYLE_THREAD_SAFETY_ATTRIBUTES
  123. // The original version of thread safety analysis the following attribute
  124. // definitions. These use a lock-based terminology. They are still in use
  125. // by existing thread safety code, and will continue to be supported.
  126.  
  127. // Deprecated.
  128. #define PT_GUARDED_VAR \
  129. THREAD_ANNOTATION_ATTRIBUTE__(pt_guarded_var)
  130.  
  131. // Deprecated.
  132. #define GUARDED_VAR \
  133. THREAD_ANNOTATION_ATTRIBUTE__(guarded_var)
  134.  
  135. // Replaced by REQUIRES
  136. #define EXCLUSIVE_LOCKS_REQUIRED(...) \
  137. THREAD_ANNOTATION_ATTRIBUTE__(exclusive_locks_required(__VA_ARGS__))
  138.  
  139. // Replaced by REQUIRES_SHARED
  140. #define SHARED_LOCKS_REQUIRED(...) \
  141. THREAD_ANNOTATION_ATTRIBUTE__(shared_locks_required(__VA_ARGS__))
  142.  
  143. // Replaced by CAPABILITY
  144. #define LOCKABLE \
  145. THREAD_ANNOTATION_ATTRIBUTE__(lockable)
  146.  
  147. // Replaced by SCOPED_CAPABILITY
  148. #define SCOPED_LOCKABLE \
  149. THREAD_ANNOTATION_ATTRIBUTE__(scoped_lockable)
  150.  
  151. // Replaced by ACQUIRE
  152. #define EXCLUSIVE_LOCK_FUNCTION(...) \
  153. THREAD_ANNOTATION_ATTRIBUTE__(exclusive_lock_function(__VA_ARGS__))
  154.  
  155. // Replaced by ACQUIRE_SHARED
  156. #define SHARED_LOCK_FUNCTION(...) \
  157. THREAD_ANNOTATION_ATTRIBUTE__(shared_lock_function(__VA_ARGS__))
  158.  
  159. // Replaced by RELEASE and RELEASE_SHARED
  160. #define UNLOCK_FUNCTION(...) \
  161. THREAD_ANNOTATION_ATTRIBUTE__(unlock_function(__VA_ARGS__))
  162.  
  163. // Replaced by TRY_ACQUIRE
  164. #define EXCLUSIVE_TRYLOCK_FUNCTION(...) \
  165. THREAD_ANNOTATION_ATTRIBUTE__(exclusive_trylock_function(__VA_ARGS__))
  166.  
  167. // Replaced by TRY_ACQUIRE_SHARED
  168. #define SHARED_TRYLOCK_FUNCTION(...) \
  169. THREAD_ANNOTATION_ATTRIBUTE__(shared_trylock_function(__VA_ARGS__))
  170.  
  171. // Replaced by ASSERT_CAPABILITY
  172. #define ASSERT_EXCLUSIVE_LOCK(...) \
  173. THREAD_ANNOTATION_ATTRIBUTE__(assert_exclusive_lock(__VA_ARGS__))
  174.  
  175. // Replaced by ASSERT_SHARED_CAPABILITY
  176. #define ASSERT_SHARED_LOCK(...) \
  177. THREAD_ANNOTATION_ATTRIBUTE__(assert_shared_lock(__VA_ARGS__))
  178.  
  179. // Replaced by EXCLUDE_CAPABILITY.
  180. #define LOCKS_EXCLUDED(...) \
  181. THREAD_ANNOTATION_ATTRIBUTE__(locks_excluded(__VA_ARGS__))
  182.  
  183. // Replaced by RETURN_CAPABILITY
  184. #define LOCK_RETURNED(x) \
  185. THREAD_ANNOTATION_ATTRIBUTE__(lock_returned(x))
  186.  
  187. #endif // USE_LOCK_STYLE_THREAD_SAFETY_ATTRIBUTES
  188.  
  189. #endif // THREAD_SAFETY_ANALYSIS_MUTEX_H
 
原文地址:https://clang.llvm.org/docs/ThreadSafetyAnalysis.html

clang的线程安全分析模块 thread safety analysis的更多相关文章

  1. Clang的线程安全分析静态工具

    本文内容来自 Thread Safety Analysis,如需完整学习,请参考相关链接. Clang线程安全分析工具是C++语言的一种扩展,用于警告代码中潜在的竞争条件.它在编译期间进行静态分析,无 ...

  2. Thread Safety线程安全

    Thread Safe(线程安全)和None Thread Safe(NTS,非线程安全)之分 如果disabled就选择nts(php_stomp-1.0.9-5.5-nts-vc11-x86.zi ...

  3. 折返(Reentrancy)VS线程安全(Thread safety)

    在Wiki上,折返例如,下面的定义(接) In computing, a computer program or subroutine is called reentrant if it can be ...

  4. 线程安全 Thread Safety Problem scala concurrency 并发

    小结: 1.基于java并发模型 Scala concurrency is built on top of the Java concurrency model. 2. 将每个请求放入一个新的线程 T ...

  5. Thread Safety in Java(java中的线程安全)

    Thread Safety in Java is a very important topic. Java provide multi-threaded environment support usi ...

  6. {Python之线程} 一 背景知识 二 线程与进程的关系 三 线程的特点 四 线程的实际应用场景 五 内存中的线程 六 用户级线程和内核级线程(了解) 七 python与线程 八 Threading模块 九 锁 十 信号量 十一 事件Event 十二 条件Condition(了解) 十三 定时器

    Python之线程 线程 本节目录 一 背景知识 二 线程与进程的关系 三 线程的特点 四 线程的实际应用场景 五 内存中的线程 六 用户级线程和内核级线程(了解) 七 python与线程 八 Thr ...

  7. Java线程问题分析定位

    Java线程问题分析定位 分析步骤: 1.使用top命令查看系统资源占用情况,发现Java进程占用大量CPU资源,PID为11572: 2.显示进程详细列表命令:ps -mp 11572 -o THR ...

  8. jstack和线程dump分析

    转自:http://jameswxx.iteye.com/blog/1041173 一:jstack jstack命令的语法格式: jstack  <pid>.可以用jps查看java进程 ...

  9. java线程池分析和应用

    比较 在前面的一些文章里,我们已经讨论了手工创建和管理线程.在实际应用中我们有的时候也会经常听到线程池这个概念.在这里,我们可以先针对手工创建管理线程和通过线程池来管理做一个比较.通常,我们如果手工创 ...

随机推荐

  1. Swift字符串的介绍

    字符串的介绍 字符串在任何的开发中使用都是非常频繁的 OC和Swift中字符串的区别 在OC中字符串类型时NSString,在Swift中字符串类型是String OC中字符串@"" ...

  2. Android状态栏微技巧,带你真正理解沉浸式模式【转】

    感谢! 本文转自大佬郭霖:http://blog.csdn.net/guolin_blog/article/details/51763825 转载请注明出处:http://blog.csdn.net/ ...

  3. 关于CSS3样式中的前缀问题

    作为新手,有的时候在写css时分不清什么属性需要用到前缀,或者用什么前缀,下面是我平时学习的一些总结. 在了解这些前缀之前,先介绍一下各大主流浏览器的内核: IE--trident(国内很多双核浏览器 ...

  4. Foundation框架介绍

    1.Foundation框架介绍 什么是框架? 众多功能\API的集合 框架是由许多类.方法.函数.文档按照一定的逻辑组织起来的集合,以便使研发程序变得更容易,在OS X下的Mac操作系统中大约有80 ...

  5. 简单实现UITableView索引功能(中英文首字母索引)(一) ByH罗

    UITableView索引功能是常见的,主要是获取中英文的首字母并排序,系统自带获取首字母 //系统获取首字母 - (NSString *) pinyinFirstLetter:(NSString*) ...

  6. SQL 游标 指针

    DECLARE @radioScoreRate decimal DECLARE @checkScoreRate decimal DECLARE @judgeScoreRate decimal DECL ...

  7. 「 题解 」P2487 [SDOI2011]拦截导弹

    简单题意 给定 \(n\) 个数对 \((h_i, v_i)\). 求: 最长不上升子序列的长度. 对于每个 \(i\),分别求出包含数对 \((h_i, v_i)\) 的最长上升子序列的个数和最长不 ...

  8. 他人学习Python感悟

    作者:王一 链接:https://www.zhihu.com/question/26235428/answer/36568428 来源:知乎 著作权归作者所有.商业转载请联系作者获得授权,非商业转载请 ...

  9. 有手就行7——*项目构建细节2-钩子(webhook) 配置

    有手就行7--*项目构建细节2-钩子(webhook) 配置 钩子服务  1)开启webhook功能 使用root账户登录到后台,点击Admin Area -> Settings -> N ...

  10. Worms

    474B Worms time limit per test 1 second memory limit per test 256 megabytes input standard input out ...