synchronized_修饰的锁

/**
 * DateTime 2020/11/25 21:14
 *
 * @author db
 **/
public class Concurrency {
    public static void main(String[] args) {
        /*
            锁：
            1、类锁：仅有一把锁，无论有多少实例，全部都是同步的。
            2、对象锁：每个对象实例各自有一把锁，不同实例之间是异步的，同实例才是同步的
            3、方法锁：每个实例各自有一把锁，不同方法之间共用一把锁；修饰静态方法就变为类锁了，不同实例之间共用一把锁。
            4、代码块锁：所得依然是实例或类
            注意：类锁和对象锁不是一把锁。
         */
        
        lockCode();//修饰代码块
        lockMethod();//每个方法加锁，单独调的时候不会有并发问题，如果混合调用的话会出现并发问题（原因是外层的代码块没有加锁）。
        deadLock();//两个对象锁互相等待
    }

    private static void lockCode() {
        //synchronized 修饰代码块的3种形式
        
        //1、成员锁： synchronized (成员对象)
        //锁的是成员对象，同一对象是同步的，不同对象是异步的
        lockMember();
        
        //2、实例对象锁：synchronized (this) 
        //锁的是本对象实例，同一对象是同步的，不同对象是异步的
        lockThis();
        
        //3、当前类的class对象锁： synchronized (*.class)
        //锁的是类，无论操作几个对象，都是同步的
        lockThisClass();
        
    }

    private static void lockMethod() {
        //synchronized 修饰方法的2种形式
        
        //1、修饰普通方法：synchronized methodName(){}
        //锁的是对象实例方法，同一对象是同步的，不同对象是异步的
        lockGeneralMethod();
        
        //2、修饰静态方法：synchronized static methodName(){}
        //锁的是类方法，无论多少个实例对象，都是同步的
        lockStaticMethod();
        
        //多普通方法加锁，混合调用
        //锁的是实例，同一对象是同步的
        lockMoreMethod();
        
        //类锁和对象锁同时调用
        //因为不是同一把锁，所以是异步的
        lockGeneralAndStatic();
    }

    private static void deadLock() {
        ObjA a = new ObjA();
        ObjC c = new ObjC();
        
        Thread threadE = new Thread(()->{
            String name = Thread.currentThread().getName();
            synchronized (a){
                a.run(name + "，锁住了");
                synchronized (c){
                    c.run(name + "执行了");
                }
            }
        }, "threadE");
        Thread threadF = new Thread(()->{
            String name = Thread.currentThread().getName();
            synchronized (c){
                c.run(name + "，锁住了");
                synchronized (a){
                    a.run(name + "执行了");
                }
            }
        }, "threadF");
        
        threadE.start();
        threadF.start();
    }

    private static void lockMember() {
        ObjC d = new ObjC();
        Thread threadE = new Thread(()->{
            synchronized (d){
                d.lockMember();
            }
        }, "threadE");
        Thread threadF = new Thread(()->{
            synchronized (d){
                d.lockMember();
            }
        }, "threadF");

        threadE.start();
        threadF.start();
    }

    private static void lockThis() {
        ObjC d = new ObjC();
        Thread threadE = new Thread(d::lockObj, "threadE");
        Thread threadF = new Thread(d::lockObj, "threadF");

        threadE.start();
        threadF.start();
    }

    private static void lockThisClass() {
        ObjC d = new ObjC();
        Thread threadE = new Thread(d::lockThisClass, "threadE");
        Thread threadF = new Thread(d::lockThisClass, "threadF");

        ObjC a = new ObjC();
        Thread threadA = new Thread(a::lockThisClass, "threadA");
        Thread threadB = new Thread(a::lockThisClass, "threadB");

        threadA.start();
        threadB.start();
        threadE.start();
        threadF.start();
    }

    private static void lockGeneralMethod() {
        ObjC d = new ObjC();
        Thread threadE = new Thread(d::lockMethod, "threadE");
        Thread threadF = new Thread(d::lockMethod, "threadF");

        threadE.start();
        threadF.start();
    }

    private static void lockStaticMethod() {
        Thread threadE = new Thread(ObjC::lockStaticMethod, "threadE");
        Thread threadF = new Thread(ObjC::lockStaticMethod, "threadF");

        threadE.start();
        threadF.start();
    }

    private static void lockMoreMethod() {
        ObjC d = new ObjC();
        Thread threadE = new Thread(d::lockMoreMethod1, "threadE");
        Thread threadF = new Thread(d::lockMoreMethod2, "threadF");
        Thread threadA = new Thread(d::lockMoreMethod3, "threadA");

        threadA.start();
        threadE.start();
        threadF.start();
    }

    private static void lockGeneralAndStatic() {
        ObjC d = new ObjC();
        Thread threadE = new Thread(d::lockMethod, "threadE");
        Thread threadF = new Thread(ObjC::lockStaticMethod, "threadF");
        
        threadE.start();
        threadF.start();
    }


    
}

class ObjA{
    public int val;
    public ObjA(){}
    public void run(String thread){
        System.out.println(thread+":"+",ObjA");
    }
    
    public synchronized void addValue(){
        val++;
    }
    public synchronized void subValue(){
        val--;
    }
}

class ObjC{
    public static int val;
    public ObjC(){}
    public void run(String thread){
        System.out.println(thread+":"+",ObjC");
    }

    public synchronized void addValue(){
        val++;
    }
    public synchronized void subValue(){
        val--;
    }
    
    private void print(){
        int i=5;
        while (i-->0){
            System.out.println(Thread.currentThread().getName() +":"+i);
        }
    }
    
    public void lockMember(){
        print();
    }
    
    public void lockObj(){
        synchronized (this){
            print();
        }
    }
    
    public void lockThisClass(){
        synchronized (ObjC.class){
            print();
        }
    }
    
    public synchronized void lockMethod(){
        print();
    }
    
    public synchronized static void lockStaticMethod(){
        int i=5;
        while (i-->0){
            System.out.println(Thread.currentThread().getName() +":"+i);
        }
    }

    public synchronized void lockMoreMethod1(){
        print();
    }

    public synchronized void lockMoreMethod2(){
        print();
    }

    public synchronized void lockMoreMethod3(){
        print();
    }
}