java线程同步问题

想发布一些关于线程同步的疑问。我理解了这个概念 同步。但是，当我通过多线程实现一个示例java程序时，我无法实现我想要的结果。但是最后我可以通过修改一行代码来实现这个结果。但是我想知道下面的代码有什么问题

在这里，当我使用synchronized block、synchnized（SharedResource.class）时，我可以得到我想要的结果。 为什么它不适用于synchonized method和synchronized（this）块

公共类SharedResource{
公共同步的无效访问（字符串名称）{
System.out.println（name+“：访问的共享资源”）；
System.out.println（name+“正在做他的工作：”）；
对于（int i=0；i<5；i++）{
试一试{
System.out.println（name+“：”+i）；
睡眠（500）；
}捕获（中断异常e）{
e、 printStackTrace（）；
}
}
System.out.println（name+“：完成了他的工作…”）；
}
}
公共类SharedAccessThread实现可运行{
私有字符串名称；
公共SharedAccessThread（字符串名称）{
this.name=名称；
}
@凌驾
公开募捐{
SharedResource资源=新的SharedResource（）；
resource.access（Thread.currentThread（）.getName（））；
}
}
公共类多线程{
公共静态void main（字符串[]args）{
SharedAccessThread线程=新的SharedAccessThread（thread.currentThread（）.getName（））；
螺纹t1=新螺纹（螺纹）；
t1.设定名称（“A”）；
螺纹t2=新螺纹（螺纹）；
t2.设定名称（“b”）；
螺纹t3=新螺纹（螺纹）；
t3.设定名称（“C”）；
t1.start（）；
t2.start（）；
t3.start（）；
}
}
预计产量如下：
答：访问共享资源
A做他的工作：
A:0
A:1
A:2
A:3
A:4
完成了他的工作。。
C：访问共享资源
C.做他的工作：
C:0
C:1
C:2
C:3
C:4
C:完成了他的工作。。
b:访问共享资源
b做他的工作：
b:0
b:1
b:2
b:3
b:4
完成了他的工作。。

---

但它以一种混乱的方式给出了答案。这意味着一个被访问的共享资源..B正在做他的工作..等等，这是我不想要的。

您的代码不需要同步。同步在以下位置很重要：

全局成员和任何线程更改其值

，但在您的示例中不要进行任何互斥。 在java中，任何线程都有自己的

线程上下文

由

局部变量

、

输入参数

等组成。

---

在您的代码中，任何线程都有一个

SharedResource

实例并调用它的

access

方法，因此不要担心

线程安全问题。
您的代码不需要同步。同步在以下位置很重要：
全局成员和任何线程更改其值
，但在您的示例中不要进行任何互斥。
在java中，任何线程都有自己的
线程上下文
由
局部变量
、
输入参数
等组成。
在您的代码中，任何线程都有一个
SharedResource
实例，并调用它的
access
方法，因此不要担心
线程安全问题。
问题是您正在每个线程内创建一个
新的SharedResource
：

@Override
public void run() {
    SharedResource resource = new SharedResource();
    resource.access(Thread.currentThread().getName());

}

因此，在
这个
上同步或在方法本身上同步（这与在
这个
上同步相同）会导致每个线程看到不同的锁，因此没有效果

在类本身上进行同步之所以有效，是因为它起到全局锁的作用，因为类本身对于所有线程都是相同的

要能够在此
上进行同步，您应该将资源设置为静态成员，例如：

public class SharedAccessThread implements Runnable {

    private String name;
    private static SharedResource resource = new SharedResource();

    public SharedAccessThread(String name) {
            this.name = name ;
    }
    @Override
    public void run() {          
        resource.access(Thread.currentThread().getName());   
    }    
}

这保证您的所有线程都能看到相同的
SharedResource
实例。问题是您正在每个线程内创建一个
新的SharedResource
：

@Override
public void run() {
    SharedResource resource = new SharedResource();
    resource.access(Thread.currentThread().getName());

}

因此，在
这个
上同步或在方法本身上同步（这与在
这个
上同步相同）会导致每个线程看到不同的锁，因此没有效果

在类本身上进行同步之所以有效，是因为它起到全局锁的作用，因为类本身对于所有线程都是相同的

要能够在此

上进行同步，您应该将资源设置为静态成员，例如：

public class SharedAccessThread implements Runnable {

    private String name;
    private static SharedResource resource = new SharedResource();

    public SharedAccessThread(String name) {
            this.name = name ;
    }
    @Override
    public void run() {          
        resource.access(Thread.currentThread().getName());   
    }    
}

---

这保证了您的所有线程都能看到相同的

SharedResource

实例，您会说：“在这里，当我使用synchronized块时，synchronized（SharedResource.class）可以实现我想要的结果。为什么它不适用于synchronized方法和synchronized（This）块？”请说出预期结果是什么？描述您的预期结果以及您在该代码中看到的“问题”，您可以说：“在这里，当我使用synchronized块、synchronized（SharedResource.class）时，我可以实现我想要的结果。为什么它不适用于synchronized方法和synchronized（this）块？”请说出预期结果是什么？描述您的预期结果以及您在代码中看到的“问题”