在多线程中同步

Question

当我尝试通过启动不同的线程来执行所有同步方法时，我在一个类中有三个同步方法，我看不到同步的输出，在对象上没有获得锁

公共类DisplayMessage{

public static synchronized void sayHello(String name) throws InterruptedException{
    for(int i=1; i<=10;i++){
        Thread.sleep(1000);
        System.out.println("How are you"+name);
    }
}
public synchronized void sayHello1(String name2,int j){
    for(int i=1; i<=10;i++){
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        System.out.println("How are you Hello1  :: "+name2+ " Age " + j);
    }
}
public synchronized void sayHello2(String name3,String lastname){
    for(int i=1; i<=10;i++){
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        System.out.println("How are you Hello 2 :: "+ name3 + " lastname " +lastname);
    }
}

}线程类：

公共类 MyThread 扩展了线程 {

String name;


MyThread(String name) {

    this.name = name;
}

public void run() {

    try {
        DisplayMessage.sayHello(name);
    } catch (InterruptedException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }

}

}Thread2类：公共类MyThread2扩展线程{

String name2;
String name3;

int age;
DisplayMessage dm;

MyThread2(DisplayMessage dm, String name2, int age) {
    this.dm = dm;
    this.name2 = name2;
    this.age = age;
}

public void run() {

    dm.sayHello1(name2, age);

}

} 线程 3 类：

包装Synchronization.classlock；

公共类MyThread3扩展线程{

String name3;
String lastname;
int age;

DisplayMessage dm2;

MyThread3(DisplayMessage dm, String name3, String lastname) {
    this.dm2 = dm;
    this.name3 = name3;
    this.lastname = lastname;
}

public void run() {

    dm2.sayHello2(name3, lastname);
}

}

使用main方法生成不同线程的Democlass公共类SynchronizationDemo{

public static void main(String[] args) {
    DisplayMessage dm=new DisplayMessage();
    MyThread t1= new MyThread("steve");
    MyThread t2=new MyThread("Anitha");
    MyThread2 t3=new MyThread2(dm," Amit", 31);
    MyThread3 t4=new MyThread3(dm," Arit ","urkude");
    t1.start();
    t2.start();
    t3.start();
    t4.start();

}

}

以下是输出结果:

你好你好我31岁你好我31岁你好你好我31岁你好你好你好我31岁你好你好你好我31岁你好你好你好我31岁你好你好你好我31岁你好你好你好 你好吗你好吗你好吗你好吗你好吗你好吗你好吗你好吗你好吗你好吗你好吗你好吗你好阿里特姓乌尔库德你好你好你好阿里特姓乌尔库德你好你好你好你好你好你好你好阿里特姓乌尔库德你好你好你好你好 你好你好你好你好阿里特你好你好你好你好你好你好阿里特你好你好你好你好你好你好你好阿里特你好你好你好你好你好你好你好你好你好你好你好你好你好你好你好你好你好你好你好你好

Answer 1

添加到静态方法的synchronized关键字是到当前的*。对应于类锁的java文件；而synchronized关键字添加到非静态方法中就是给这个对象加锁。虽然这两种锁是不同的，但是这种对象锁和类锁是可以互相重入的。

Answer 2

根据您的代码，您看到的输出完全有效MyThread正在使用DisplayMessage。sayHello（）方法，它是静态，因此在DisplayMessage上同步。class＜/code＞对象。在static方法上使用synchronized关键字相当于：

public static void sayHello(String name) throws InterruptedException{
    synchronized(DisplayMessage.class) {
        for(int i=1; i<=10;i++){
            Thread.sleep(1000);
            System.out.println("How are you"+name);
        }
    }
}

另一方面，另外两个线程，< code>MyThread2和< code>MyThread3正在调用非静态方法- sayHello1和< code>sayHello2，它们在< code>this上同步。在这种情况下，使用< code>synchronized关键字相当于:

public void sayHello1(String name2,int j){
    synchronized(DisplayMessage.this) {
        for(int i=1; i<=10;i++){
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            System.out.println("How are you Hello1  :: "+name2+ " Age " + j);
        }
    }
}

因此，您的输出包含 Steve 和 Amit 同时运行，然后是 Anitha和 Arit 并发运行，这是预期的，因为代码在两个不同的对象上同步。