线程八锁问题超简单理解

在并发的环境中，锁机制一个良好的控制同步的方法，使用synchronize关键字对临界资源的锁，在普通的成员方法中添加锁的是调用该方法的对象public synchronized void Sem(){//普通同步的发邮件的方法 System.out.println("发邮件"); }，而在静态方法中使用 则锁的整个类对象（类对象是在class加载的时候进行创建的，每一个类只用有一个）public static synchronized void Sem(){//普通同步的发邮件的方法 System.out.println("发邮件"); }
第一种锁
两个synchronize修饰的是普通的成员方法，只有一个实例对象
不加线程的休眠操作

public class Phone {
   
    public synchronized void Sms(){
   //普通同步的发短信的方法

     
        System.out.println("发短信");
    }

    public synchronized void Sem(){
   //普通同步的发邮件的方法
        System.out.println("发邮件");
    }

    public static void main(String[] args) throws InterruptedException {
   
        Phone phone1=new Phone();//一个对象
        new Thread(()->{
   phone1.Sem();},"b").start();//b线程调用资源类中的发邮件

        new Thread(()->{
    phone1.Sms();},"a").start();//a线程调用资源类中的发短信


    }
}

结果是随机的，但是因为发邮件的线程在发短信的线程之前start所以获得cpu分配的时间片的机率更大

第二种锁
两个synchronize修饰的是普通的成员方法，只有一个实例对象增加线程的休眠操作

package eightLocks;

import java.util.concurrent.TimeUnit;

public class Phone {
   
    public synchronized void Sms(){
   //普通同步的发短信的方法


        System.out.println("发短信");
        try {
   
            TimeUnit.SECONDS.sleep(4);//休眠4秒，，如果两个方法不是需要同一个锁，发邮件就直接执行，结果是等待了四秒
        } catch (InterruptedException e) {
   
            e.printStackTrace();
        }
    }


    public synchronized void Sem(){
   //普通同步的发邮件的方法
        System.out.println("发邮件");
    }

    public static void main(String[] args) throws InterruptedException {
   
        Phone phone1=new Phone();//一个对象
        new Thread(()->{
   phone1.Sms()