小编du3*_*369的帖子

生成器只是一个函数,它返回一个可以在其上调用的对象,这样每次调用它都会返回一些值,直到它引发一个StopIteration异常,表示已生成所有值.这样的对象称为迭代器.

>>> def myGen(n):
...     yield n
...     yield n + 1
... 
>>> g = myGen(6)

我从Python中理解生成器中引用了这个？

这是我想弄清楚的:

1. 哪个是发电机？myGen还是myGen(6)？

   根据上面提到的报价,我认为发电机应该是myGen.并且myGen(6)是返回的迭代器对象.但我真的不确定.

2. 当我尝试这个时:

   >>> type(myGen)
   <type 'function'>
   >>> type(g)         # <1>this is confusing me.
   <type 'generator'>  
   >>> callable(g)     # <2> g is not callable.  
   False               
   >>> callable(myGen)
   True
   >>> g is iter(g)    # <3> so g should an iterable and an iterator 
   True                # at the same time. And it …

   Run Code Online (Sandbox Code Playgroud)

我知道重载使用静态绑定和覆盖使用动态绑定.但如果他们混在一起呢？根据本教程,要解析方法调用,静态绑定使用类型信息,而动态绑定使用实际的Object信息.

那么,在以下示例中是否发生了静态绑定以确定sort()要调用的方法？

public class TestStaticAndDynamicBinding {

    @SuppressWarnings("rawtypes")
    public static void main(String[] args) {
        Parent p = new Child();
        Collection c = new HashSet();

        p.sort(c);
    }
}

.

public class Parent {

    public void sort(Collection c) {
        System.out.println("Parent#sort(Collection c) is invoked");
    }

    public void sort(HashSet c) {
        System.out.println("Parent#sort(HashSet c) is invoked");
    }
}

.

public class Child extends Parent {

    public void sort(Collection c) {
        System.out.println("Child#sort(Collection c) is invoked");
    }

    public void sort(HashSet c) {
        System.out.println("Child#sort(HashSet c) …

我对这两个概念有点困惑.

在wiki上无锁的定义:

如果保证系统范围的进度,则非阻塞算法是无锁的

非阻塞的定义:

如果任何线程的故障或暂停不会导致另一个线程的失败或暂停,则算法称为非阻塞

我以为spinlock是无锁的,或者至少是非阻塞的.但现在我不确定.因为根据定义,"spinlock is not lock-free"对我来说也很有意义.比如,如果持有自旋锁的线程被挂起,那么它将导致其他线程在外面旋转.因此,根据定义,spinlock甚至不是非阻塞,更不用说无锁.

我现在很困惑.谁能清楚解释一下吗？

使用 Eclipse 进行调试时，有没有办法检查特定表达式的值？表达式视图并不总是那么有用。

例如：

public class P 
{
    public boolean executed = false;

    public String getSomeString() {
        if (!executed) {
            executed = true; //set executed to true,so calling this method again will not yield the same result
            return "someStr";
        }else {
            throw new RuntimeException();
        }
    }
}

下面是主要方法：

public class Test {
    public static void main(String[] args) {
        P p = new P();
        p.getSomeString(); //breakpoint here, I want to check the value of this expression, but it is not assign …

这是来自JCiP的示例。

public class Unsafe {
    // Unsafe publication 
    public Holder holder;

    public void initialize() {
        holder = new Holder(42);
    }
}

public class Holder {
    private int n;

    public Holder(int n) {
        this.n = n;
    }
    public void assertSanity() {
        if (n != n) {
            throw new AssertionError("This statement is false.");
        }
    }
}

在第34页上：

[15]这里的问题不是Holder类本身，而是Holder没有正确发布。但是，可以通过将n字段声明为final来使Holder免受不适当发布的影响，这将使Holder不变。

从这个答案：

final的规范（请参阅@andersoj的答案）保证当构造函数返回时，将对final字段进行适当的初始化（从所有线程可见）。

从维基：

例如，在Java中，如果已经内联了对构造函数的调用，则一旦分配了存储空间，但是在内联的构造函数初始化对象之前，可以立即更新共享变量。

我的问题是：

因为：（可能不正确，我不知道。）

a）可以在内联构造函数初始化对象之前立即更新共享变量。

b）只有在构造函数返回时，才能保证对final字段进行正确的初始化（从所有线程可见）。

另一个线程是否可能看到默认值holder.n？（即，另一个线程holder在holder构造函数返回之前获得对它的引用。）

如果是这样，那么您如何解释以下声明？

通过将n字段声明为final，可以使Holder免受不适当发布的影响，这将使Holder不可变

编辑： …

我写了这样的东西:

#define Parent C*
class C{
public:
    Parent parent;
    C():parent(NULL){}
};
void fun(Parent &p){
    //condition..return;
    fun(p->parent);
}

当我试图使引用参数保持不变以避免对引用对象的任何意外更改时,发生了某些事情.

第一:

我说constbefor Parent,像这样:void fun(const Parent &p).但它不能在这一行编译fun(p->parent);.错误信息是:

无效的参数'候选者是:void fun(const C*&)'

然后:

我改变了这样的立场const:void fun(Parent const &p)突然之间,问题就消失了.为什么？？？有什么不同？