What&#39;s the difference between [`java.lang.ref.WeakReference`](https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/ref/WeakReference.html) and [`java.lang.ref.SoftReference`](https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/ref/SoftReference.html) ?

What&#39;s the difference between SoftReference and WeakReference in Java?

Swift has:

- Strong References
- Weak References
- Unowned References



How is an unowned reference different from a weak reference?

When is it safe to use an unowned reference?

Are unowned references a security risk like [dangling pointers][1] in C/C++?


  [1]: http://en.wikipedia.org/wiki/Dangling_pointer

What is the difference between a weak reference and an unowned reference?

I am a little confused about block usage in Objective-C. I currently use ARC and I have quite a lot of blocks in my app, currently always referring to `self` instead of its weak reference. May that be the cause of these blocks retaining `self` and keeping it from being dealloced ? The question is, should I always use a `weak` reference of `self` in a block ? 

    -(void)handleNewerData:(NSArray *)arr
    {
        ProcessOperation *operation =
        [[ProcessOperation alloc] initWithDataToProcess:arr
                                             completion:^(NSMutableArray *rows) {
            dispatch_async(dispatch_get_main_queue(), ^{
                [self updateFeed:arr rows:rows];
            });
        }];
        [dataProcessQueue addOperation:operation];
    }

**ProcessOperation.h**

    @interface ProcessOperation : NSOperation
    {
        NSMutableArray *dataArr;
        NSMutableArray *rowHeightsArr;
        void (^callback)(NSMutableArray *rows);
    }

**ProcessOperation.m**

    -(id)initWithDataToProcess:(NSArray *)data completion:(void (^)(NSMutableArray *rows))cb{
        
        if(self =[super init]){
            dataArr = [NSMutableArray arrayWithArray:data];
            rowHeightsArr = [NSMutableArray new];
            callback = cb;
        }
        return self;
    }

    - (void)main {
        @autoreleasepool {
            ...
            callback(rowHeightsArr);
        }
    }


Always pass weak reference of self into block in ARC?

I&#39;d like to store an array of weak references in Swift. The array itself should not be a weak reference - its elements should be. I think Cocoa `NSPointerArray` offers a non-typesafe version of this.

How do I declare an array of weak references in Swift?

I have read [this article](https://web.archive.org/web/20110303225354/http://weblogs.java.net/blog/2006/05/04/understanding-weak-references) about different types of references in Java (strong, soft, weak, phantom), but I don&#39;t really understand it.

What is the difference between these reference types, and when would each type be used?



Java: difference between strong/soft/weak/phantom reference

I have been a java developer for 2 years. 

But I have never wrote a WeakReference in my code. How to use WeakReference to make my application more efficient especially the Android application?

How to use WeakReference in Java and Android development?

The use of weak references is something that I&#39;ve never seen an implementation of so I&#39;m trying to figure out what the use case for them is and how the implementation would work. When have you needed to use a `WeakHashMap` or `WeakReference` and how was it used?

When would you use a WeakHashMap or a WeakReference?

Is there any way in JavaScript to create a &quot;weak reference&quot; to another object? [Here is the wiki page describing what a weak reference is.][1] [Here is another article that describes them in Java.][2] Can anyone think of a way to implement this behavior in JavaScript?


  [1]: http://en.wikipedia.org/wiki/Weak_reference
  [2]: https://community.oracle.com/blogs/enicholas/2006/05/04/understanding-weak-references

Is it possible to create a &quot;weak reference&quot; in JavaScript?

&gt; **Possible Duplicate:**  
&gt; [Weak references - how useful are they?](https://stackoverflow.com/questions/7136620/weak-references-how-useful-are-they)  

Since weak references can be claimed by the garbage collector at any time, is there any practical reason for using them?

Is there a practical use for weak references?

I often do this,

    let when = DispatchTime.now() + 2.0
    DispatchQueue.main.asyncAfter(deadline: when) {
       beep()
    }

and in one app we often do this

    tickle.fresh(){
    	msg in
    	paint()
    }

but if you do *this*

    let when = DispatchTime.now() + 2.0
    DispatchQueue.main.asyncAfter(deadline: when) {
       tickle.fresh(){
    	  msg in
    	  paint()
       }
    }

of course you have to do *this*

    let when = DispatchTime.now() + 2.0
    DispatchQueue.main.asyncAfter(deadline: when) { [weak self] _ in
       tickle.fresh(){
    	  msg in
    	  self?.paint()
       }
    }

or, maybe *this* 

    let when = DispatchTime.now() + 2.0
    DispatchQueue.main.asyncAfter(deadline: when) {
       tickle.fresh(){
    	  [weak self] msg in
    	  self?.paint()
       }
    }

*or maybe this*

    let when = DispatchTime.now() + 2.0
    DispatchQueue.main.asyncAfter(deadline: when) { [weak self] _ in
       tickle.fresh(){
    	  [weak self] msg in
    	  self?.paint()
       }
    }

#W T H should we do?

All three suggestions *seem* to work perfectly. What&#39;s the full depth of meaning here? And which should one do? Is a strong reference to a weak reference, a weak or strong reference? To be or not to be?  That&#39;s the question!

Where does the weak self go?

From [J. Bloch][1]

&gt; A ... source of memory leaks is
&gt; listeners
&gt; ... The best way to ensure that
&gt; callbacks are garbage collected
&gt; promptly is to store only weak
&gt; references to them, for instance, by
&gt; storing them only as keys in a
&gt; [WeakHashMap][2].

So, why there isn&#39;t any WeakSet in the Java [Collections framework][3]?


  [1]: http://www.informit.com/articles/article.aspx?p=1216151&amp;seqNum=6
  [2]: http://docs.oracle.com/javase/8/docs/api/java/util/WeakHashMap.html
  [3]: https://en.wikipedia.org/wiki/Java_collections_framework

Why does exist WeakHashMap, but absent WeakSet?

Can someone explain the difference between the three Reference classes (or post a link to a nice explanation)? `SoftReference` &gt; `WeakReference` &gt; `PhantomReference`, but when would I use each one? Why is there a `WeakHashMap` but no `SoftHashMap` or `PhantomHashMap`?

And if I use the following code...

    WeakReference&lt;String&gt; ref = new WeakReference&lt;String&gt;(&quot;Hello!&quot;);
    if (ref != null) {                 // ref can get collected at any time...
        System.gc();                   // Let&#39;s assume ref gets collected here.
        System.out.println(ref.get()); // Now what?!
    }

...what happens? Do I have to check if `ref` is null before every statement (this is wrong, but what _should_ I do)? Sorry for the rapid-fire questions, but I&#39;m having trouble understanding these `Reference` classes... Thanks!


Understanding Java&#39;s Reference classes: SoftReference, WeakReference, and PhantomReference

When I&#39;m declaring variables as `weak` in Swift, I sometimes get the error message from Xcode: 

&gt; &#39;weak&#39; may only be applied to class and class-bound protocol types

or

&gt; &#39;weak&#39; must not be applied to non-class-bound &#39;SomeProtocol&#39;; consider adding a protocol conformance that has a class bound

I&#39;m wondering why the keyword `weak` can only applied to class and class-bound protocol types? What is the reason behind this requirement?

Why can the keyword &quot;weak&quot; only be applied to class and class-bound protocol types

I&#39;m reading Xcode&#39;s documentation, and here is something that puzzles me:

    __block typeof(self) tmpSelf = self;
    [self methodThatTakesABlock:^ {
        [tmpSelf doSomething];
    }];

The following is copied from the documentation:

&gt; A block forms a strong reference to variables it captures. If you use
&gt; `self` within a block, the block forms a strong reference to `self`, so if
&gt; `self` also has a strong reference to the block (which it typically
&gt; does), a strong reference cycle results. To avoid the cycle, you need
&gt; to create a weak (or `__block`) reference to self outside the block, as
&gt; in the example above.

I don&#39;t understand what does &#39;a weak (or `__block`)&#39; mean?

Is

    __block typeof(self) tmpSelf = self;

and

    __weak typeof(self) tmpSelf = self;

exactly the same here？

I found another piece in the document:

&gt; Note: In a garbage-collected environment, if you apply both `__weak` and
&gt; `__block` modifiers to a variable, then the block will not ensure that it is kept alive.

So, I&#39;m totally puzzled.

What is the difference between a __weak and a __block reference?

Can someone explain the main benefits of different types of references in C#?

 -  Weak references
 -  Soft references
 -  Phantom references
 -  Strong references.

We have an application that is consuming a lot of memory and we are trying to determine if this is an area to focus on.

Weak reference benefits

What are the pros and cons of keeping listeners as WeakReferences?

The big &#39;Pro&#39; of course is that:

Adding a listener as a WeakReference means the listener doesn&#39;t need to bother &#39;removing&#39; itself.

For those worried about the listener having the only reference to the object, why can&#39;t there be 2 methods, addListener() and addWeakRefListener()? 

Those who don&#39;t care about removal can use the latter.

Pros and Cons of Listeners as WeakReferences

I understand how to use `weak_ptr` and `shared_ptr`. I understand how `shared_ptr` works, by counting the number of references in its object. How does `weak_ptr` work? I tried reading through the boost source code, and I&#39;m not familiar enough with boost to understand all the things it uses.

Thanks.

How does weak_ptr work?

Java&#39;s [WeakHashMap][1] is often cited as being useful for caching. It seems odd though that its weak references are defined in terms of the map&#39;s keys, not its values. I mean, it&#39;s the values I want to cache, and which I want to get garbage collected once no-one else besides the cache is strongly referencing them, no?

In which way does it help to hold weak references to the keys? If you do a `ExpensiveObject o = weakHashMap.get(&quot;some_key&quot;)`, then I want the cache to hold on to &#39;o&#39; until the caller doesn&#39;t hold the strong reference anymore, and I don&#39;t care at all about the string object &quot;some_key&quot;.

Am I missing something?


  [1]: http://developer.android.com/reference/java/util/WeakHashMap.html

Java&#39;s WeakHashMap and caching: Why is it referencing the keys, not the values?

I know there is a `WeakHashMap` in `java.util`, but since it uses `WeakReference`s for everything, which is only referenced by this `Map`, referenced objects will get lost on the next GC cycle. So it&#39;s nearly useless if you want to cache random data, which is very likely to be requested again without being Hard-linked the rest of the time. The best solution would be a map, which uses `SoftReference`s instead, but I didn&#39;t find one in the Java RT Package.

Is there a SoftHashMap in Java?

I have a question regarding this simple frequently occurring situation in android . 

We have a main activity , we invoke an AsyncTask alongwith the reference of the mainactivity , so that that the AsyncTask can update the views on the MainActivity.

 I will break down the event into steps

+ MainActivity creates an AyncTask , passes its reference to it .
+ AysncTask , starts it&#39;s work , downloading ten files for example
+ The user changed the orientation of the device. This results in an orphan pointer in the AsyncTask 
+ When the AsyncTask completes , and tries to access the activity to update the status , it crashes ,   because of the null pointer . 

The solution for the above is to keep a WeakReference in the AsyncTask as recommended by the book &quot;Pro Android 4&quot; 

    WeakReference&lt;Activity&gt; weakActivity;
    
    in method onPostExecute
    
    Activity activity = weakActivity.get();
    if (activity != null) {
       // do your stuff with activity here
    }

How does this resolve the situation ?

My question it , if my asynctask is downloading ten files , and upon completion of 5 the activity is restarted (because of an orientation change) then would my FileDownloadingTask be invoked once again ?. 

What would happen to the previous AsyncTask that was initially invoked ? 

Thank you  , and I apologize for the length of the question .  

WeakReference/AsyncTask pattern in android

I read a lot of posts about using `__weak self` inside `dispatch_async`, and now I am a litle bit confused.

if I have :

    self.myQueue = dispatch_queue_create(&quot;com.biview.core_data&quot;, NULL);

    dispatch_async(self.myQueue, ^(void){
        if (!self.var1) {
            self.var1 = ...;
        }
        dispatch_async(dispatch_get_main_queue(), ^(void) {
            if ([self.var2 superview]) {
                [self.var2 removeFromSuperview];
            }
            
            [self.Label setText:text];
        });
    });

do I need to use `__weak self`. Because I read that in some cases `dispatch_async`   not need a `__weak self`.

[See last comment here][1]


  [1]: https://stackoverflow.com/questions/8806193/when-and-why-would-i-want-to-declare-a-local-variable-as-weak-using-arc

All Weak References Solutions on Gang of Coders

Total of 21 Weak References Solutions

What's the difference between SoftReference and WeakReference in Java?