首页 > 编程语言 >JUC并发编程学习笔记(四)8锁现象

JUC并发编程学习笔记(四)8锁现象

时间:2023-11-02 21:56:24浏览次数:32  
标签:JUC 调用者 synchronized void 编程 并发 TimeUnit new public

8锁现象

八锁->就是关于锁的八个问题

锁是什么,如何判断锁的是谁

对象、class模板

深刻理解锁

锁的东西无外乎就两样:1、同步方法的调用者,2、Class模板。

同一个锁中,只有当前线程资源释放后才会被下一个线程所接手。

同步方法的调用者是两个不同的实例时,互不相关。

静态同步方法(static)锁的是整个Class模板,和同步方法的调用者也不是同一个锁;切Class模板在Java程序中唯一。

代码示例

1、浅浅理解锁的作用

同一把锁中根据执行先后释放资源,保证一个资源的使用顺序

package org.example.phone;

import java.util.concurrent.TimeUnit;

public class Test1 {
    public static void main(String[] args) {
//        标准情况下,打印顺序为 1、发短信,2、打电话
//        给sendMsg内部延迟四秒执行,执行顺序依旧是 1、发短信,2、打电话
//        可知,并非是我们所想的,A线程在前面就先执行,而是锁的机制导致了这种情况
//        phone1只创建了一个对象,所以这个对象的锁只有一把,谁先拿到就是谁先执行
//        锁的对象是该方法的调用者,即phone1
        Phone1 phone1 = new Phone1();
        new Thread(()->{
            phone1.sendMsg();
        },"A").start();

        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }

        new Thread(()->{
            phone1.call();
        },"B").start();
    }
}
class Phone1{
//    synchronized锁的对象是方法的调用者,Phone1只new了一个对象,所以锁的是new出来的整个对象
    public synchronized void sendMsg(){

        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        System.out.println("发短信");
    }
    public synchronized void call(){
        System.out.println("打电话");
    }
}

2、区分锁的对象

不同的实例使用的锁并非同一把,所以也无法同时锁定某个固定的资源、无法对同一资源进行有顺序的操作

package org.example.phone;

import java.util.concurrent.TimeUnit;

public class Test3 {
    public static void main(String[] args) {
//        标准情况下,打印顺序为 1、发短信,2、打电话
//        给sendMsg内部延迟四秒执行,执行顺序依旧是 1、发短信,2、打电话
//        可知,并非是我们所想的,A线程在前面就先执行,而是锁的机制导致了这种情况
//        phone1只创建了一个对象,所以这个对象的锁只有一把,谁先拿到就是谁先执行
//        锁的对象是该方法的调用者,即phone1

//        调用两个不同对象的方法,锁的是两个不同的对象,此时先出现打电话,说明不同对象之间的锁互不影响
        Phone3 phone3_1 = new Phone3();
        Phone3 phone3_2 = new Phone3();
        new Thread(()->{
            phone3_1.sendMsg();
        },"A").start();

        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }

        new Thread(()->{
            phone3_2.call();
        },"B").start();
    }
}
class Phone3{
    //    synchronized锁的对象是方法的调用者,Phone1只new了一个对象,所以锁的是new出来的整个对象
    public synchronized void sendMsg(){

        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        System.out.println("发短信");
    }
    public synchronized void call(){
        System.out.println("打电话");
    }
    //    当在资源类中添加了一个普通方法后,先输出hello
//    没有锁,不是同步方法,不受锁的影响
    public void hello(){
        System.out.println("Hello");
    }
}

3、了解锁的参与者

只有同步方法参与锁,普通方法依旧按照java执行顺序执行

package org.example.phone;

import java.util.concurrent.TimeUnit;

public class Test2 {
    public static void main(String[] args) {
//        标准情况下,打印顺序为 1、发短信,2、打电话
//        给sendMsg内部延迟四秒执行,执行顺序依旧是 1、发短信,2、打电话
//        可知,并非是我们所想的,A线程在前面就先执行,而是锁的机制导致了这种情况
//        phone1只创建了一个对象,所以这个对象的锁只有一把,谁先拿到就是谁先执行
//        锁的对象是该方法的调用者,即phone1
        Phone2 phone2 = new Phone2();
        new Thread(()->{
            phone2.sendMsg();
        },"A").start();

        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }

        new Thread(()->{
            phone2.hello();
        },"B").start();
    }
}
class Phone2{
    //    synchronized锁的对象是方法的调用者,Phone1只new了一个对象,所以锁的是new出来的整个对象
    public synchronized void sendMsg(){

        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        System.out.println("发短信");
    }
    public synchronized void call(){
        System.out.println("打电话");
    }
//    当在资源类中添加了一个普通方法后,先输出hello
//    没有锁,不是同步方法,不受锁的影响
    public void hello(){
        System.out.println("Hello");
    }
}

4、明白锁能锁谁

锁只能锁两个东西,一个是同步方法的调用者,一个是整个Class模板(全局唯一),一旦使用static创建静态同步方法,那么该方法的锁锁的就是全局唯一的Class模板,并且在反射时就已经被创建了

package org.example.phone;

import java.util.concurrent.TimeUnit;

public class Test4 {
    public static void main(String[] args) {
//        两个对象的Class类模板只有一个;static,锁的是Class
        Phone4 phone4_1 = new Phone4();
        Phone4 phone4_2 = new Phone4();
        new Thread(()->{
            phone4_1.sendMsg();
        },"A").start();

        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }

        new Thread(()->{
            phone4_2.call();
        },"B").start();
    }
}
class Phone4{
//    synchronized锁的对象是方法的调用者
//    注:增加了static静态方法 此时调用该方法的就变成了Phone4的反射对象,全局唯一
//    此时锁的就是Class模板了,即不管你有几个调用者,都在同一个锁
//    static方法类一加载就有了!锁的是Class
    public static synchronized void sendMsg(){

        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        System.out.println("发短信");
    }
    public static synchronized void call(){
        System.out.println("打电话");
    }
}

5、深入理解锁的是谁

静态同步方法和普通同步方法在一起使用时,锁的并非同一对象,所以打印顺序也时按java的执行顺序来,并不存在锁定资源的情况

package org.example.phone;

import java.util.concurrent.TimeUnit;
/*
* 1、一个静态同步方法,一个普通同步方法,先打印发短信还是打电话
*   两个方法一个锁的是Class模板,一个锁的是调用者,锁的不是同一对象,所以延迟四秒的静态同步方法后打印,延迟一秒的普通同步方法先打印
*
* */
public class Test5 {
    public static void main(String[] args) {

        Phone5 phone5_1 = new Phone5();
//        Phone5 phone5_2 = new Phone5();
        new Thread(()->{
            phone5_1.sendMsg();
        },"A").start();

        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }

        new Thread(()->{
            phone5_1.call();
        },"B").start();
    }
}
class Phone5{
//    锁的是Class模板
    public static synchronized void sendMsg(){

        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        System.out.println("发短信");
    }
//    锁的是调用者
    public synchronized void call(){
        System.out.println("打电话");
    }
}

标签:JUC,调用者,synchronized,void,编程,并发,TimeUnit,new,public
From: https://www.cnblogs.com/nhgtx/p/17805974.html

相关文章

  • java 网络编程之传输文件
    需要建两个类,分别作为服务器(接收文件)和客户端(发送文件) 1.服务器类:1package菜鸟教程.网络编程.网络编程之传输文件;23importjava.io.*;4importjava.net.InetAddress;5importjava.net.ServerSocket;6importjava.net.Socket;78/**9*服......
  • java网络编程与多线程
      一、Java 网络编程网络编程是指编写运行在多个设备(计算机)的程序,这些设备都通过网络连接起来。java.net包中J2SE的API包含有类和接口,它们提供低层次的通信细节。你可以直接使用这些类和接口,来专注于解决问题,而不用关注通信细节。java.net包中提供了两种常见的网络......
  • JUC并发编程学习笔记(三)生产者和消费者问题
    生产者和消费者问题synchronized版->wait/notifyjuc版->Lock面试:单例模式、排序算法、生产者和消费者、死锁生产者和消费者问题Synchronized版packageorg.example.pc;publicclassA{publicstaticvoidmain(String[]args){Datedate=newDate();......
  • JUC并发编程学习笔记(二)Lock锁(重点)
    Lock锁(重点)传统的synchronized传统的解决多线程并发导致的一些问题我们会使用synchronized关键字来解决,synchronized的本质就是队列、锁。Lock的实现类有:可重复锁(最常用)、读锁、写锁在创建可重复锁时,可传入boolean类型值来决定该锁是公平锁(先来后到)还是非公平锁(可插队)......
  • Java-并发编程-进阶篇
    在上一篇幅中对并发编程进行了简单介绍:并发与并行,进程与线程,以及并发编程的简单代码但是在企业中往往并不能解决实际问题,例如:1.synchronized关键字在企业开发中会大大降低系统的性能2.当线程被创建并启动以后,它既不是一启动就进入了执行状态,也不是一直处于执行状态。线程对象......
  • JUC并发编程学习笔记(一)认知进程和线程
    进程和线程进程一个程序,如QQ.exe,是程序的集合一个进程往往可以包含多个线程,至少包含一个java默认有两个线程,GC垃圾回收线程和Main线程线程:一个进程中的各个功能java无法真正的开启线程,因为java是运行在虚拟机上的,所以只能通过C++,通过native本地方法调用C++开启线程priva......
  • (四)C#编程基础复习——运算符
    运算符其实就是一个符号,用来告诉编译器执行特定的数学或者逻辑运算。C#中内置了丰富的运算符,大致可以分为以下几类:一、算术运算符算术运算符即完成特定算术运算的符号,例如加、减、乘、除、余等,如下图所示:inta=10;intb=20;Console.WriteLine("a+b={0}",a+b);Console.W......
  • 【转载】CUDA编程学习记录 C++
    参考Yuezero的CUDA编程基础(https://blog.csdn.net/weixin_54338498/article/details/127947551)CUDA编程模型host指代CPU及其内存,包含host程序device指代GPU及其内存,包含device程序经典CUDA程序的执行流程如下:分配host内存,并进行数据初始化;分配device内存,并从host将......
  • (三)C#编程基础复习——数据类型
    C#语言中内置了一些基本的数据类型,数据类型用来指定程序中变量可以存储的数据的类型,C#中的数据类型可以大致分为三类:值类型(Valuetypes);引类型(Referencestypes);指针类型(Pointertypes);一、值类型值类型顾名思义就是有带数值的类型,C#中的值类型有非常多,值类型变量声明后,不......
  • 模拟实现.net中的Task机制:探索异步编程的奥秘
    .net中使用Task可以方便地编写异步程序,为了更好地理解Task及其调度机制,接下来模拟Task的实现,目的是搞清楚:Task是什么Task是如何被调度的基本的Task模拟实现从最基本的Task用法开始Task.Run(Actionaction)这个命令的作用是将action作为一项任务提交给调度器,调度器会安排......