多线程锁synchronized多种测试案例

最新推荐文章于 2024-05-08 07:00:00 发布

GuochaoHN

最新推荐文章于 2024-05-08 07:00:00 发布

阅读量827

点赞数

分类专栏： JUC 文章标签： java 开发语言

本文链接：https://blog.csdn.net/weixin_46369022/article/details/122869826

版权

JUC 专栏收录该内容

14 篇文章 8 订阅

订阅专栏

1、标准访问，先打印短信还是邮件

class Phone {
    public synchronized void sendSMS() throws Exception {
       //TimeUnit.SECONDS.sleep(4);
       //即使是当前线程sleep4秒，其他线程也无法调用此类中的所有synchronized方法，因为锁就是当前调用此方法的对象，且并没有释放。
        System.out.println("------sendSMS");
    }
    public synchronized void sendEmail() throws Exception {
        System.out.println("------sendEmail");
    }
    public void getHello() {
        System.out.println("------getHello");
    }
}
public class Testsyn {
    public static void main(String[] args) throws Exception
    {
        Phone phone = new Phone();
        Phone phone2 = new Phone();

        new Thread(() -> {
            try {
                phone.sendSMS();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }, "AA").start();

        Thread.sleep(100);
        
        new Thread(() -> {
            try {
                phone.sendEmail();         
            } catch (Exception e) {
                e.printStackTrace();
            }
        }, "BB").start();
    }
}

一个类里面如果有多个synchronized方法，某一个时刻内，只要一个线程（此类的一个对象）去调用其中的一个synchronized方法了，其它的线程都只能等待，换句话说，某一个时刻内，只能有唯一一个线程去访问这些synchronized方法。

因为非静态synchronized方法的锁是当前对象this，被锁定后，其它的线程都不能进入到当前对象的其它的synchronized方法。

在这里插入图片描述
如果一个实例对象的非静态同步方法获取锁后，该实例对象的其他非静态同步方法必须等待获取锁的方法释放锁后才能获取锁，可是别的实例对象的非静态同步方法因为跟该实例对象的非静态同步方法用的是不同的锁，
所以毋须等待该实例对象已获取锁的非静态同步方法释放锁就可以获取他们自己的锁。

2、普通的hello方法，是先打短信还是hello

public class Testsyn {

    public static void main(String[] args) throws Exception
    {

        Phone phone = new Phone();
        Phone phone2 = new Phone();

        new Thread(() -> {
            try {
                phone.sendSMS();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }, "AA").start();

        Thread.sleep(100);

        new Thread(() -> {
            try {              
                phone.getHello();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }, "BB").start();
    }
}

调用普通方法与同步锁无关
在这里插入图片描述
3、现在有两部手机，先打印短信还是邮件

class Phone {
    public synchronized void sendSMS() throws Exception {
        TimeUnit.SECONDS.sleep(4);
        System.out.println("------sendSMS");
    }
    public synchronized void sendEmail() throws Exception {
        System.out.println("------sendEmail");
    }
    public void getHello() {
        System.out.println("------getHello");
    }
}

public class Testsyn {

    public static void main(String[] args) throws Exception
    {
        Phone phone = new Phone();
        Phone phone2 = new Phone();

        new Thread(() -> {
            try {
                phone.sendSMS();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }, "AA").start();

        Thread.sleep(100);

        new Thread(() -> {
            try {
                phone2.sendEmail();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }, "BB").start();
    }
}

两个锁对象，相互不影响。
在这里插入图片描述
4、两个静态同步方法，1部手机，先打印短信还是邮件

class Phone {
    public static synchronized void sendSMS() throws Exception {

        TimeUnit.SECONDS.sleep(4);
        System.out.println("------sendSMS");
    }

    public static synchronized void sendEmail() throws Exception {
        System.out.println("------sendEmail");
    }

    public void getHello() {
        System.out.println("------getHello");
    }

}

public class Testsyn {

    public static void main(String[] args) throws Exception
    {

        Phone phone = new Phone();
        Phone phone2 = new Phone();

        new Thread(() -> {
            try {
                phone.sendSMS();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }, "AA").start();

        Thread.sleep(100);

        new Thread(() -> {
            try {
                phone.sendEmail();              
            } catch (Exception e) {
                e.printStackTrace();
            }
        }, "BB").start();
    }
}

对于静态同步方法，锁是当前类的Class对象。这里this对象也相同。
在这里插入图片描述
5、两个静态同步方法，2部手机，先打印短信还是邮件

class Phone {
    public static synchronized void sendSMS() throws Exception {
        TimeUnit.SECONDS.sleep(4);
        System.out.println("------sendSMS");
    }
    public static synchronized void sendEmail() throws Exception {
        System.out.println("------sendEmail");
    }
    public void getHello() {
        System.out.println("------getHello");
    }
}
public class Testsyn {
    public static void main(String[] args) throws Exception
    {

        Phone phone = new Phone();
        Phone phone2 = new Phone();

        new Thread(() -> {
            try {
                phone.sendSMS();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }, "AA").start();

        Thread.sleep(100);

        new Thread(() -> {
            try {
                //phone.sendEmail();
               // phone.getHello();
                phone2.sendEmail();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }, "BB").start();
    }
}

对于静态同步方法，锁是当前类的Class对象。同样是先执行sms。
在这里插入图片描述
6、1个静态同步方法，1个普通同步方法，1部手机，先打印短信还是邮件

class Phone {
    public static synchronized void sendSMS() throws Exception {
        TimeUnit.SECONDS.sleep(4);
        System.out.println("------sendSMS");
    }
    public  synchronized void sendEmail() throws Exception {
        System.out.println("------sendEmail");
    }
    public void getHello() {
        System.out.println("------getHello");
    }

}

public class Testsyn {
    public static void main(String[] args) throws Exception
    {

        Phone phone = new Phone();
        Phone phone2 = new Phone();

        new Thread(() -> {
            try {
                phone.sendSMS();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }, "AA").start();

        Thread.sleep(100);

        new Thread(() -> {
            try {
                phone.sendEmail();              
            } catch (Exception e) {
                e.printStackTrace();
            }
        }, "BB").start();
    }
}

静态同步方法用的也是同一把锁——类对象本身，与非静态同步方法的对象不同，所以静态同步方法与非静态同步方法之间是不会有竞态条件的。
在这里插入图片描述
7、1个静态同步方法，1个普通同步方法，2部手机，先打印短信还是邮件

class Phone {
    public static synchronized void sendSMS() throws Exception {
        TimeUnit.SECONDS.sleep(4);
        System.out.println("------sendSMS");
    }
    public  synchronized void sendEmail() throws Exception {
        System.out.println("------sendEmail");
    }
    public void getHello() {
        System.out.println("------getHello");
    }
}

public class Testsyn {
    public static void main(String[] args) throws Exception
    {
        Phone phone = new Phone();
        Phone phone2 = new Phone();

        new Thread(() -> {
            try {
                phone.sendSMS();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }, "AA").start();

        Thread.sleep(100);

        new Thread(() -> {
            try {
                phone2.sendEmail();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }, "BB").start();
    }
}

原理同上：不是同一把锁，不存在竞争关系。
在这里插入图片描述

GuochaoHN

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
多线程锁synchronized多种测试案例

1、标准访问，先打印短信还是邮件class Phone { public synchronized void sendSMS() throws Exception { //TimeUnit.SECONDS.sleep(4); //即使是当前线程sleep4秒，其他线程也无法调用此类中的所有synchronized方法，因为锁就是当前调用此方法的对象，且并没有释放。 System.out.println("------sendSMS"); }
复制链接

扫一扫