java多线程synchronized 会锁定什么

对于自定义UnSafeThread类

Public static int count;

    静态同步方法：锁定当前类对象
    A：Public synchronized static void increment(){

//轮流执行
//锁的是UnsafeThread类对象
//进入方法会锁SynchronizedDemo.class指向对象中的锁；出方法会释放
//SynchronizedDemo.class指向的对象中的锁
count++;
}

    B: Public static void increment( ) {

synchronized(UnSafeThread.class){
//锁的是UnSafeThread类对象
count++;
}
}

    同步实例方法：锁定当前对象this
    C: Public synchronized void increment2(){
    count++;
    }

    D: Public void increment3(){

synchronized(this){
count++;
}
}

    同步代码块：锁定o对象
    E：Object o = new Object();

synchronized(o){//对o对象锁定
count++;
}

    锁定的对象的所有同步的地方，都会同步互斥
    只有锁定的对象是同一个时才会同步互斥
    A A 互斥
    A B 互斥
    A C 不互斥
    A D 不互斥
    A E 不互斥

    Synchronized 解决线程不安全（原子性，可见性，代码重排序）

```java

public class UnSafeThread {
    public static int count;

    public static void main(String[] args) throws InterruptedException {
        Object o = new Object();
        for (int i = 0; i < 20; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    for (int j = 0; j < 10000; j++) {
                        //count++;
                        increment();  //静态类对象锁定
//                        synchronized (o){   //对o对象锁定
//                            count++;
//                        }
                        decrement();
                    }
                }
            }).start();
        }
        while (Thread.activeCount()>2) {
            Thread.yield();
        }
        System.out.println(count);
        // 结果不是20 0000


//        List<Integer> list = new ArrayList<>();
//        for (int i = 0; i < 20; i++) {
//            final int k = i;
//            new Thread(new Runnable() {
//                //内部匿名类不能使用栈里的元素i
//                @Override
//                public void run() {
//                      for (int j = 0; j < 10000; j++) {
//                          list.add(k * 10000 + j);
//                     }
//                }
//            }).start();
//        }
//        while (Thread.activeCount()>2) {
//            Thread.yield();
//        }
        // 会抛出数组越界异常ArrayIndexOutOfBoundsException
//        System.out.println(list.size());
    }
    public synchronized static void increment() {
        //轮流执行
        //锁的是UnsafeThread类对象
        //进入方法会锁 SynchronizedDemo.class 指向对象中的锁；出方法会释放SynchronizedDemo.class 指向的对象中的锁
        count++;
    }
//    public static void increment() {
//        synchronized (UnSafeThread.class) {
//            //锁的是UnSafeThread类的对象
//            count++;
//        }
//    }
    public synchronized static void decrement() {
        count--;
    }
    public synchronized void increment2() {
        count++;
    }
    public void increment3() {
        synchronized (this) {
            count++;
        }
    }
}