angeldevil1
angeldevil1

Android指针管理：RefBase,SP,WP

        Android中通过引用计数来实现智能指针，并且实现有强指针与弱指针。由对象本身来提供引用计数器，但是对象不会去维护引用计数器的值，而是由智能指针来管理。

        要达到所有对象都可用引用计数器实现智能指针管理的目标，可以定义一个公共类，提供引用计数的方法，所有对象都去继承这个公共类，这样就可以实现所有对象都可以用引用计数来管理的目标，在Android中，这个公共类就是RefBase，同时还有一个简单版本LightRefBase。

        RefBase作为公共基类提供了引用计数的方法，但是并不去维护引用计数的值，而是由两个智能指针来进行管理：sp(Strong Pointer)和wp(Weak Pointer)，代表强引用计数和弱引用计数。

 

一、轻量级引用计数的实现：LightRefBase

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
template  < class  T>
class  LightRefBase
{
public :
     inline  LightRefBase() : mCount(0) { }
     inline  void  incStrong( const  void * id)  const  {
         android_atomic_inc(&mCount);
     }
     inline  void  decStrong( const  void * id)  const  {
         if  (android_atomic_dec(&mCount) == 1) {
             delete  static_cast < const  T*>( this );
         }
     }
     //! DEBUGGING ONLY: Get current strong ref count.
     inline  int32_t getStrongCount()  const  {
         return  mCount;
     }
     typedef  LightRefBase<T> basetype;
protected :
     inline  ~LightRefBase() { }
private :
     mutable  volatile  int32_t mCount;
};

        LightRefBase的实现很简单，只是内部保存了一个变量用于保存对象被引用的次数，并提供了两个函数用于增加或减少引用计数。

 

二、sp(Strong Pointer)

        LightRefBase仅仅提供了引用计数的方法，具体引用数应该怎么管理，就要通过智能指针类来管理了，每当有一个智能指针指向对象时，对象的引用计数要加1，当一个智能指针取消指向对象时，对象的引用计数要减1，在C＋＋中，当一个对象生成和销毁时会自动调用（拷贝）构造函数和析构函数，所以，对对象引用数的管理就可以放到智能指针的（拷贝）构造函数和析构函数中。Android提供了一个智能指针可以配合LightRefBase使用：sp，sp的定义如下：

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
template  < typename  T>
class  sp
{
public :
     inline  sp() : m_ptr(0) { }
     sp(T* other);
     sp( const  sp<T>& other);
                                          
     template < typename  U> sp(U* other);
     template < typename  U> sp( const  sp<U>& other);
                                        
     ~sp();
                                          
     // Assignment
     sp& operator = (T* other);
     sp& operator = ( const  sp<T>& other);
                                          
     template < typename  U> sp& operator = ( const  sp<U>& other);
     template < typename  U> sp& operator = (U* other);
                                          
     //! Special optimization for use by ProcessState (and nobody else).
     void  force_set(T* other);
                                          
     // Reset
     void  clear();
                                          
     // Accessors
     inline   T&      operator* ()  const   {  return  *m_ptr; }
     inline   T*      operator-> ()  const  {  return  m_ptr;  }
     inline   T*      get()  const          {  return  m_ptr; }
                                          
     // Operators
     COMPARE(==)
     COMPARE(!=)
     COMPARE(>)
     COMPARE(<)
     COMPARE(<=)
     COMPARE(>=)
private :  
     template < typename  Y>  friend  class  sp;
     template < typename  Y>  friend  class  wp;
     void  set_pointer(T* ptr);
     T* m_ptr;
};

        代码比较多，其中Accessors部分代码重载了*、->操作符使我们使用sp的时候就像使用真实的对象指针一样，可以直接操作对象的属性或方法，COMPARE是宏定义，用于重载关系操作符，由于对引用计数的控制主要是由（拷贝）构造函数和析构函数控制，所以忽略其他相关代码后，sp可以精简为如下形式（赋值操作符也省略掉了，构造函数省略相似的两个）：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
template  < typename  T>
class  sp
{
public :
     inline  sp() : m_ptr(0) { }
     sp(T* other);
     sp( const  sp<T>& other);
                                        
     ~sp();
                                        
private :  
     template < typename  Y>  friend  class  sp;
     template < typename  Y>  friend  class  wp;
     void  set_pointer(T* ptr);
     T* m_ptr;
};

        默认构造函数使智能指针不指向任何对象，sp(T* other)与sp(const sp<T>& other)的实现如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
template < typename  T>
sp<T>::sp(T* other)
: m_ptr(other)
{
     if  (other) other->incStrong( this );
}
                                       
template < typename  T>
sp<T>::sp( const  sp<T>& other)
: m_ptr(other.m_ptr)
{
     if  (m_ptr) m_ptr->incStrong( this );
}

 

        内部变量m_ptr指向实际对象，并调用实际对象的incStrong函数，T继承自LightRefBase，所以此处调用的是LightRefBase的incStrong函数，之后实际对象的引用计数加1。

        当智能指针销毁的时候调用智能指针的析构函数：

    

1
2
3
4
5
template < typename  T>
sp<T>::~sp()
{
     if  (m_ptr) m_ptr->decStrong( this );
}

        调用实际对象即LightRefBase的decStrong函数，其实现如下：

1
2
3
4
5
inline  void  decStrong( const  void * id)  const  {
     if  (android_atomic_dec(&mCount) == 1) {
         delete  static_cast < const  T*>( this );
     }
}

        android_atomic_dec返回mCount减1之前的值，如果返回1表示这次减过之后引用计数就是0了，就把对象delete掉。

 

三、RefBase

        RefBase提供了更强大的引用计数的管理。

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
64
65
66
67
68
69
70
71
72
73
74
class  RefBase
{
public :
     void     incStrong( const  void * id)  const ;
     void     decStrong( const  void * id)  const ;
     void     forceIncStrong( const  void * id)  const ;
     //! DEBUGGING ONLY: Get current strong ref count.
     int32_t getStrongCount()  const ;
                                 
     class  weakref_type
     {
     public :
         RefBase refBase()  const ;
         void     incWeak( const  void * id);
         void     decWeak( const  void * id);
         // acquires a strong reference if there is already one.
         bool     attemptIncStrong( const  void * id);
         // acquires a weak reference if there is already one.
         // This is not always safe. see ProcessState.cpp and BpBinder.cpp
         // for proper use.
         bool     attemptIncWeak( const  void * id);
         //! DEBUGGING ONLY: Get current weak ref count.
         int32_t getWeakCount()  const ;
         //! DEBUGGING ONLY: Print references held on object.
         void     printRefs()  const ;
         //! DEBUGGING ONLY: Enable tracking for this object.
         // enable -- enable/disable tracking
         // retain -- when tracking is enable, if true, then we save a stack trace
         //           for each reference and dereference; when retain == false, we
         //           match up references and dereferences and keep only the
         //           outstanding ones.
         void     trackMe( bool  enable,  bool  retain);
     };
     weakref_type*   createWeak( const  void * id)  const ;
     weakref_type*   getWeakRefs()  const ;
     // DEBUGGING ONLY: Print references held on object.
     inline   void             printRefs()  const  { getWeakRefs()->printRefs(); }
     // DEBUGGING ONLY: Enable tracking of object.
     inline   void             trackMe( bool  enable,  bool  retain)
     {
         getWeakRefs()->trackMe(enable, retain);
     }
     typedef  RefBase basetype;
                                     
protected :
     RefBase();
     virtual      ~RefBase();
                                     
     //! Flags for extendObjectLifetime()
     enum  {
         OBJECT_LIFETIME_STRONG  = 0x0000,
         OBJECT_LIFETIME_WEAK    = 0x0001,
         OBJECT_LIFETIME_MASK    = 0x0003
     };
                                     
     void     extendObjectLifetime(int32_t mode);
     //! Flags for onIncStrongAttempted()
     enum  {
         FIRST_INC_STRONG = 0x0001
     };
                                     
     virtual  void             onFirstRef();
     virtual  void             onLastStrongRef( const  void * id);
     virtual  bool             onIncStrongAttempted(uint32_t flags,  const  void * id);
     virtual  void             onLastWeakRef( const  void * id);
                                     
private :
     friend  class  weakref_type;
     class  weakref_impl;
                                     
     RefBase( const  RefBase& o);
     RefBase&        operator=( const  RefBase& o);
     weakref_impl*  const  mRefs;
};

 

        不同于LightRefBase的是，RefBase内部并没有使用一个变量来维护引用计数，而是通过一个weakref_impl *类型的成员来维护引用计数，并且同时提供了强引用计数和弱引用计数。weakref_impl继承于RefBase::weakref_type，代码比较多，不过大都是调试代码，由宏定义分开，Release是不包含调试代码的，去除这些代码后其定义为：

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
#define INITIAL_STRONG_VALUE (1<<28)
                                
class  RefBase::weakref_impl :  public  RefBase::weakref_type 
{ 
public : 
     volatile  int32_t    mStrong; 
     volatile  int32_t    mWeak; 
     RefBase*  const       mBase; 
     volatile  int32_t    mFlags; 
                                   
     weakref_impl(RefBase* base) 
         : mStrong(INITIAL_STRONG_VALUE) 
         , mWeak(0) 
         , mBase(base) 
         , mFlags(0) 
     { 
     } 
                                   
     void  addStrongRef( const  void *  /*id*/ ) { } 
     void  removeStrongRef( const  void *  /*id*/ ) { } 
     void  addWeakRef( const  void *  /*id*/ ) { } 
     void  removeWeakRef( const  void *  /*id*/ ) { } 
     void  printRefs()  const  { } 
     void  trackMe( bool ,  bool ) { } 
};

        weakref_impl中的函数都是作为调试用，Release版的实现都是空的，成员变量分别表示强引用数、弱引用数、指向实际对象的指针与flag，flag可控制实际对象的生命周期，取值为0或RefBase中定义的枚举值。

        RefBase提供了incStrong与decStrong函数用于控制强引用计数值，其弱引用计数值是由weakref_impl控制，强引用计数与弱引用数都保存在weakref_impl *类型的成员变量mRefs中。

        RefBase同LightRefBase一样为对象提供了引用计数的方法，对引用计数的管理同样要由智能指针控制，由于RefBase同时实现了强引用计数与弱引用计数，所以就有两种类型的智能指针，sp(Strong Pointer)与wp(Weak Pointer)。

 

        sp前面已经说过，其（拷贝）构造函数调用对象即RefBase的incStrong函数。

1
2
3
4
5
6
7
8
9
10
11
12
13
void  RefBase::incStrong( const  void * id)  const
{
     weakref_impl*  const  refs = mRefs;
     refs->incWeak(id);
     refs->addStrongRef(id);
     const  int32_t c = android_atomic_inc(&refs->mStrong);
     LOG_ASSERT(c > 0,  "incStrong() called on %p after last strong ref" , refs);
     if  (c != INITIAL_STRONG_VALUE)  {
         return ;
     }
     android_atomic_add(-INITIAL_STRONG_VALUE, &refs->mStrong);
     refs->mBase->onFirstRef();
}

        addStrong的函数体为空，incStrong函数内部首先调用成员变量mRefs的incWeak函数将弱引用数加1，然后再将强引用数加1，由于android_atomic_inc返回变量的旧值，所以如果其不等于INITIAL_STRONG_VALUE就直接返回，则则是第一次由强智能指针（sp）引用，将其减去INITIAL_STRONG_VALUE后变成1，然后调用对象的onFirstRef。

        成员变量mRefs是在对象的构造函数中初始化的：

1
2
3
4
RefBase::RefBase()
     : mRefs( new  weakref_impl( this ))
{
}

        weakrel_impl的incWeak继承自父类weakrel_type的incWeak：

1
2
3
4
5
6
7
void  RefBase::weakref_type::incWeak( const  void * id)
{
     weakref_impl*  const  impl =  static_cast <weakref_impl*>
     impl->addWeakRef(id);
     const  int32_t c = android_atomic_inc(&impl->mWeak);
     LOG_ASSERT(c >= 0,  "incWeak called on %p after last weak ref" ,  this );
}

        addWeakRef实现同样为空，所以只是将弱引用计数加1。所以当对象被sp引用后，强引用计数与弱引用计数会同时加1。

        当sp销毁时其析构函数调用对象即RefBase的decStrong函数：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
void  RefBase::decStrong( const  void * id)  const
{ 
     weakref_impl*  const  refs = mRefs; 
     refs->removeStrongRef(id); 
     const  int32_t c = android_atomic_dec(&refs->mStrong);
     if  (c == 1) { 
         const_cast <RefBase*>( this )->onLastStrongRef(id); 
         if  ((refs->mFlags&OBJECT_LIFETIME_WEAK) != OBJECT_LIFETIME_WEAK) { 
             delete  this ; 
         }
     } 
     refs->removeWeakRef(id); 
     refs->decWeak(id); 
}

        decStrong中将强引用数与弱引用数同时减1，如果这是最后一个强引用的话，会调用对象的onLastStrongRef，并且判断成员变量mRefs的成员变量mFlags来决定是否在对象的强引用数为0时释放对象。

        mFlags可以为0或以下两个枚举值：

1
2
3
4
enum  {
     OBJECT_LIFETIME_WEAK    = 0x0001,
     OBJECT_LIFETIME_FOREVER    = 0x0003
};

        mFlags的值可以通过extendObjectLifetime函数改变：

1
2
3
4
void  RefBase::extendObjectLifetime(int32_t mode)
{
     android_atomic_or(mode, &mRefs->mFlags);
}

        OBJECT_LIFETIME_FOREVER包含OBJECT_LIFETIME_WEAK（位运算中其二进制11包含01），所以当

1
refs->mFlags&OBJECT_LIFETIME_WEAK) != OBJECT_LIFETIME_WEAK

        为true时表示mFlags为0，实际对象的生命周期受强引用数控制，所以在强引用数为0时delete this，否则实际对象的生命周期就由弱引用数控制。

        再来看decWeak：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
void  RefBase::weakref_type::decWeak( const  void * id) 
{ 
     weakref_impl*  const  impl =  static_cast <weakref_impl*>( this ); 
     impl->removeWeakRef(id); 
     const  int32_t c = android_atomic_dec(&impl->mWeak); 
     if  (c != 1)  return ; 
                          
     if  ((impl->mFlags&OBJECT_LIFETIME_WEAK) != OBJECT_LIFETIME_WEAK) { 
         if  (impl->mStrong == INITIAL_STRONG_VALUE) 
             delete  impl->mBase; 
         else  { 
             delete  impl; 
         } 
     }  else  { 
         impl->mBase->onLastWeakRef(id); 
         if  ((impl->mFlags&OBJECT_LIFETIME_FOREVER) != OBJECT_LIFETIME_FOREVER) { 
             delete  impl->mBase; 
         } 
     } 
}

        将弱引用数减1，若减1后不为0直接返回，否则判断

1
(impl->mFlags&OBJECT_LIFETIME_WEAK) != OBJECT_LIFETIME_WEAK

    1. 判断结果为true：

实际对象生命周期被强引用数控制，接下来判断：

1
mpl->mStrong == INITIAL_STRONG_VALUE

    1. 如果判断为true表示对象只被弱引用引用过，现在弱引用数为0，直接删除实际对象。

    2. 如果判断为false，表示对象曾经被强引用引用过，但现在强引用为变为0了（因为增加或减小强引用数时一定同时增加或减小弱引用数，所以弱引用数为0时，强引用数一定为0），弱引用数为0了，直接释放mRefs，而实际对象由于受强引用数控制，已经在RefBase::decStrong中被delete了。

  1. 判断结果为false:

    判断mFlgs是否是OBJECT_LIFETIME_FOREVER，如果是，什么都不作由用户自己控制对象的生命周期，否则，实际对象的生命周期受弱引用数控制，现在弱引用数为0，delete实际对象。

四、wp(Weak Pointer)

        定义如下：

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
template  < typename  T>
class  wp
{
public :
     typedef  typename  RefBase::weakref_type weakref_type;
                     
     inline  wp() : m_ptr(0) { }
                 
     wp(T* other);
     wp( const  wp<T>& other);
     wp( const  sp<T>& other);
     template < typename  U> wp(U* other);
     template < typename  U> wp( const  sp<U>& other);
     template < typename  U> wp( const  wp<U>& other);
                 
     ~wp();
                     
     // Assignment
                 
     wp& operator = (T* other);
     wp& operator = ( const  wp<T>& other);
     wp& operator = ( const  sp<T>& other);
                     
     template < typename  U> wp& operator = (U* other);
     template < typename  U> wp& operator = ( const  wp<U>& other);
     template < typename  U> wp& operator = ( const  sp<U>& other);
                     
     void  set_object_and_refs(T* other, weakref_type* refs);
                 
     // promotion to sp
                     
     sp<T> promote()  const ;
                 
     // Reset
                     
     void  clear();
                 
     // Accessors
                     
     inline   weakref_type* get_refs()  const  {  return  m_refs; }
                     
     inline   T* unsafe_get()  const  {  return  m_ptr; }
                 
     // Operators
                         
     COMPARE(==)
     COMPARE(!=)
     COMPARE(>)
     COMPARE(<)
     COMPARE(<=)
     COMPARE(>=)
                 
private :
     template < typename  Y>  friend  class  sp;
     template < typename  Y>  friend  class  wp;
                 
     T*              m_ptr;
     weakref_type*   m_refs;
};

        同sp一样，m_ptr指向实际对象，但wp还有一个成员变量m_refs。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
template < typename  T>
wp<T>::wp(T* other)
     : m_ptr(other)
{
     if  (other) m_refs = other->createWeak( this );
}
                  
template < typename  T>
wp<T>::wp( const  wp<T>& other)
     : m_ptr(other.m_ptr), m_refs(other.m_refs)
{
     if  (m_ptr) m_refs->incWeak( this );
}
                 
RefBase::weakref_type* RefBase::createWeak( const  void * id)  const
{
     mRefs->incWeak(id);
     return  mRefs;
}

        可以看到，wp的m_refs就是RefBase即实际对象的mRefs。

        wp析构的时候减少弱引用计数：

1
2
3
4
5
template < typename  T>
wp<T>::~wp()
{
     if  (m_ptr) m_refs->decWeak( this );
}

        由于弱指针没有重载*与->操作符，所以不能直接操作指向的对象，虽然有unsafe_get函数，但像名字所示的，不建议使用，直接使用实际对象指针的话就没必要用智能指针了。

        因为弱指针不能直接操作对象，所以要想操作对象的话就要将其转换为强指针，即wp::promote方法：

1
2
3
4
5
6
7
8
9
10
11
template < typename  T>
sp<T> wp<T>::promote()  const
{
     return  sp<T>(m_ptr, m_refs);
}
                
template < typename  T>
sp<T>::sp(T* p, weakref_type* refs)
     : m_ptr((p && refs->attemptIncStrong( this )) ? p : 0)
{
}

        是否能从弱指针生成一个强指针关键是看refs->attemptIncStrong，看其定义：

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
bool  RefBase::weakref_type::attemptIncStrong( const  void * id)
{
     incWeak(id);
                    
     weakref_impl*  const  impl =  static_cast <weakref_impl*>( this );
                    
     int32_t curCount = impl->mStrong;
     LOG_ASSERT(curCount >= 0,  "attemptIncStrong called on %p after underflow" ,
                this );
     while  (curCount > 0 && curCount != INITIAL_STRONG_VALUE) {
         if  (android_atomic_cmpxchg(curCount, curCount+1, &impl->mStrong) == 0) {
             break ;
         }
         curCount = impl->mStrong;
     }
                    
     if  (curCount <= 0 || curCount == INITIAL_STRONG_VALUE) {
         bool  allow;
         if  (curCount == INITIAL_STRONG_VALUE) {
             // Attempting to acquire first strong reference...  this is allowed
             // if the object does NOT have a longer lifetime (meaning the
             // implementation doesn't need to see this), or if the implementation
             // allows it to happen.
             allow = (impl->mFlags&OBJECT_LIFETIME_WEAK) != OBJECT_LIFETIME_WEAK
                   || impl->mBase->onIncStrongAttempted(FIRST_INC_STRONG, id);
         }  else  {
             // Attempting to revive the object...  this is allowed
             // if the object DOES have a longer lifetime (so we can safely
             // call the object with only a weak ref) and the implementation
             // allows it to happen.
             allow = (impl->mFlags&OBJECT_LIFETIME_WEAK) == OBJECT_LIFETIME_WEAK
                   && impl->mBase->onIncStrongAttempted(FIRST_INC_STRONG, id);
         }
         if  (!allow) {
             decWeak(id);
             return  false ;
         }
         curCount = android_atomic_inc(&impl->mStrong);
                
         // If the strong reference count has already been incremented by
         // someone else, the implementor of onIncStrongAttempted() is holding
         // an unneeded reference.  So call onLastStrongRef() here to remove it.
         // (No, this is not pretty.)  Note that we MUST NOT do this if we
         // are in fact acquiring the first reference.
         if  (curCount > 0 && curCount < INITIAL_STRONG_VALUE) {
             impl->mBase->onLastStrongRef(id);
         }
     }
                    
     impl->addWeakRef(id);
     impl->addStrongRef(id);
                
#if PRINT_REFS
     LOGD( "attemptIncStrong of %p from %p: cnt=%d\n" ,  this , id, curCount);
#endif
                
     if  (curCount == INITIAL_STRONG_VALUE) {
         android_atomic_add(-INITIAL_STRONG_VALUE, &impl->mStrong);
         impl->mBase->onFirstRef();
     }
                    
     return  true ;
}

        首先通过incWeak将弱引用数加1（被强指针sp引用会导致强引用数和弱引用数同时加1），然后：

1
2
3
4
5
6
7
int32_t curCount = impl->mStrong;
while  (curCount > 0 && curCount != INITIAL_STRONG_VALUE) {
     if  (android_atomic_cmpxchg(curCount, curCount+1, &impl->mStrong) == 0) {
         break ;
     }
     curCount = impl->mStrong;
}

        如果之前已经有强引用，直接将强引用数加1，android_atomic_cmpxchg表示如果impl->mStrong的值为curCount，则把impl->mString的值改为curCount+1，此处用while循环是防止其他线程已经增加了强引用数。

   接下来：

1
if  (curCount <= 0 || curCount == INITIAL_STRONG_VALUE)

   表示对象目前没有强引用，这就要判断对象是否存在了。

   如果curCount == INITIAL_STRONG_VALUE，表示对象没有被sp引用过。接下来判断：

 

1
2
allow = (impl->mFlags&OBJECT_LIFETIME_WEAK) != OBJECT_LIFETIME_WEAK
     || impl->mBase->onIncStrongAttempted(FIRST_INC_STRONG, id);

        表示：如果对象的生命周期只受强引用控制，对象一定存在，要有强引用才可以管理对象的释放，所以一定会允许生成强引用；如果对象的生命周期受弱引用控制，调用对象的onIncStrongAttempted试图增加强引用，由于此时在弱引用中，弱引用一定不为0，对象也一定存在，调用onIncStrongAttempted的意图是因为类的实现者可能不希望用强引用引用对象。在RefBase中onIncStrongAttempted默认返回true：

1
2
3
4
bool  RefBase::onIncStrongAttempted(uint32_t flags,  const  void * id)
{
     return  (flags&FIRST_INC_STRONG) ?  true  :  false ;
}

        如果curCount <= 0（只会等于0），表示对象强引用数经历了INITIAL_STRONG_VALUE -->大于0 --> 0，接下来就要判断：

1
2
allow = (impl->mFlags&OBJECT_LIFETIME_WEAK) == OBJECT_LIFETIME_WEAK
     && impl->mBase->onIncStrongAttempted(FIRST_INC_STRONG, id);

        如果对象的生命周期受强引用数控制，那么由于曾被sp引用过，现在强引用数又为0，对象就已经被delete了，所以就不能生成强引用，否则如果对象的生命周期受弱引用数控制，就通过onIncStrongAttempted看类的实现者是否希望当对象的强引用数变为0时可以再次被强引用引用。

1
2
3
4
if  (!allow) {
     decWeak(id);
     return  false ;
}

    如果allow为false表示不能从弱引用生成强引用，就要调用decWeak将弱引用减1（因为在promote入口先将弱引用加了1），然后返回false表示生成强引用失败。

1
2
3
4
if  (curCount == INITIAL_STRONG_VALUE) {
     android_atomic_add(-INITIAL_STRONG_VALUE, &impl->mStrong);
     impl->mBase->onFirstRef();
}

    最后，如果curCount == INITIAL_STRONG_VALUE表示第一次被sp引用，调用对象的onFirstRef函数。

五、总结

        RefBase内部有一个指针指向实际对象，有一个weakref_impl类型的指针保存对象的强／弱引用计数、对象生命周期控制。

 

       sp只有一个成员变量，用来保存实际对象，但这个实际对象内部已包含了weakref_impl *对象用于保存实际对象的引用计数。sp 管理一个对象指针时，对象的强、弱引用数同时加1，sp销毁时，对象的强、弱引用数同时减1。

 

        wp中有两个成员变量，一个保存实际对象，另一个是weakref_impl *对象。wp管理一个对象指针时，对象的弱引用计数加1，wp销毁时，对象的弱引用计数减1。

 

        weakref_impl中包含一个flag用于决定对象的生命周期是由强引用数控制还是由弱引用数控制：

  • 当flag为0时，实际对象的生命周期由强引用数控制，weakref_impl *对象由弱引用数控制。

  • 当flag为OBJECT_LIFETIME_WEAK时，实际对象的生命周期受弱引用数控制。

  • 当flag为OBJECT_LIFETIME_FOREVER时，实际对象的生命周期由用户控制。

        可以用extendObjectLifetime改变flag的值。

你可能感兴趣的:(Android指针管理：RefBase,SP,WP)

  • 关于沟通这件事，项目经理不需要每次都面对面进行 流程大师兄
    很多项目经理都会遇到这样的问题，项目中由于事情太多，根本没有足够的时间去召开会议，那在这种情况下如何去有效地管理项目中的利益相关者？当然，不建议电子邮件也不需要开会的话，建议可以采取下面几种方式来形成有效的沟通，这几种方式可以帮助你努力的通过各种办法来保持和各方面的联系。项目经理首先要问自己几个问题，项目中哪些利益相关者是必须要进行沟通的？可以列出项目中所有的利益相关者清单，同时也整理出项目中哪些
  • android系统selinux中添加新属性property 辉色投像
    1.定位/android/system/sepolicy/private/property_contexts声明属性开头：persist.charge声明属性类型：u:object_r:system_prop:s0图12.定位到android/system/sepolicy/public/domain.te删除neverallow{domain-init}default_prop:property
  • 学点心理知识，呵护孩子健康 静候花开_7090
    昨天听了华中师范大学教育管理学系副教授张玲老师的《哪里才是学生心理健康的最后庇护所，超越教育与技术的思考》的讲座。今天又重新学习了一遍，收获匪浅。张玲博士也注意到了当今社会上的孩子由于心理问题导致的自残、自杀及伤害他人等恶性事件。她向我们普及了一个重要的命题，她说心理健康的一些基本命题，我们与我们通常的一些教育命题是不同的，她还举了几个例子，让我们明白我们原来以为的健康并非心理学上的健康。比如如果
  • Long类型前后端数据不一致 igotyback 前端
    响应给前端的数据浏览器控制台中response中看到的Long类型的数据是正常的到前端数据不一致前后端数据类型不匹配是一个常见问题，尤其是当后端使用Java的Long类型（64位）与前端JavaScript的Number类型（最大安全整数为2^53-1，即16位）进行数据交互时，很容易出现精度丢失的问题。这是因为JavaScript中的Number类型无法安全地表示超过16位的整数。为了解决这个问
  • 水平垂直居中的几种方法（总结） LJ小番茄 CSS_玄学语言htmljavascript前端csscss3
    1.使用flexbox的justify-content和align-items.parent{display:flex;justify-content:center;/*水平居中*/align-items:center;/*垂直居中*/height:100vh;/*需要指定高度*/}2.使用grid的place-items:center.parent{display:grid;place-item
  • C#中使用split分割字符串 互联网打工人no1 c#
    1、用字符串分隔：usingSystem.Text.RegularExpressions;stringstr="aaajsbbbjsccc";string[]sArray=Regex.Split(str,"js",RegexOptions.IgnoreCase);foreach(stringiinsArray)Response.Write(i.ToString()+"");输出结果：aaabbbc
  • WPF中的ComboBox控件几种数据绑定的方式 互联网打工人no1 wpfc#
    一、用字典给ItemsSource赋值（此绑定用的地方很多，建议熟练掌握）在XMAL中：在CS文件中privatevoidBindData(){DictionarydicItem=newDictionary();dicItem.add(1,"北京");dicItem.add(2,"上海");dicItem.add(3,"广州");cmb_list.ItemsSource=dicItem;cmb_l
  • python os.environ_python os.environ 读取和设置环境变量 weixin_39605414 pythonos.environ
    >>>importos>>>os.environ.keys()['LC_NUMERIC','GOPATH','GOROOT','GOBIN','LESSOPEN','SSH_CLIENT','LOGNAME','USER','HOME','LC_PAPER','PATH','DISPLAY','LANG','TERM','SHELL','J2REDIR','LC_MONETARY','QT_QPA
  • 如何部分格式化提示模板:LangChain中的高级技巧 nseejrukjhad langchainjava服务器python
    标题:如何部分格式化提示模板:LangChain中的高级技巧内容:如何部分格式化提示模板:LangChain中的高级技巧引言在使用大型语言模型(LLM)时,提示工程是一个关键环节。LangChain提供了强大的提示模板功能,让我们能更灵活地构建和管理提示。本文将介绍LangChain中一个高级特性-部分格式化提示模板,这个技巧可以让你的提示管理更加高效和灵活。什么是部分格式化提示模板?部分格式化提
  • GitHub上克隆项目 bigbig猩猩 github
    从GitHub上克隆项目是一个简单且直接的过程，它允许你将远程仓库中的项目复制到你的本地计算机上，以便进行进一步的开发、测试或学习。以下是一个详细的步骤指南，帮助你从GitHub上克隆项目。一、准备工作1.安装Git在克隆GitHub项目之前，你需要在你的计算机上安装Git工具。Git是一个开源的分布式版本控制系统，用于跟踪和管理代码变更。你可以从Git的官方网站（https://git-scm.
  • 人生的每一步路都算数 sheli
    如果你想打工，一直靠打工赚钱，那你就会不断的希望自己变得更专业，不断的希望能够获得更好的工作机会，升职加薪。如果你的目标志不在此，而是拥有自己的企业，那你的选择就会出现差别。在认真打工的人眼里，会“不务正业”，会总是选择不同岗位，甚至放弃高薪机会。但是这背后都是有更加长远的规划。成功富人所必需的管理技能包括：1．对现金流的管理。2．对系统的管理。3．对人员的管理。所以，在没有获得这些能力之前，只要
  • 番茄西红柿叶子病害分类数据集12882张11类别 futureflsl 数据集分类数据挖掘人工智能
    数据集类型：图像分类用，不可用于目标检测无标注文件数据集格式：仅仅包含jpg图片，每个类别文件夹下面存放着对应图片图片数量(jpg文件个数)：12882分类类别数：11类别名称:["Bacterial_Spot_Bacteria","Early_Blight_Fungus","Healthy","Late_Blight_Water_Mold","Leaf_Mold_Fungus","Powdery
  • 冬天短期的暴利小生意有哪些？那些小生意适合新手做？ 一起高省
    短期生意不失为创业的一个商机，不过短期生意的商机是转瞬即逝的，而且这类生意也很难作为长期的生意去做，那冬天短期暴利小生意查看更多关于短期暴利小生意的文章有哪些呢?给大家先推荐一个2023年风口项目吧，真很不错的项目，全程零投资，当做副业来做真的很稳定，不管你什么阶层的人，或多或少都网购吧？你们知道网购是可以拿提成，拿返利，拿分佣的吗？你们知道很多优惠券群里面，天天群主和管理发一些商品吗？他们其实在
  • 【华为OD技术面试真题 - 技术面】- python八股文真题题库（4) 算法大师 华为od面试python
    华为OD面试真题精选专栏：华为OD面试真题精选目录:2024华为OD面试手撕代码真题目录以及八股文真题目录文章目录华为OD面试真题精选**1.Python中的`with`**用途和功能自动资源管理示例：文件操作上下文管理协议示例代码工作流程解析优点2.\_\_new\_\_和**\_\_init\_\_**区别__new____init__区别总结3.**切片（Slicing）操作**基本切片语法
  • 01-Git初识 Meereen Gitgit
    01-Git初识概念：一个免费开源，分布式的代码版本控制系统，帮助开发团队维护代码作用：记录代码内容。切换代码版本，多人开发时高效合并代码内容如何学：个人本机使用：Git基础命令和概念多人共享使用：团队开发同一个项目的代码版本管理Git配置用户信息配置：用户名和邮箱，应用在每次提交代码版本时表明自己的身份命令：查看git版本号git-v配置用户名gitconfig--globaluser.name
  • docker igotyback eureka云原生
    Docker容器的文件系统是隔离的，但是可以通过挂载卷（Volumes）或绑定挂载（BindMounts）将宿主机的文件系统目录映射到容器内部。要查看Docker容器的映射路径，可以使用以下方法：查看容器配置：使用dockerinspect命令可以查看容器的详细配置信息，包括挂载的卷。例如：bashdockerinspect在输出的JSON格式中，查找"Mounts"部分，这里会列出所有的挂载信息
  • 果然只有离职的时候，才有人敢说真话！ return2ok
    今天公司出了神贴。今天中午吃饭，同事问我看了论坛上的神贴了吗？什么帖子？我问。同事显得很惊讶，你居然没看，现在那个帖子可能会成为年度最佳帖子。这么厉害？我等不及了，饭没吃完就快速的奔向办公室，打开公司论坛，我要一睹这个帖子的神奇。写这帖子的童鞋胆儿真肥。这哪里是一个帖子，这是很多个帖子，组成了一个系列。某人从公司文化、管理、人事、项目管理等多个方面分析了公司的概况，并抨击了公司的各种弊端，并提出了
  • nosql数据库技术与应用知识点 皆过客，揽星河 NoSQLnosql数据库大数据数据分析数据结构非关系型数据库
    Nosql知识回顾大数据处理流程数据采集(flume、爬虫、传感器)数据存储(本门课程NoSQL所处的阶段)Hdfs、MongoDB、HBase等数据清洗(入仓)Hive等数据处理、分析(Spark、Flink等)数据可视化数据挖掘、机器学习应用(Python、SparkMLlib等)大数据时代存储的挑战(三高)高并发(同一时间很多人访问)高扩展(要求随时根据需求扩展存储)高效率(要求读写速度快)
  • 如何选择最适合你的项目研发管理软件？TAPD卓越版全面解析 北京云巴巴信息技术有限公司 产品经理需求分析
    在当今快速发展的科技时代，项目研发管理软件已成为企业不可或缺的重要工具。面对市场上琳琅满目的产品，如何选择一款适合自己团队的项目研发管理软件呢？本文将围绕项目研发管理软件的选择标准，重点介绍TAPD卓越版的特点、优势以及使用体验，让你更好地理解和选择适合自己的项目研发管理软件。项目研发管理软件的选择标准在选择项目研发管理软件时，我们需要考虑以下几个方面的因素：功能全面性：软件是否覆盖了从需求管理、
  • 第二期心理咨询师培训 第1组分享第八天 张云511
    学会与问题共存—事情不会只有一个面读完本节，印象最深的点就是“扩大白色而非消灭黑色”。其实在班级管理中也是一样，我们暂时不要着急去消灭问题，而是注意学生哪些方面很不错，值得我们去扩大，我们要发现学生的资源与潜力，从正向的意义出发，发挥滴水穿石的力量，让一个个小改变汇集出巨大的改变！调整看事情的角度，不把生活问题扩大，是我们学习“与问题共存”的重要一步。换个角度看问题，会改变自己，也会感动别人！这样
  • 下一站深圳 默琊
    昨天已经买好3/15到深圳的机票了，原本上周还有点拖延症发作，不太积极，所以昨天就直接逼迫自己买机票，然后在订房，下周就是确认行业和把具体的面谈日程定下来。行业的选择上目前没有太大的偏好，上一份工作主要是风控和客服，客服部分也算是个小组长，有负责培训和一些案件SOP流程的制定等工作。总感觉客服这个职位的职涯发展只能是垂直的往更高的管理层走，对于横向发展似乎不容易，而鉴于做客服1年的感受，我不太喜欢
  • SpringBlade dict-biz/list 接口 SQL 注入漏洞 文章永久免费只为良心 oracle数据库
    SpringBladedict-biz/list接口SQL注入漏洞POC:构造请求包查看返回包你的网址/api/blade-system/dict-biz/list?updatexml(1,concat(0x7e,md5(1),0x7e),1)=1漏洞概述在SpringBlade框架中，如果dict-biz/list接口的后台处理逻辑没有正确地对用户输入进行过滤或参数化查询（PreparedSta
  • 和自己结婚，是一种怎样的体验 只如初见_2020
    一个17岁谈恋爱，19岁结婚，然后离了三次婚的女人，站在台上说：“现在我结婚了，和那个一直以来，真正想在一起的人结婚了，那个人就是我自己。”她说，在我9岁前，我已经在二十几个寄养家庭中待过。我从童年到成年，就只有一个目标，不要被落下。而我实现这一目标的方式就是，我要结婚。我第一次的结婚对象，是我17岁时遇到的人。我们两年之后结了婚，当时我19岁。他是个非常好的人，来自于非常棒的家庭，他是工商管理硕
  • TDengine 签约前晨汽车，解锁智能出行的无限潜力 涛思数据（TDengine） tdengine汽车大数据
    在全球汽车产业转型升级的背景下，智能网联和新能源技术正迅速成为商用车行业的重要发展方向。随着市场对环保和智能化需求的日益增强，企业必须在技术创新和数据管理上不断突破，以满足客户对高效、安全和智能出行的期待。在这一背景下，前晨汽车凭借其在新能源智能商用车领域的前瞻性布局和技术实力，成为行业中的佼佼者。前晨汽车采用整车数据采集和全车数据打通策略，能够实时将数据推送至APP端客户。然而，这导致整体写入和
  • 11月，你好 自由自在的白云
    图片发自App今天是11月的第一天阳光明媚，秋日静好。给大家分享一个情绪管理的方法。也许你学习过，也许你还不曾了解，都没有关系，现在，我们一起来温习一下。就像孔老先生说的：学而时习之，温故而知新。种下对的种子，才会结出好的果实。种下情绪良好的种子，就可以收获良好的心态。“你瞧这些白云聚了又散，散了又聚，人生离合，亦复如斯。”世事如此，情绪的变化如山型曲线，一会来了，一会去了。还有那天课堂中老师讲，
  • CentOS的根目录下，/bin 和 /sbin 用途和权限 Energet!c Linux日常centoslinux运维
    CentOS的根目录下，/bin和/sbin用途和权限一、/bin(Binary)二、/sbin(SystemBinary)三、总结在CentOS的根目录下，/bin和/sbin目录有不同的用途和权限一、/bin(Binary)用途:存放系统的基本命令，这些命令对所有用户都是可用的。例如：ls、cp、mv、rm等。权限:普通用户和系统管理员都可以使用这些命令。二、/sbin(SystemBinar
  • 2.2.6 通知类控件 Toast、Menu 常思行
    本文例程下载：WillFlow_Toast、WillFlowMenu一、什么是Toast？Toast也被叫做吐司，是Android系统提供的一种非常好的提醒方式，在程序中可以使用它将一些短小的信息通知给用户，它有如下两个特点：Toast是没有焦点的Toast显示的时间有限过一定的时间就会自动消失所以一般来讲Toast的使用并不会影响我们的正常操作，并且它通常不会占用太大的屏幕空间，有着良好的用户体
  • 为什么你总是对下属不满意? ZhaoWu1050
    【ZhaoWu的听课笔记】大多数公司，都存在两种问题。我创业四年，更是体会深切。这两种问题就是：老板经常不满意下属的表现；下属总是不知道老板想要什么；虽然这两种问题普遍存在，其实解决方法并不复杂。这节课，我们再聊聊第一个问题：为什么老板经常不满意下属表现?其实，这背后也是一条管理常识。管理学家德鲁克先生早就说过：管理者的任务，不是去改变人。*来自《卓有成效的管理者》只是大多数老板和我一样，都是一边
  • 九月班级管理工作反思 追梦蜂
    这个月应该算是最难的一个月，我已N年没当班主任，然后我又开始当了。职称是一方面，想到我如果退休了，不能再接触学生了，那该是多么遗憾的事！我的学生梁*铭是我的榜样，她那么努力，那么拼，那么上进，为什么我不行？虽然我面临的工作很难，但是高考数学也不容易。她拿下来了！满分150分她考了146分！我目睹她的艰辛，她的拼搏！还有，我要为我的孩子做榜样，如何竭尽全力，实现梦想。还有，服务，为社会做事，也是会有
  • 2021-01-24 9ce517ee104c
    【打卡素材】《香帅金融学讲义》【标题】公司治理：怎样同床异梦地过下去【日期】2021.1.24【字数】公司本质上是一连串的合约关系。降低合同执行中的各种摩擦是公司正常有效运行的基础。协同各方的利益、制衡各方的权力是关键。为解决利益冲突问题、协同各方利益，进行权力制衡的机制设计就是公司治理机制。001什么是公司治理治理是管理的基础，治理机制越好，权、责、利就越清晰，管理的目标也就会更容易实现。002
  • [星球大战]阿纳金的背叛 comsci
          本来杰迪圣殿的长老是不同意让阿纳金接受训练的.........     但是由于政治原因,长老会妥协了...这给邪恶的力量带来了机会     所以......现代的地球联邦接受了这个教训...绝对不让某些年轻人进入学院    
  • 看懂它，你就可以任性的玩耍了！ aijuans JavaScript
              javascript作为前端开发的标配技能，如果不掌握好它的三大特点：1.原型 2.作用域 3. 闭包 ,又怎么可以说你学好了这门语言呢？如果标配的技能都没有撑握好，怎么可以任性的玩耍呢？怎么验证自己学好了以上三个基本点呢，我找到一段不错的代码，稍加改动，如果能够读懂它，那么你就可以任性了。 function jClass(b
  • Java常用工具包 Jodd Kai_Ge javajodd
    Jodd 是一个开源的 Java 工具集， 包含一些实用的工具类和小型框架。简单，却很强大！ 写道 Jodd = Tools + IoC + MVC + DB + AOP + TX + JSON + HTML < 1.5 Mb Jodd 被分成众多模块，按需选择，其中 工具类模块有： jodd-core    &nb
  • SpringMvc下载 120153216 springMVC
    @RequestMapping(value = WebUrlConstant.DOWNLOAD) public void download(HttpServletRequest request,HttpServletResponse response,String fileName) { OutputStream os = null; InputStream is = null;
  • Python 标准异常总结 2002wmj python
    Python标准异常总结 AssertionError 断言语句（assert）失败 AttributeError 尝试访问未知的对象属性 EOFError 用户输入文件末尾标志EOF（Ctrl+d） FloatingPointError 浮点计算错误 GeneratorExit generator.close()方法被调用的时候 ImportError 导入模块失
  • SQL函数返回临时表结构的数据用于查询 357029540 SQL Server
    这两天在做一个查询的SQL，这个SQL的一个条件是通过游标实现另外两张表查询出一个多条数据，这些数据都是INT类型，然后用IN条件进行查询，并且查询这两张表需要通过外部传入参数才能查询出所需数据，于是想到了用SQL函数返回值，并且也这样做了，由于是返回多条数据，所以把查询出来的INT类型值都拼接为了字符串，这时就遇到问题了，在查询SQL中因为条件是INT值，SQL函数的CAST和CONVERST都
  • java 时间格式化 | 比较大小| 时区 个人笔记 7454103 javaeclipsetomcatcMyEclipse
    个人总结！ 不当之处多多包含！ 引用 1.0 如何设置 tomcat 的时区：          位置：(catalina.bat---JAVA_OPTS  下面加上)          set JAVA_OPT
  • 时间获取Clander的用法 adminjun Clander时间
    /**    * 得到几天前的时间    * @param d    * @param day    * @return    */   public static Date getDateBefore(Date d,int day){    Calend
  • JVM初探与设置 aijuans java
    JVM是Java Virtual Machine（Java虚拟机）的缩写，JVM是一种用于计算设备的规范，它是一个虚构出来的计算机，是通过在实际的计算机上仿真模拟各种计算机功能来实现的。Java虚拟机包括一套字节码指令集、一组寄存器、一个栈、一个垃圾回收堆和一个存储方法域。 JVM屏蔽了与具体操作系统平台相关的信息，使Java程序只需生成在Java虚拟机上运行的目标代码（字节码）,就可以在多种平台
  • SQL中ON和WHERE的区别 avords
    SQL中ON和WHERE的区别   数据库在通过连接两张或多张表来返回记录时，都会生成一张中间的临时表，然后再将这张临时表返回给用户。   www.2cto.com   在使用left jion时，on和where条件的区别如下：  1、 on条件是在生成临时表时使用的条件，它不管on中的条件是否为真，都会返回左边表中的记录。 
  • 说说自信 houxinyou 工作生活
    自信的来源分为两种,一种是源于实力,一种源于头脑.实力是一个综合的评定,有自身的能力,能利用的资源等.比如我想去月亮上,要身体素质过硬,还要有飞船等等一系列的东西.这些都属于实力的一部分.而头脑不同,只要你头脑够简单就可以了!同样要上月亮上,你想,我一跳,1米,我多跳几下,跳个几年,应该就到了!什么?你说我会往下掉?你笨呀你!找个东西踩一下不就行了吗?     无论工作还
  • WEBLOGIC事务超时设置 bijian1013 weblogicjta事务超时
            系统中统计数据，由于调用统计过程，执行时间超过了weblogic设置的时间，提示如下错误： 统计数据出错! 原因：The transaction is no longer active - status: 'Rolling Back. [Reason=weblogic.transaction.internal
  • 两年已过去，再看该如何快速融入新团队 bingyingao java互联网融入架构新团队
    偶得的空闲，翻到了两年前的帖子 该如何快速融入一个新团队，有所感触，就记下来，为下一个两年后的今天做参考。     时隔两年半之后的今天，再来看当初的这个博客，别有一番滋味。而我已经于今年三月份离开了当初所在的团队，加入另外的一个项目组，2011年的这篇博客之后的时光，我很好的融入了那个团队，而直到现在和同事们关系都特别好。大家在短短一年半的时间离一起经历了一
  • 【Spark七十七】Spark分析Nginx和Apache的access.log bit1129 apache
    Spark分析Nginx和Apache的access.log，第一个问题是要对Nginx和Apache的access.log文件进行按行解析，按行解析就的方法是正则表达式：   Nginx的access.log解析正则表达式   val PATTERN = """([^ ]*) ([^ ]*) ([^ ]*) (\\[.*\\]) (\&q
  • Erlang patch bookjovi erlang
    Totally five patchs committed to erlang otp, just small patchs. IMO, erlang really is a interesting programming language, I really like its concurrency feature. but the functional programming style
  • log4j日志路径中加入日期 bro_feng javalog4j
    要用log4j使用记录日志，日志路径有每日的日期，文件大小5M新增文件。 实现方式 log4j: <appender name="serviceLog" class="org.apache.log4j.RollingFileAppender"> <param name="Encoding" v
  • 读《研磨设计模式》-代码笔记-桥接模式 bylijinnan java设计模式
    声明： 本文只为方便我个人查阅和理解，详细的分析以及源代码请移步 原作者的博客http://chjavach.iteye.com/ /** * 个人觉得关于桥接模式的例子，蜡笔和毛笔这个例子是最贴切的：http://www.cnblogs.com/zhenyulu/articles/67016.html * 笔和颜色是可分离的，蜡笔把两者耦合在一起了：一支蜡笔只有一种
  • windows7下SVN和Eclipse插件安装 chenyu19891124 eclipse插件
    今天花了一天时间弄SVN和Eclipse插件的安装，今天弄好了。svn插件和Eclipse整合有两种方式，一种是直接下载插件包，二种是通过Eclipse在线更新。由于之前Eclipse版本和svn插件版本有差别，始终是没装上。最后在网上找到了适合的版本。所用的环境系统：windows7JDK：1.7svn插件包版本：1.8.16Eclipse：3.7.2工具下载地址：Eclipse下在地址：htt
  • [转帖]工作流引擎设计思路 comsci 设计模式工作应用服务器workflow企业应用
    作为国内的同行，我非常希望在流程设计方面和大家交流，刚发现篇好文(那么好的文章，现在才发现，可惜)，关于流程设计的一些原理，个人觉得本文站得高，看得远，比俺的文章有深度，转载如下 ================================================================================= 自开博以来不断有朋友来探讨工作流引擎该如何
  • Linux 查看内存，CPU及硬盘大小的方法 daizj linuxcpu内存硬盘大小
    一、查看CPU信息的命令 [root@R4 ~]# cat /proc/cpuinfo |grep "model name" && cat /proc/cpuinfo |grep "physical id" model name : Intel(R) Xeon(R) CPU X5450 @ 3.00GHz model name :
  • linux 踢出在线用户 dongwei_6688 linux
    两个步骤： 1.用w命令找到要踢出的用户，比如下面：   [root@localhost ~]# w 18:16:55 up 39 days, 8:27, 3 users, load average: 0.03, 0.03, 0.00 USER TTY FROM LOGIN@ IDLE JCPU PCPU WHAT
  • 放手吧,就像不曾拥有过一样 dcj3sjt126com
    内容提要： 静悠悠编著的《放手吧就像不曾拥有过一样》集结“全球华语世界最舒缓心灵”的精华故事，触碰生命最深层次的感动，献给全世界亿万读者。《放手吧就像不曾拥有过一样》的作者衷心地祝愿每一位读者都给自己一个重新出发的理由，将那些令你痛苦的、扛起的、背负的，一并都放下吧！把憔悴的面容换做一种清淡的微笑，把沉重的步伐调节成春天五线谱上的音符，让自己踏着轻快的节奏，在人生的海面上悠然漂荡，享受宁静与
  • php二进制安全的含义 dcj3sjt126com PHP
    PHP里，有string的概念。 string里，每个字符的大小为byte（与PHP相比，Java的每个字符为Character，是UTF8字符，C语言的每个字符可以在编译时选择）。 byte里，有ASCII代码的字符，例如ABC，123，abc，也有一些特殊字符，例如回车，退格之类的。 特殊字符很多是不能显示的。或者说，他们的显示方式没有标准，例如编码65到哪儿都是字母A，编码97到哪儿都是字符
  • Linux下禁用T440s，X240的一体化触摸板(touchpad) gashero linuxThinkPad触摸板
    自打1月买了Thinkpad T440s就一直很火大，其中最让人恼火的莫过于触摸板。   Thinkpad的经典就包括用了小红点(TrackPoint)。但是小红点只能定位，还是需要鼠标的左右键的。但是自打T440s等开始启用了一体化触摸板，不再有实体的按键了。问题是要是好用也行。   实际使用中，触摸板一堆问题，比如定位有抖动，以及按键时会有飘逸。这就导致了单击经常就
  • graph_dfs hcx2013 Graph
    package edu.xidian.graph; class MyStack { private final int SIZE = 20; private int[] st; private int top; public MyStack() { st = new int[SIZE]; top = -1; } public void push(i
  • Spring4.1新特性——Spring核心部分及其他 jinnianshilongnian spring 4.1
    目录 Spring4.1新特性——综述 Spring4.1新特性——Spring核心部分及其他 Spring4.1新特性——Spring缓存框架增强 Spring4.1新特性——异步调用和事件机制的异常处理 Spring4.1新特性——数据库集成测试脚本初始化 Spring4.1新特性——Spring MVC增强 Spring4.1新特性——页面自动化测试框架Spring MVC T
  • 配置HiveServer2的安全策略之自定义用户名密码验证 liyonghui160com
        具体从网上看   http://doc.mapr.com/display/MapR/Using+HiveServer2#UsingHiveServer2-ConfiguringCustomAuthentication   LDAP Authentication using OpenLDAP Setting
  • 一位30多的程序员生涯经验总结 pda158 编程工作生活咨询
    1.客户在接触到产品之后，才会真正明白自己的需求。 　　这是我在我的第一份工作上面学来的。只有当我们给客户展示产品的时候，他们才会意识到哪些是必须的。给出一个功能性原型设计远远比一张长长的文字表格要好。 2.只要有充足的时间，所有安全防御系统都将失败。 　　安全防御现如今是全世界都在关注的大课题、大挑战。我们必须时时刻刻积极完善它，因为黑客只要有一次成功，就可以彻底打败你。   3.
  • 分布式web服务架构的演变 自由的奴隶 linuxWeb应用服务器互联网
    最开始，由于某些想法，于是在互联网上搭建了一个网站，这个时候甚至有可能主机都是租借的，但由于这篇文章我们只关注架构的演变历程，因此就假设这个时候已经是托管了一台主机，并且有一定的带宽了，这个时候由于网站具备了一定的特色，吸引了部分人访问，逐渐你发现系统的压力越来越高，响应速度越来越慢，而这个时候比较明显的是数据库和应用互相影响，应用出问题了，数据库也很容易出现问题，而数据库出问题的时候，应用也容易
  • 初探Druid连接池之二——慢SQL日志记录 xingsan_zhang 日志连接池druid慢SQL
    由于工作原因，这里先不说连接数据库部分的配置，后面会补上，直接进入慢SQL日志记录。   1.applicationContext.xml中增加如下配置： <bean abstract="true" id="mysql_database" class="com.alibaba.druid.pool.DruidDataSourc
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他