Let me try (and probably fail) to clarify a few basic concepts.

[It may be helpful to think of blank nodes as being like variables in  algebra.  A homework assignment might have several questions:

One might ask for the value of x when x-3=0.
Another might ask for the value when x-1=2.
A third might ask for the value when x-5=0.

In the first two cases, the value happens to be the same; in the third it happens to be different. Each equation would have the same solutions if you renamed the variables to i, j, and k.]

1. Within the context of a *single* reading of a *single* RDF document, a blank node x ("_:x") always refers to the same thing. 

  This is why you can assert multiple property values about the thing referred to by "_:x" , and use "_:x" as a property value,  knowing that each of these uses will be referring to the same thing.

2. If you read the same RDF document twice, the thing referred to by "_:x" the first time *might* not be the same thing referred to by "_:x" in the second reading.  

3. Because you can have multiple names for the same thing they may not always be different, but without additional information you can't assume one way or the other.

For example, you might have an OWL axiom that says that a concept in a thesaurus can only have a single preferred label, and you see two statements about the same concept that use different names for the preferred label, you can infer that the two names must refer to the same thing, even if the name of the label is a blank node- e.g. :

Given the OWL axiom  FunctionalObjectProperty(:prefLabel),
reading the statements below twice will make the potentially different things that the blank node in each reading might refer to in fact be the same.

_:x :literalForm "Weasels--Homes and Haunts"@en.
ex:weaselHH :prefLabel _:x.

If we didn't have the OWL axiom, ex:weaselHH might have two different values for :prefLabel.

4. There is no problem with a SPARQL  query binding a variable to a blank node; however it can be difficult to use the value in second query.

5. It can be difficult to use SPARQL to update an entity that is identified by a blank node.  It is necessary to construct a WHERE clause that will bind the blank node naming the entity to be modified to some variable.  This may be awkward if it hard to uniquely select the blank named entity.

6. It is not possible to make additional assertions about a blank node named entity using only RDF.
It is usually possible to do so using OWL,  though the process may be very awkward.

7. There are several features in OWL that only work for named individuals. The most obvious example are HasKey axioms, which let you define a set properties that work like a primary key for instances of a particular class- if all of the key properties associated with two names are identical, the two names refer to the same entity.

8. If you use blank nodes with linked data you're gonna have a bad time.