8锁问题（充分了解锁的概念）

1

package com.luoKing.Lock8;
 
/*
* 1、两个同步方法，被同一个对象调用，由于锁的存在，谁先拿到锁，谁先执行（谁在前面，谁先执行）
*
* 2、 一个同步方法延时，另一个正常 被同一个对象调用？谁先拿到锁，谁先执行，与谁休息无关
* */
 
 
import java.util.concurrent.TimeUnit;
 
public class test1 {
    public static void main(String[] args) {
        bucket bucket = new bucket();
        new Thread(()->{
            bucket.pour();
        }).start();
        new Thread(()->{
            bucket.drink();
        }).start();
    }
 
}
 
class bucket{//桶
 
//synchronized 锁的对象是方法的调用者
    public synchronized void pour(){//倒水的功能
        try {
            TimeUnit.SECONDS.sleep(1);  //休息一秒
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("倒水");
    }
    public synchronized void drink(){//喝水
        System.out.println("喝水");
    }
}

2

package com.luoKing.Lock8;
 
import java.util.concurrent.TimeUnit;
 
/*
 * 1、一个普通方法，一个延时同步方法，同一个对象调用，先调用普通方法，由于普通方法不受锁的影响，可以直接执行
 *
 * 2、 一个同步方法延时，另一个正常 被两个对象调用？由于是两把锁，那两个线程互不影响，谁快就谁先执行。
 * */
public class test2{
    public static void main(String[] args) {
        bucket2 bucket = new bucket2();
 
        new Thread(()->{
            bucket.pour();
        }).start();
        new Thread(()->{
            bucket.hello();
        }).start();
    }
 
}
 
class bucket2{//桶
    public synchronized void pour(){//倒水的功能
        try {
            TimeUnit.SECONDS.sleep(1);  //休息一秒
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("倒水");
    }
    public synchronized void drink(){//喝水
        System.out.println("喝水");
    }
    public void hello(){
        System.out.println("桶对你说，hello");
    }
}

3

package com.luoKing.Lock8;
 
import java.util.concurrent.TimeUnit;
 
 
/*
* 1.两个静态同步类方法，一个对象调用，先执行倒水还是喝水？是倒水，锁的对象一样都是Class，所以谁先拿到锁，谁先执行
*
*
*2.两个静态同步类方法，两个对象调用，先执行倒水还是喝水？是倒水，原因与上面的一样
*
*
* */
public class test3 {
    public static void main(String[] args) {
        bucket3 bucket = new bucket3();
        bucket3 bucket2 = new bucket3();
 
        new Thread(()->{
            bucket.pour();
        }).start();
        new Thread(()->{
            bucket2.drink();
        }).start();
    }
 
}
 
class bucket3{//桶
 
 
    /*
    * 普通的同步方法，锁的对象是方法调用者
    *
    * 静态同步方法，锁的对象是Class对象，我们知道一个类的Class对象（模板）全局唯一
    * */
    public static synchronized void pour(){//倒水的功能
        try {
            TimeUnit.SECONDS.sleep(1);  //休息一秒
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("倒水");
    }
    public static synchronized void drink(){//喝水
        System.out.println("喝水");
    }
 
}

4

package com.luoKing.Lock8;
 
import java.util.concurrent.TimeUnit;
 
 
 
/*
 * 1.一个静态同步类方法，一个普通同步类方法 ，一个对象调用，先执行倒水还是喝水？是喝水，锁的对象不一样，谁快谁先执行，互不影响
 *
 *
 *2.一个静态同步类方法，一个普通同步类方法 ，两个对象调用，先执行倒水还是喝水？是喝水，锁的对象不一样，谁快谁先执行，互不影响
 *
 *
 * */
public class test4 {
    public static void main(String[] args) {
        bucket4 bucket = new bucket4();
        bucket4 bucket1 = new bucket4();
 
 
        new Thread(()->{
            bucket.pour();
        }).start();
        new Thread(()->{
            bucket1.drink();
        }).start();
    }
 
}
 
class bucket4{//桶
 
 
    /*
     * 静态同步方法，锁的对象是Class对象，我们知道一个类的Class对象（模板）全局唯一
     * */
    public static synchronized void pour(){//倒水的功能
        try {
            TimeUnit.SECONDS.sleep(1);  //休息一秒
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("倒水");
    }
    /*
    * 普通的同步方法，锁的对象是方法调用者
    * */
    public synchronized void drink(){//喝水
        System.out.println("喝水");
    }
 
}