相关疑难解决方法(0)

Java中的a HashMap和a有什么区别Hashtable？

哪个非线程应用程序更有效？

"对象序列化"是什么意思？你能用一些例子解释一下吗？

我试图理解Java堆术语中年轻,老一代和永久世代的概念,更具体地说是三代之间的相互作用.

我的问题是:

• 什么是年轻一代？
• 什么是老一代？
• 什么是永久世代？
• 三代人如何相互作用/相互联系？

说这static意味着所有对象的值的volatile一个副本并且意味着所有线程的值的一个副本是否正确？

无论如何,static变量值也将成为所有线程的一个值,那么我们为什么要这样做volatile呢？

我阅读了一些关于该volatile关键字的文章,但我无法弄清楚它的正确用法.你能告诉我在C#和Java中它应该用什么吗？

目前我无法理解何时应该使用volatile声明变量.

我已经做了一些研究并且长时间搜索了一些关于它的材料并且知道当一个字段被声明为volatile时,编译器和运行时会注意到这个变量是共享的,并且它上面的操作不应该与其他内存重新排序操作.

但是,我仍然无法理解在什么情况下我们应该使用它.我的意思是,有人可以提供任何示例代码,可以证明使用"volatile"带来的好处或解决问题与不使用它相比？

我需要一个volatile在java 中使用关键字的简单示例,由于不使用而表现不一致volatile.

挥发性使用的理论部分对我来说已经很清楚了.

我有一个帖子:

class Foo extends Thread
{
    boolean active = true;

    public void run()
    {
        while(active)
        {
            //do stuff
        }
    }

    public void end()
    {
        active = false;
    }

    public void hibernate()
    {
        synchronized(this)
        {
            wait();
        }
    }
 }

如果另一个线程调用end(),会Foo立即看到active现在是false什么？具体来说,因为active不是volatile,我不确定它会不会.我最初创建的end()是一种避免易变的聪明方法,但现在我不确定它实际上会做我想做的事情.另外,如果另一个线程调用hibernate(),哪个线程将进入休眠状态？我打算Foo睡觉,所以如果这不符合我的意图,那么另一个建议将非常受欢迎.

我正在尝试合并两个已排序的链表.

代码段不适用于以下两个列表:

List 1 : 1->3->5->7->9->null
List 2 : 2->4->6->8->10->null

Expected List : 1->2->3->4->5->6->7->8->9->10->null

但是以下程序的输出结果是这样的:

Output :  1->2->3->4->5->6->7->8->9->null // element 10 is missing.

我错过了什么吗？现场演示:http://ideone.com/O7MBlo

class Node {

    Node next;
    int value;

    Node(int val) {
        this.value = val;
        this.next = null;
    }

    @Override
    public String toString() {
        Node cur = this;
        String str = "";

        while(cur != null) {
            str += cur.value+"->";
            cur = cur.next;
        }

        return str;
    }
}

class MergeLL {

    public static Node merge(Node n1, …

来自Javadocs

使用volatile变量可降低内存一致性错误的风险,因为对volatile变量的任何写入都会建立与之后读取同一变量的先发生关系.这意味着对volatile变量的更改始终对其他线程可见.

当对volatile变量的更改始终对任何其他线程可见时,为什么在多个线程写入该变量的情况下不能使用volatile变量.为什么volatile只用于一个线程正在写入或读取的情况,而另一个线程只读取变量？

如果其他线程始终可以看到更改,则假设线程B想要写入该变量,它将看到新值(由线程A更新)并更新它.当线程A再次想要写入时,它将再次通过线程B看到更新的值并写入它.问题出在哪里？

简而言之,我无法理解这一点.

如果两个线程都在读取和写入共享变量,那么使用volatile关键字是不够的.在这种情况下,您需要使用同步来保证变量的读取和写入是原子的.

我试图理解volatile变量的工作.我创建了一个简单的类"A",它扩展了"Thread"并具有一个volatile变量"i".还有另一个类"Amain"运行3个"A"类线程.我在A的run()中运行一个循环,它取决于这个volatile变量.这里的代码.

// Thread

public class A extends Thread {

    public volatile int i = 0;

    @Override
    public void run() {

        while(i<10)
            System.out.println(i++ + "  " + this.getName());
    }
}

// Main Class

public class Amain {

    public static void main(String[] args) {

        A t1 = new A();
        A t2 = new A();
        A t3 = new A();

        t1.start();
        t2.start();
        t3.start();
    }

}

如果在所有线程之间共享易失性值,那么"i"应该被打印10次.相反,它为每个线程打印10个值,即总共30个值.需要在此代码的上下文中理解volatile的工作.另外,我还可以从任意数量的线程中获取i的10个值(在此代码的上下文中).