线程中的synchronized(this)的一些疑惑

//synchronized(this)表示锁这个类，那么为什么其他线程还能执行类中的非同步方法呢？


package ThreadS;

public class Cc {
    public static void main(String[] args) {
        MyClass mc = new MyClass();
        MyThread1 my1 = new MyThread1(mc);
        MyThread1 my2 = new MyThread1(mc);

        new Thread(my1, "my1").start();
        new Thread(my2, "my2").start();

    }
}

class MyThread1 implements Runnable {
    private MyClass mc;

    public MyThread1(MyClass mc) {
        this.mc = mc;
    }

    @Override
    public void run() {
        if (Thread.currentThread().getName().equals("my1")) {
            mc.daSome();
        }
        if (Thread.currentThread().getName().equals("my2")) {
            mc.doOther();
        }


    }
}

class MyClass {
    public void daSome() {
        synchronized (this) {
            System.out.println("soSome begin");
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("soSome over");
        }
    }

    public void doOther() {
        System.out.println("doThter begin");
        System.out.println("doThter over");
    }

}

//为什么doOthe()能执行呢?,这个类不是被锁了吗

```************

搞混类和实例的区别了吧。锁的是具体的某个实例对象，不是某个方法。

synchronized(this)不是表示锁这个类，而是以这个对象的实例当做一把锁来使用，synchronized语句块确保同一时刻只能有一个人能执行，就是排他性。

类是创建实例的模板，而实例则是一个一个具体的对象，各个实例拥有的数据都互相独立，互不影响；

方法就是与实例绑定的函数，和普通函数不同，方法可以直接访问实例的数据；

通过在实例上调用方法，我们就直接操作了对象内部的数据，但无需知道方法内部的实现细节。

和静态语言不同，Python允许对实例变量绑定任何数据，也就是说，对于两个实例变量，虽然它们都是同一个类的不同实例，但拥有的变量名称都可能不同

首先你这边的this锁的是相同的对象，不是类，还有，锁锁的是对象，不是方法，如果doOther也跟some一样加synchronized，就不会执行