多线程锁

pearl-t / 2023-07-26 / 原文

一、悲观锁和乐观锁

1.1. 一级目录1

1.1.1. 二级目录1

1.1.2. 二级目录1

二、synchronized

2.1 八锁案例

2.1.1 说明

标准访问有ab两个线程，请问是先打印邮件还是短信？
sendEmal方法中加入暂停3秒钟，请问先打印邮件还是短份？
添加一个普通的heLLo方法，请问先打印邮件还是helLo？
有两部手机，请问先打印邮件还是短信
有两个静态同步方法，有部手机，请问先打印邮件还是短信？
有两个静态同步方法，有2部手机，请问先打印邮件还是短信？
有1个静态同步方法，有1个普通同步方法，有1部手机，请问先打印邮件还是短信？
一个静态同步方法，有1个普通同步方法，有2部手机，请问先打印邮件还是短信？

2.1.2 分析总结

根据情况1和情况2得出结论：不管暂停3秒还是不暂停都是先打印邮件再打印短信。

一个对象里面如果有多个synchronized方法，某一个时刻内，只要一个线程去调用其中的一个synchronized的方法了，其它的线程都只能等待，换句话说，某一个时刻内，只能有唯一的一个线程去访网这些synchronized方法。锁的是当前对象this，被锁定后，其它的线程都不能进入到当前对象的其它的synchronized方法

public class Lock8Demo {

    public static void main(String[] args)//一切程序的入口
    {
        Phone phone = new Phone();

        new Thread(() -> {
            phone.sendEmail();
        }, "a").start();

        //暂停200毫秒，保证a线程先启动
        try {
            TimeUnit.MILLISECONDS.sleep(200);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        new Thread(() -> {
            phone.sendSMS();
        }, "b").start();
    }
}

class Phone //资源类
{
    public synchronized void sendEmail() {

        // 第二种情况：暂停3秒，还是先打印邮件
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        // 打印邮件
        System.out.println("-----sendEmai1");
    }

    public synchronized void sendSMS() {
        // 打印短信
        System.out.println("-----sendsms");
    }

}

根据情况3和情况4得出结论：两个方法各自执行，无需等待

加个普通方法后发现和同步锁无关

换成两个对象后，不是同一把锁了，情况立即变化

public class Lock8Demo {

    public static void main(String[] args)//一切程序的入口
    {
        Phone phone = new Phone();
        Phone phone2 = new Phone();

        new Thread(() -> {
            phone.sendEmail();
        }, "a").start();

        //暂停200毫秒，保证a线程先启动
        try {
            TimeUnit.MILLISECONDS.sleep(200);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        new Thread(() -> {
            phone.hello();//情况3：先打印hello
            phone2.sendSMS();//情况4：先打印短信
        }, "b").start();
    }
}

class Phone //资源类
{
    public synchronized void sendEmail() {

        // 暂停3秒
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        // 打印邮件
        System.out.println("-----sendEmai1");
    }

    public synchronized void sendSMS() {
        // 打印短信
        System.out.println("-----sendsms");
    }

    public void hello() {
        // 打印hello
        System.out.println("-------hello");
    }

}

根据情况5和情况6得出结论：都换成静态同步方法后，不管new了几个对象，都是先打印邮件

三种synchronized 锁的内容有一些差别:

对于普通同步方法，锁的是当前实例对象，通常指this，具体的一部部手机，所有的普通同步方法用的都是同一把锁一>实例对象本身，

对于静态同步方法，锁的是当前类的cLass对象，如Phpne.cLass唯一的一个模板。

对于同步代码块，锁的是 synchronized括号内的对象

public class Lock8Demo {

    public static void main(String[] args)//一切程序的入口
    {
        Phone phone = new Phone();
        Phone phone2 = new Phone();

        new Thread(() -> {
            phone.sendEmail();
        }, "a").start();

        //暂停200毫秒，保证a线程先启动
        try {
            TimeUnit.MILLISECONDS.sleep(200);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        new Thread(() -> {
            phone.sendSMS();//情况5：先打印邮件
            phone2.sendSMS();//情况6：先打印邮件
        }, "b").start();
    }
}

class Phone //资源类
{
    public static synchronized void sendEmail() {

        // 暂停3秒
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        // 打印邮件
        System.out.println("-----sendEmai1");
    }

    public static synchronized void sendSMS() {
        // 打印短信
        System.out.println("-----sendsms");
    }

}

根据情况7和情况8得出结论：一个静态同步方法一个，一个普通同步方法，不管new了几个对象，两个方法都是各自执行，无需等待

当一个线程试图访问同步代码时它首先必须得到锁，正常退出或地出异常时必须释放锁。

所有的普通同步方法用的都是同一把锁——实例对象本身，就是new出来的具体实例对象本身，本类this；

也就是说如果一个实例对象的普通同步方法获取锁后，该实例对象的其他普通同步方法必须等待获取锁的方法释放锁后才能获取锁。

所有的静态同步方法用的也是同一把锁——类对象本身，就是我们说过的唯一模板CLass；

具体实例对象this 和唯一模板cLass，这两把锁是两个不同的对象，所以静态同步方法与普通同步方法之间是不会有竞态条件的

但是一旦一个静态同步方法获取锁后，其他的静态同步方法都必须等待该方法释放锁后才能获取锁。

public class Lock8Demo {

    public static void main(String[] args)//一切程序的入口
    {
        Phone phone = new Phone();
        Phone phone2 = new Phone();

        new Thread(() -> {
            phone.sendEmail();
        }, "a").start();

        //暂停200毫秒，保证a线程先启动
        try {
            TimeUnit.MILLISECONDS.sleep(200);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        new Thread(() -> {
            phone.sendSMS();//情况7：先打印短信
            phone2.sendSMS();//情况8：先打印短信
        }, "b").start();
    }
}

class Phone //资源类
{
    // 这是一个静态同步方法
    public static synchronized void sendEmail() {

        // 暂停3秒
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        // 打印邮件
        System.out.println("-----sendEmai1");
    }

    // 这是一个普通同步方法
    public synchronized void sendSMS() {
        // 打印短信
        System.out.println("-----sendsms");
    }

}