相关疑难解决方法(0)

Java教程说:"同一个对象上的两个同步方法的调用不可能交错."

这对静态方法意味着什么？由于静态方法没有关联对象,所以synchronized关键字会锁定类,而不是对象吗？

我已经知道每个类字节码都被加载到内存中一次为每个类加载器,因此当一个线程正在执行某个方法的字节代码,而另一个线程出现？

1个线程 - > 1个实例 - 类 Foo ==没问题.

X个线程 - > 1个实例 - 类 Foo ==需要处理这个很清楚.

X个线程 - > X各个实例 - 类 Foo == ????

我应该确保方法中没有搞砸了吗？如果该方法使用实例级变量,我可以确定它将使用正确的变量吗？

更新:

我看到我的问题并不清楚,这是一个数字的例子

我有一个类型为Foo的对象没有同步!!

我有5个Foo实例,其中每个都运行5个线程,并访问实例级参数,例如:

class FOO {
     private SomeObject someObject=new SomeObject();

     private void problematicMethod(Data data) {
         someObject.doSomethingWithTheData(data);
         data.doSomethingWithSomeObject(someObject); 
// any way you want it use the data or export the data
     }
}

我问这里有问题,因为这个类只有1个字节的代码,这个对象的5个实例访问这个字节代码,所以如果我想防止它们在同一个字节代码上重叠,我该怎么办？做？

谢谢,亚当.

可能重复:
同步静态方法如何在Java中工作？

我想知道如果在静态方法上使用synchronized会发生什么.该类是否锁定该方法？这与非静态方法的同步有何不同？

谢谢

我有20个线程用println()函数写入一个名为results.txt的文件.我怎样才能同步它们？

我注意到每次运行程序时,我在results.txt中都有不同数量的文本行.

谢谢.

我一直在研究 Java 多线程概念。我越经历它们，我就越困惑。

现在我不明白Java中类级别、对象级别、显式锁定和内在锁定之间的区别。有人可以告诉我哪个是什么吗？另外，如果我能举一些例子来理解，那对我来说也会很有帮助。

可能重复:
同步静态方法如何在Java中工作？

有人能让我理解以下两个功能之间的根本区别:

public static void synchronized f() {… } 

和

public void synchronized f() {… }

我有一个这样的课:

public class Utils {

    public static void doSomething() {
        // doSomething code
    }

    public static void doSomethingElse() {
        // doSomethingElse code
    }
}

我希望两个方法同步但不能彼此同步,即没有两个线程可以同时处理doSomething()方法,没有两个线程可以同时处理doSomethingElse()但是线程可以处理doSomething()方法和另一个方法同时处理doSomethingElse()方法.

我实现了这样的事情:

public class Utils {

    private static final String DO_SOMETHING_LOCK = "DO_SOMETHING_LOCK";
    private static final String DO_SOMETHING_ELSE_LOCK = "DO_SOMETHING_ELSE_LOCK";

    public static void doSomething() {
        synchronized(DO_SOMETHING_LOCK) {
            // doSomething code
        }
    }

    public static void doSomethingElse() {
        synchronized(DO_SOMETHING_ELSE_LOCK) {
        // doSomethingElse code
    }
}

我看到Scott Stanchfield的回应在这里采用了类似的方法:

同步静态方法如何在Java中工作？

但这是最好的方法吗？对我来说似乎有些笨拙,创造了两个对象,只是用于锁定 - 有更好的方法吗？

我正在阅读最初来自(我相信)IBM developerworks站点的线程教程.在其中,他们讨论了synchronized关键字以及同步代码块如何被实际对象锁定,而不是代码块本身.

例如,在下面的代码中,作者声明即使静态类Thingie的setLastAccess方法被列为同步,下面定义的两个线程也可以setLastAccess同时调用,因为它们使用的是不同的值.但是,如果thingie是静态的,那不就意味着它们使用相同的值吗？

是否只是变量名称需要不同,即使它们指的是同一个对象？

public class SyncExample {
    public static class Thingie {
        private Date lastAccess;
        public synchronized void setLastAccess(Date date) {
            this.lastAccess = date;
        }
    }
    public static class MyThread extends Thread {
        private Thingie thingie;
        public MyThread(Thingie thingie) {
            this.thingie = thingie;
        }
        public void run() {
            thingie.setLastAccess(new Date());
        }
    }
    public static void main() {
        Thingie thingie1 = new Thingie(),
        thingie2 = new Thingie();
        new MyThread(thingie1).start();
        new MyThread(thingie2).start();
    }
} 

如果A类有两个同步方法,比如methodA和methodB.如果一个线程正在访问methodA,另一个线程可以访问methodB吗？根据我的理解,当访问methodA时,线程获取对象的锁定,其他线程不应该同时访问methodB.但这会使性能降级很多,对吧？而且,我似乎习惯于阅读一篇文章说其他线程可以访问methodB.哪一个是正确的？

根据我在Java类中的知识

1. 非静态同步方法:锁定特定对象的获取
2. 静态同步方法:锁定类上的获取

我对此有点困惑,因为我们可以通过类名或对象名来调用静态方法.

请假设有4种方法,我的班级都是同步的.2个方法是静态的,2个是非静态的.如果我将创建我的类"obj1"的1个对象,并且还有2个线程Thread1和Thread2

问题1:如果我将尝试使用obj1(或类名)访问静态同步方法.这是否意味着"obj1"没有锁定只会锁定2个静态方法(类级别锁定)？意味着其他线程可以同时使用"obj1"访问非静态方法但不能访问静态方法吗？

问题2:如果我将尝试使用Thread1中的obj1 来访问非静态同步方法.这是否意味着Thread2只锁定了2个方法？表示Thread2可以访问2个静态方法,或者我们可以同时使用className(MyClass)访问静态方法

问题3:如果我班级中的所有方法都是静态的并且是同步的.这是否意味着没有对象级别锁定,并且所有线程只有一个类级别锁定.？

请解释一下关于班级锁定的一点点

提前致谢.

我有一个计数器和多个线程访问该getCount方法.代码如下:

public class ThreadSafeMethod {

        public static int counter = 0;

        public static int getCount() {
            return counter++;
        }
    }

方法线程安全吗？我的理解是,因为counter++不是自动的,所以不安全.那怎么安全呢？如果我们添加synchronized关键字,将同步哪个对象？