首页手记 static和synchronized

static和synchronized

标签：

Java

static和synchronized

2个线程模拟手机发邮件和发短信功能

八锁

标准访问 2个线程一部手机资源类
发邮件睡眠4秒
新增sayHello方法
两部手机资源类
2个静态同步方法一部手机
2个静态同步方法两部部手机
1个静态同步方法一个普通同步方法一部手机
1个静态同步方法一个普通同步方法两部部手机

场景一

标准访问 2个线程一部手机资源类

package com.zbiti.juc;

import java.util.concurrent.TimeUnit;

public class LockDemo {
    public static void main(String[] args) throws InterruptedException {
        Phone phone = new Phone();
        
        new Thread(() -> {
            phone.sendEmail();
        }, "AA").start();

        TimeUnit.SECONDS.sleep(2);

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

//手机资源类，带发邮件、发短信功能
class Phone {
    //发邮件
     synchronized void sendEmail() {
        System.out.println("sendEmail----->");
    }

    //发短信
    synchronized void sendSMS() {
        System.out.println("sendSMS------->");
    }


}

结果

场景二

发邮件睡眠4秒

package com.zbiti.juc;

import java.util.concurrent.TimeUnit;

public class LockDemo {
    public static void main(String[] args) throws InterruptedException {
        Phone phone = new Phone();

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

        TimeUnit.SECONDS.sleep(2);

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

//手机资源类，带发邮件、发短信功能
class Phone {
    //发邮件
     synchronized void sendEmail() {
         try {
             TimeUnit.SECONDS.sleep(4);
         } catch (InterruptedException e) {
             e.printStackTrace();
         }
         
         System.out.println("sendEmail----->");
    }

    //发短信
    synchronized void sendSMS() {
        System.out.println("sendSMS------->");
    }
}

结果

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

场景三

新增sayHello方法

package com.zbiti.juc;

import java.util.concurrent.TimeUnit;

public class LockDemo {
    public static void main(String[] args) throws InterruptedException {
        Phone phone = new Phone();

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

        TimeUnit.SECONDS.sleep(2);

        new Thread(() -> {
            phone.sayHello();
        }, "BB").start();
    }
}

//手机资源类，带发邮件、发短信功能
class Phone {
    //发邮件
     synchronized void sendEmail() {
         try {
             TimeUnit.SECONDS.sleep(4);
         } catch (InterruptedException e) {
             e.printStackTrace();
         }

         System.out.println("sendEmail----->");
    }

    //发短信
    synchronized void sendSMS() {
        System.out.println("sendSMS------->");
    }

    void sayHello(){
        System.out.println("sayHello------>");
    }
}

结果

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

场景四

两部手机资源类

package com.zbiti.juc;

import java.util.concurrent.TimeUnit;

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

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

        TimeUnit.SECONDS.sleep(2);

        new Thread(() -> {
            phone2.sendSMS();
        }, "BB").start();
    }
}

//手机资源类，带发邮件、发短信功能
class Phone {
    //发邮件
     synchronized void sendEmail() {
         try {
             TimeUnit.SECONDS.sleep(4);
         } catch (InterruptedException e) {
             e.printStackTrace();
         }

         System.out.println("sendEmail----->");
    }

    //发短信
    synchronized void sendSMS() {
        System.out.println("sendSMS------->");
    }

    void sayHello(){
        System.out.println("sayHello------>");
    }


}

结果

换成两个对象后，不是同一把锁，情况立刻发生了变化，所有的非静态同步方法用的都是同一把锁，即实例对象本身

场景五

2个静态同步方法一部手机

package com.zbiti.juc;

import java.util.concurrent.TimeUnit;

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

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

        TimeUnit.SECONDS.sleep(2);

        new Thread(() -> {
            phone.sendSMS();
//            phone2.sendSMS();
        }, "BB").start();
    }
}

//手机资源类，带发邮件、发短信功能
class Phone {
    //发邮件
    static synchronized void sendEmail() {
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("sendEmail----->");
    }

    //发短信
    static synchronized void sendSMS() {
        System.out.println("sendSMS------->");
    }

    void sayHello() {
        System.out.println("sayHello------>");
    }
}

结果

synchronized实现同步的基础，java中的每一个对象都可以作为锁，具体表现以下3种形式

对于普通同步方法，锁是当前实例对象
对于同步方法块，锁是synchronized括号里配置的对象
对于静态同步方法，锁是当前类的Class对象

场景六

2个静态同步方法两部部手机

package com.zbiti.juc;

import java.util.concurrent.TimeUnit;

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

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

        TimeUnit.SECONDS.sleep(2);

        new Thread(() -> {
//            phone.sendSMS();
            phone2.sendSMS();
        }, "BB").start();
    }
}

//手机资源类，带发邮件、发短信功能
class Phone {
    //发邮件
    static synchronized void sendEmail() {
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("sendEmail----->");
    }

    //发短信
    static synchronized void sendSMS() {
        System.out.println("sendSMS------->");
    }

    void sayHello() {
        System.out.println("sayHello------>");
    }


}

结果

场景七

1个静态同步方法一个普通同步方法一部手机

package com.zbiti.juc;

import java.util.concurrent.TimeUnit;

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

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

        TimeUnit.SECONDS.sleep(2);

        new Thread(() -> {
            phone.sendSMS();
//            phone2.sendSMS();
        }, "BB").start();
    }
}

//手机资源类，带发邮件、发短信功能
class Phone {
    //发邮件
    static synchronized void sendEmail() {
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("sendEmail----->");
    }

    //发短信
    synchronized void sendSMS() {
        System.out.println("sendSMS------->");
    }

    void sayHello() {
        System.out.println("sayHello------>");
    }
}

结果

场景八

1个静态同步方法一个普通同步方法两部部手机

package com.zbiti.juc;

import java.util.concurrent.TimeUnit;

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

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

        TimeUnit.SECONDS.sleep(2);

        new Thread(() -> {
//            phone.sendSMS();
            phone2.sendSMS();
        }, "BB").start();
    }
}

//手机资源类，带发邮件、发短信功能
class Phone {
    //发邮件
    static synchronized void sendEmail() {
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("sendEmail----->");
    }

    //发短信
    synchronized void sendSMS() {
        System.out.println("sendSMS------->");
    }

    void sayHello() {
        System.out.println("sayHello------>");
    }
}

结果

锁当前实例对象和锁当前类的Class对象是两个不同的对象，所以静态同步方法和非静态同步方法之间是不会有竞态条件的。但是一旦一个静态同步方法获取锁后，其它的静态同步方法都必须等待该方法释放锁后才能获取锁，而不管是同一个实例对象的静态同步方法之间，还是不同的实例对象静态同步方法之间

本文由博客一文多发平台 OpenWrite 发布！

点击查看更多内容

为 TA 点赞

若觉得本文不错，就分享一下吧！

评论

评论

共同学习，写下你的评论

评论加载中...

展开查看更多评论

作者其他优质文章

正在加载中

libingshen

JAVA开发工程师

手记
篇

粉丝

2

获赞与收藏

7

关注作者，订阅最新文章

相关文章推荐

synchronized和Lock

synchronized 和ReenTrantLock关键字

锁之synchronized

Java多线程的创建和Synchronized

synchronized学习

阅读免费教程

Java并发工具

23个小节 19133 310

Java 并发原理入门教程

26个小节 38736 565

Java 入门教程

50个小节 339380 3141

推荐

评论

收藏

共同学习，写下你的评论



感谢您的支持，我会继续努力的～

扫码打赏，你说多少就多少

赞赏金额会直接到老师账户

支付方式

打开微信扫一扫，即可进行扫码打赏哦

今天注册有机会得

100积分直接送

付费专栏免费学

大额优惠券免费领

立即参与放弃机会

点击
抽奖

慕课手记新用户专享福利

恭喜你，你的运气太好了，居然抽中了 100个积分！

恭喜你，抽中了价值元的专栏！

太棒了，直接落到你账户里！

积分商城里的罗技鼠标、机械键盘、
Kindle 阅读器、小米平衡车
Apple iPad （10.2英寸）、大额优惠券
在等着你去兑换了噢

作者：

免费赠送

兑换码：1111222211 复制

优惠券可用于购买实战课、体系课
无门槛使用

先去看看，有什么好东西马上兑换我爱学习，选课去


热搜

最近搜索清空

static和synchronized

static和synchronized

场景一

场景二

场景三

场景四

场景五

场景六

场景七

场景八

相关文章推荐

阅读免费教程