首页 / 更多教程 / JUC并发编程（二）

JUC并发编程（二）

内容导读

互联网集市收集整理的这篇技术教程文章主要介绍了JUC并发编程（二），小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含6029字，纯文字阅读大概需要9分钟。

内容图文

8锁现象

在并发编程中，一直在谈论锁，但是锁到底是什么呢？它锁的是什么？

首先看下以下8个问题

1、一部手机，两个线程，标准访问，请问先打印邮件还是短信？
2、邮件方法暂停4秒钟，请问先打印邮件还是短信？
3、新增一个普通方法hello()没有同步,请问先打印邮件还是hello？
4、两部手机、请问先打印邮件还是短信？
5、两个静态同步方法，同一部手机，请问先打印邮件还是短信？
6、两个静态同步方法，2部手机，请问先打印邮件还是短信？
7、一个普通同步方法，一个静态同步方法，同一部手机，请问先打印邮件还是短信？
8、一个普通同步方法，一个静态同步方法，2部手机，请问先打印邮件还是短信？

看下程序运行的效果：

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

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

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

		//干扰条件
        try{
            TimeUnit.SECONDS.sleep(1);
        }catch (InterruptedException e){
            e.printStackTrace();
        }
        new Thread(()->{
            phone.sendSMS();
        },"B").start();
    }
}

/**
 * 手机，发短信，发邮件
 */
class Phone{

    public synchronized void sendEmail(){
        System.out.println("sendEmail");
    }

    public synchronized void sendSMS(){
        System.out.println("sendSMS");
    }
}

结果：
JUC并发编程（二） - 文章图片
2、邮件方法暂停4秒钟，请问先打印邮件还是短信？

public class Test2 {
    public static void main(String[] args) {

        Phone2 phone=new Phone2();

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

        //干扰
        try{
            TimeUnit.SECONDS.sleep(1);
        }catch (InterruptedException e){
            e.printStackTrace();
        }
        new Thread(()->{
            phone.sendSMS();
        },"B").start();
    }
}

/**
 * 手机，发短信，发邮件
 */
class Phone2{
      public synchronized void sendEmail(){
        try{
            TimeUnit.SECONDS.sleep(4);
        }catch (InterruptedException e){
            e.printStackTrace();
        }
        System.out.println("sendEmail");
    }

    public synchronized void sendSMS(){
        System.out.println("sendSMS");
    }
}

结果：
JUC并发编程（二） - 文章图片
3、新增一个普通方法hello()没有同步,请问先打印邮件还是hello？

public class Test3 {
      public static void main(String[] args) {

        Phone3 phone = new Phone3();

        new Thread(() -> { // 一开始就执行了
            phone.sendEmail();
        }, "A").start();

        // 干扰
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        new Thread(() -> { // 一秒后执行
            phone.hello();
        }, "B").start();

    }
}


/**
 *手机，发短信，发邮件
 */
class Phone3 {
 
    public synchronized void sendEmail() {
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("sendEmail");
    }

    public synchronized void sendMS() {
        System.out.println("sendMS");
    }

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

}

结果：
JUC并发编程（二） - 文章图片
4、两部手机、请问先打印邮件还是短信？

public class Test4 {

    public static void main(String[] args) {
        Phone4 phone1 = new Phone4();
        Phone4 phone2 = new Phone4();

        new Thread(() -> { // 一开始就执行了
            phone1.sendEmail();
        }, "A").start();

        // 干扰
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        new Thread(() -> { // 一秒后执行
            phone2.sendMS();
        }, "B").start();

    }
    }

// 手机，发短信，发邮件
class Phone4 {
    public synchronized void sendEmail() {
        // 善意的延迟
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("sendEmail");
    }

    public synchronized void sendMS() {
        System.out.println("sendMS");
    }

}

结果：
JUC并发编程（二） - 文章图片
5、两个静态同步方法，同一部手机，请问先打印邮件还是短信？

 public class Test5 {
     public static void main(String[] args) {
              Phone5 phone = new Phone5();

         new Thread(() -> { // 一开始就执行了
           phone.sendEmail();
       }, "A").start();

       // 干扰
       try {
           TimeUnit.SECONDS.sleep(1);
       } catch (InterruptedException e) {
           e.printStackTrace();
       }

       new Thread(() -> { // 一秒后执行
           phone.sendMS();
       }, "B").start();

   }

}


// 手机，发短信，发邮件
class Phone5 {

    public static synchronized void sendEmail() {
       // 善意的延迟
       try {
           TimeUnit.SECONDS.sleep(4);
       } catch (InterruptedException e) {
           e.printStackTrace();
       }
       System.out.println("sendEmail");
   }

   public static synchronized void sendMS() {
       System.out.println("sendMS");
   }

}

结果：
JUC并发编程（二） - 文章图片
6、两个静态同步方法，2部手机，请问先打印邮件还是短信？

public class Test6 {
public static void main(String[] args) {
        Phone5 phone = new Phone5();
        Phone5 phone2 = new Phone5();

        new Thread(() -> { // 一开始就执行了
        phone.sendEmail();
        }, "A").start();

        // 干扰
        try {
        TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
        e.printStackTrace();
        }

        new Thread(() -> { // 一秒后执行
        phone2.sendMS();
        }, "B").start();

        }

        }

// 手机，发短信，发邮件
class Phone6 {
       public static synchronized void sendEmail() {
        // 善意的延迟
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("sendEmail");
    }

    public static synchronized void sendMS() {
        System.out.println("sendMS");
    }

}

结果：
JUC并发编程（二） - 文章图片
7、一个普通同步方法，一个静态同步方法，同一部手机，请问先打印邮件还是短信？

public class Test7 {
    
    public static void main(String[] args) {
           Phone7 phone = new Phone7();

        new Thread(() -> { // 一开始就执行了
            phone.sendEmail();
        }, "A").start();

        // 干扰
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        new Thread(() -> { // 一秒后执行
            phone.sendMS();
        }, "B").start();

    }
}


class Phone7{
    // CLASS
    public static synchronized void sendEmail() {
        // 善意的延迟
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("sendEmail");
    }

    // 对象
    // 普通同步方法
    public synchronized void sendMS() {
        System.out.println("sendMS");
    }

}

结果：
JUC并发编程（二） - 文章图片

8.一个普通同步方法，一个静态同步方法，2部手机，请问先打印邮件还是短信？

public class Test8 {

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

        new Thread(() -> { // 一开始就执行了
            phone.sendEmail();
        }, "A").start();

        // 干扰
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        new Thread(() -> { // 一秒后执行
            phone2.sendMS();
        }, "B").start();

    }

}



class Phone8{

    // CLASS
    public static synchronized void sendEmail() {
        // 善意的延迟
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("sendEmail");
    }

    // 对象
    // 普通同步方法
    public synchronized void sendMS() {
        System.out.println("sendMS");
    }

}

结果：
JUC并发编程（二） - 文章图片

总结：

锁是一种竞争机制，一个方法加锁，一个方法没有加锁，那么普通方法就会先运行，因为它不要去竞争！
被synchornized修饰的同步方法，锁的对象是方法的调用者。谁先调用，谁先执行！
被synchronized修饰和static修饰的方法，锁的对象是类的class对象,唯一的！

内容总结

以上是互联网集市为您收集整理的JUC并发编程（二）全部内容，希望文章能够帮你解决JUC并发编程（二）所遇到的程序开发问题。如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。

内容备注

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容，请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。

内容手机端

扫描二维码推送至手机访问。

本文链接：https://qyyshop.com/info/639618.html

来源：【匿名】

【上一篇】为什么要成为「无敌」程序员？【下一篇】关于IE的RegExp.exec的问题

更多 ►

【JUC并发编程（二）】教程文章相关的互联网学习教程文章

并发编程-线程池（五）线程池为什么不允许使用Executors创建

一、Executors 线程池创建工具【1】 1、Executors.newCachedThreadPool();说明: 创建的线程池核心线程0 ，最大线程是Integer.MaxValue。线程空闲存活时间1分钟。默认异常拒绝策略，使用SynchronousQueue队特点:每次添加任务如果没有空闲线程就会新建一个线程去执行。　　SynchronousQueue是阻塞队列，加入任务的线程会阻塞住，直到其它线程从中取走任务才会结束阻塞　　线程创建上限近乎无限适用场景：所以它适用于任务加入比...

深入理解并发编程 -- 多线程（二）底层运行原理、线程状态【图】

并发编程 -- 多线程底层运行原理、线程状态作者： Stanley 罗昊多线程 -- 并发编程（一）： https://www.cnblogs.com/StanleyBlogs/p/10890906.html 【转载请注明出处和署名，谢谢！】多线程底层执行原理说道底层运行，那么是不是就是需要依靠CPU啊；那，各位之前有没有听过一句话叫做，一个CPU在同一个时间片只能执行一个程序；什么意思呢？就是，你的程序是不是都运行在一个CPU上啊，那你真正一个CPU在同一个时间片里是...

【并发编程必备基础之进程】 �

原文: http://blog.gqylpy.com/gqy/236 目录 1.操作系统背景知识 2.什么是进程 3.进程调度 4.进程的并行与并发 5.同步异步阻塞非阻塞 6.进程的创建与结束 1.操作系统背景知识顾名思义，进程即正在执行的一个过程，进程是对正在运行的程序的一个抽象。进程的概念起源于操作系统，是操作系统最核心的概念，也是操作系统提供的最古老的最重要的抽象概念之一，操作系统的其他所有内容都是围绕进程的概念展开的。所以想要真正了解...

透彻讲解：并发编程的优缺点

本人免费整理了Java高级资料，涵盖了Java、Redis、MongoDB、MySQL、Zookeeper、Spring Cloud、Dubbo高并发分布式等教程，一共30G，需要自己领取。传送门：https://mp.weixin.qq.com/s/JzddfH-7yNudmkjT0IRL8Q一直以来并发编程对于刚入行的小白来说总是觉得高深莫测，于是乎，就诞生了想写点东西记录下，以提升理解和堆并发编程的认知。为什么需要用的并发？凡事总有好坏两面，之间的trade-off是什么，也就是说并发编程具有哪些缺点...

JUC并发编程（二）【代码】【图】

8锁现象在并发编程中，一直在谈论锁，但是锁到底是什么呢？它锁的是什么？首先看下以下8个问题1、一部手机，两个线程，标准访问，请问先打印邮件还是短信？ 2、邮件方法暂停4秒钟，请问先打印邮件还是短信？ 3、新增一个普通方法hello()没有同步,请问先打印邮件还是hello？ 4、两部手机、请问先打印邮件还是短信？ 5、两个静态同步方法，同一部手机，请问先打印邮件还是短信？ 6、两个静态同步方法，2部手机，请问先打印邮件还是...

并发编程及并发编程的核心【图】

核心：基于资源状态的调度方式的控制权问题：有锁无锁调度线程：基于内核的锁调度；其它：应用层自我调度；并发编程在过去的30年里，计算机的性能是在摩尔定律的推动下，从现在开始，这将由Amdahl定律决定。编写代码，有效地利用多个处理器可以是非常具有挑战性的。" -Doron Rajwan　　 Amdahls Law：每个程序都分为串行与并行部分，降低串行的比重，可提高程序的效率。进行多核多服务器时代，并行并发模式更是对程序员的...

并发编程学习笔记(2)----使用多线程带来的风险【代码】

说到多线程带来的风险，首先要了解一个概念-临界区。什么是临界区？临界区是用来表示一种公共的资源（共享数据），它可以被多个线程使用，但是在每次只能有一个线程能够使用它，当临界区资源正在被一个线程使用时，其他的线程就只能等待当前线程执行完之后才能使用该临界区资源。比如一台饮水机，比如办公室办公室里有一支笔，它一次只能被一个人使用，假如它正在被甲使用时，其他想要使用这支笔的人只能等甲使用完这支笔之后才能允...

【并发编程】（十）线程本地变量的实现——ThreadLocal原理详解【代码】【图】

文章目录 1.ThreadLocal的实现1.1.创建1.2.初始化1.3.移除1.4.存储结构图示1.5.小结 2.ThreadLocalMap的实现2.1.Entry的结构2.1.1.为什么key要使用弱引用2.1.2.为什么value不使用弱引用 2.2.Entry初始化2.2.1.模拟魔数的使用2.2.2.ThreadLocal是如何使用魔数的2.2.3.数组下标出现重复的情况 2.3.set()方法2.3.1.set()方法源码解析2.3.1.1.开放寻址法——解决Hash冲突 2.3.2.扩容 2.4.get()方法2.5.remove()方法 3.总结 1.ThreadLoc...

JUC并发编程(基础入门七)——JMM、volatile、禁止指令重排【代码】【图】

1 JMM 1对Volatile 的理解 Volatile 是 Java 虚拟机提供轻量级的同步机制 1、保证可见性 2、不保证原子性 3、禁止指令重排如何实现可见性 volatile变量修饰的共享变量在进行写操作的时候回多出一行汇编： 0x01a3de1d:movb $00，01104800（%esi）;0x01a3de24**:lock** addl $00,(%esp); Lock前缀的指令在多核处理器下会引发两件事情。 1）将当前处理器缓存行的数据写回到系统内存。 2）这个写回内存的操作会使其他cpu里缓存了该内...

并发编程之GIL锁

并发编程之GIL锁 1.定义 ? GIL(Global_Interpreter_Lock)全局解释器锁: ? 在cpython中,GIL是一个互斥锁,为了防止多个本地线程在同一时间执行python字节码,因为cpython中的内存管理是非线程安全的,而cpython中的很多特性都依赖于这个特性. 2.cpython解释器与python程序之间的关系python程序本质就是一堆字符串,所以运行一个python程序时必须要开启开启一个解释器但是在一个python程序中解释器只有一个所有代码都要交给它来解释执...

首页 / 更多教程 / JUC并发编程（二）

JUC并发编程（二）

内容导读

内容图文

8锁现象

内容总结

内容备注

内容手机端

【JUC并发编程（二）】教程文章相关的互联网学习教程文章

并发编程-线程池（五）线程池为什么不允许使用Executors创建

深入理解并发编程 -- 多线程（二）底层运行原理、线程状态【图】

【并发编程必备基础之进程】 �

透彻讲解：并发编程的优缺点

JUC并发编程（二）【代码】【图】

并发编程及并发编程的核心【图】

并发编程学习笔记(2)----使用多线程带来的风险【代码】

【并发编程】（十）线程本地变量的实现——ThreadLocal原理详解【代码】【图】

JUC并发编程(基础入门七)——JMM、volatile、禁止指令重排【代码】【图】

并发编程之GIL锁

不愧是阿里P7私传“并发编程核心讲义”，实战案例，个个是经典【图】

多并发编程基础之协成【代码】【图】

并发编程之Fork/Join【代码】【图】

并发编程之线程进阶【代码】

并发编程的一些基本概念【图】

更多教程 - 最新教程

更多教程 - 最热教程