Java多线程之8Lock问题解析

最新推荐文章于 2023-06-01 03:45:00 发布
最新推荐文章于 2023-06-01 03:45:00 发布
阅读量429 收藏
点赞数
分类专栏： Java多线程 文章标签： 8Lock
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_41910694/article/details/90178554
版权

Java多线程之8Lock问题解析

本文目录

1. 8Lock实例：
  1. 标准访问的时候，请问先打印邮件还是短信？
  2. sendEmail方法暂停4秒钟，请问先打印邮件还是短信？
  3. 新增Hello普通方法，请问先打印邮件还是Hello？
  4. 两部手机，请问先打印邮件还是短信？
  5. 两个静态同步方法，同1部手机 ,请问先打印邮件还是短信？
  6. 两个静态同步方法，有2部手机 ,请问先打印邮件还是短信？
  7. 1个静态同步方法，1个普通同步方法，有1部手机 ,请问先打印邮件还是短信？
  8. 1个静态同步方法，1个普通同步方法，有2部手机 ,请问先打印邮件还是短信？
2. 8Lock总结
3. 补充：当前类的Class对象和当前类的实例对象分别是什么?

8Lock实例：

1. 标准访问的时候，请问先打印邮件还是短信？

代码：

//资源类
class Phone{
	public  synchronized void sendEmail() {
		System.out.println("sendEmail----------");
	}
	
	public synchronized void getSMS() {
		System.out.println("----------getSMS");
	}
}
//主方法
public class Lock_8 {

	public static void main(String[] args) {
		Phone p=new Phone();
		
		new Thread(() ->{
			p.sendEmail();
		},"A").start();
		
		new Thread(() ->{
			p.getSMS();;
		},"B").start();
	}
}

结果：
在这里插入图片描述
在这里插入图片描述

解析：

  • 不知道，因为线程谁抢到了谁执行，一般情况下是A执行

2. sendEmail方法暂停4秒钟，请问先打印邮件还是短信？

代码：

//资源类
class Phone{
	public  synchronized void sendEmail() {
		Thread.sleep(4000);
		System.out.println("sendEmail----------");
	}
	
	public synchronized void getSMS() {
		System.out.println("----------getSMS");
	}
}
//主方法
public class Lock_8 {

	public static void main(String[] args) throws Exception {
		Phone p=new Phone();
		
		new Thread(() ->{
			p.sendEmail();
		},"A").start();
		//强制让线程A先执行
		Thread.sleep(200);
		
		new Thread(() ->{
			p.getSMS();;
		},"B").start();
	}
}

结果：
在这里插入图片描述

解析：

  • 4秒后A先执行，紧接着B执行。
  • 因为休眠main线程之前A已经启动了，时间足够A运行，A会锁住资源类的入口（也就是对象）。所以A先执行。

3. 新增Hello普通方法，请问先打印邮件还是Hello？

代码：

//资源类
class Phone{
	public  synchronized void sendEmail() throws Exception {
		TimeUnit.SECONDS.sleep(4);
		System.out.println("sendEmail----------");
	}
	
	public synchronized void getSMS() {
		System.out.println("----------getSMS");
	}
	
	public void sayHello() {
		System.out.println("---hello---");
	}
}
//主方法
public class Lock_8 {

	public static void main(String[] args) throws Exception {
		Phone p=new Phone();
		
		new Thread(() ->{
			try {
				p.sendEmail();
			} catch (Exception e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		},"A").start();
		//强制让线程A先执行
		Thread.sleep(200);
		
		new Thread(() ->{
			p.sayHello();
		},"B").start();
	}
}

结果：

在这里插入图片描述

解析：

  • 先打印hello，虽然sendEmail锁住了资源类的入口（对象），因为sayHello未上锁，所以sayHello方法可以进入资源类。
  • 但是Thread.sleep()锁住了main线程，也就是hello打印出来的延迟时间就是休眠的设定时间。
加个普通方法后发现和同步锁无关

4. 两部手机，请问先打印邮件还是短信？

代码：

//资源类
class Phone{
	public  synchronized void sendEmail() throws Exception {
		TimeUnit.SECONDS.sleep(4);
		System.out.println("sendEmail----------");
	}
	
	public synchronized void getSMS() {
		System.out.println("----------getSMS");
	}
	
	public void sayHello() {
		System.out.println("---hello---");
	}
}
//主方法
public class Lock_8 {
	public static void main(String[] args) throws Exception {
		Phone p1=new Phone();
		Phone p2=new Phone();
		new Thread(() ->{
			try {
				p1.sendEmail();
			} catch (Exception e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		},"A").start();
		//强制让线程A先执行
		Thread.sleep(2000);
		
		new Thread(() ->{
			p2.getSMS();
		},"B").start();
	}
}

结果：

在这里插入图片描述

解析：

  • 先打印SMS，因为锁的是资源类的入口，也就是对象，既然不是同一个对象，那肯定锁不住。并且线程B的执行和main线程的休眠时间相关。
换成两个对象后，不是同一把锁了，情况立刻变化。

5. 两个静态同步方法，同1部手机 ,请问先打印邮件还是短信？

代码：

//资源类
class Phone{
	public static synchronized void sendEmail() throws Exception {
		TimeUnit.SECONDS.sleep(4);
		System.out.println("sendEmail----------");
	}
	
	public static synchronized void getSMS() {
		System.out.println("----------getSMS");
	}
	
	public void sayHello() {
		System.out.println("---hello---");
	}
}
//主方法
public class Lock_8 {

	public static void main(String[] args) throws Exception {
		Phone p=new Phone();
		
		
		new Thread(() ->{
			try {
				p.sendEmail();
			} catch (Exception e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		},"A").start();
		//强制让线程A先执行
		Thread.sleep(5000);
		
		new Thread(() ->{
			p.getSMS();
		},"B").start();
	}
}

结果：

在这里插入图片描述

解析：

  • 先打印sendEmali，然后打印getSMS，因为静态同步锁，锁的是Phone.Class，所以B线程在A线程执行完之前进不去。
  • synchronized实现同步的基础：Java中的每一个对象都可以作为锁。
具体表现为以下3种形式。
1. 对于普通同步方法，锁是当前实例对象。
2. 对于静态同步方法，锁是当前类的Class对象。
3. 对于同步方法块，锁是Synchonized括号里配置的对象。

6. 两个静态同步方法，有2部手机 ,请问先打印邮件还是短信？

代码：

//资源类
class Phone{
	public static synchronized void sendEmail() throws Exception {
		TimeUnit.SECONDS.sleep(4);
		System.out.println("sendEmail----------");
	}
	
	public static synchronized void getSMS() {
		System.out.println("----------getSMS");
	}
	
	public void sayHello() {
		System.out.println("---hello---");
	}
}
//主方法
public class Lock_8 {

	public static void main(String[] args) throws Exception {
		Phone p1=new Phone();
		Phone p2=new Phone();
		
		
		new Thread(() ->{
			try {
				p1.sendEmail();
			} catch (Exception e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		},"A").start();
		//强制让线程A先执行
		Thread.sleep(5000);
		
		new Thread(() ->{
			p2.getSMS();
		},"B").start();
	}
}

结果：

在这里插入图片描述

解析：

  • 看似和5不一样，其实是一回事，虽然两个对象，因为强制A先执行，所以A会锁住资源类，因此先打印sendEmail。

7. 1个静态同步方法，1个普通同步方法，有1部手机 ,请问先打印邮件还是短信？

代码：

//资源类
class Phone{
    public static synchronized void sendEmail() throws Exception {
        TimeUnit.SECONDS.sleep(2);
        System.out.println("sendEmail----------");
    }

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

    public void sayHello() {
        System.out.println("---hello---");
    }
}
//主方法
public class Lock_8 {

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



        new Thread(() ->{
            try {
                p.sendEmail();
            } catch (Exception e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        },"A").start();
        //强制让线程A先执行
        Thread.sleep(1000);

        new Thread(() ->{
            p.getSMS();
        },"B").start();
    }
}

结果：

在这里插入图片描述

解析：

  • static方法锁锁的不是资源类，锁的是类对象，也就是说，不管new了几个，静态同步方法的类对象都是一个；而普通同步方法锁住的是new出来的对象。
  • 所有的静态同步方法用的也是同一把锁——类对象本身，
    这两把锁是两个不同的对象，所以静态同步方法与非静态同步方法之间是不会有竞态条件的。
    但是一旦一个静态同步方法获取锁后，其他的静态同步方法都必须等待该方法释放锁后才能获取锁，
    而不管是否是同一个实例对象。

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

代码：

//资源类
class Phone{
	public static synchronized void sendEmail() throws Exception {
		TimeUnit.SECONDS.sleep(4);
		System.out.println("sendEmail----------");
	}
	
	public synchronized void getSMS() {
		System.out.println("----------getSMS");
	}
	
	public void sayHello() {
		System.out.println("---hello---");
	}
}
//主方法
public class Lock_8 {

	public static void main(String[] args) throws Exception {
		Phone p1=new Phone();
		Phone p2=new Phone();
		
		
		
		new Thread(() ->{
			try {
				p1.sendEmail();
			} catch (Exception e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		},"A").start();
		//强制让线程A先执行
		Thread.sleep(1000);
		
		new Thread(() ->{
			p2.getSMS();
		},"B").start();
	}
}

结果：

在这里插入图片描述

解析：

  • P1锁住的不是资源类，而是类对象。线程1锁的是类对象，线程2锁的是实例对象，虽然看似是一个对象，然而两者不具备竞态条件，因此修改main休眠时间之后就会发现getSMS先执行。

8Lock总结

  1. 一个对象里面如果有多个synchronized方法，某一个时刻内，只要一个线程去调用其中的一个synchronized方法了，其它的线程都只能等待，换句话说，某一个时刻内，只能有唯一一个线程去访问这些synchronized方法
  2. 锁的是当前对象this，被锁定后，其它的线程都不能进入到当前对象的其它的synchronized方法
  3. 加个普通方法后发现和同步锁无关
  4. 换成两个对象后，不是同一把锁了，情况立刻变化。
  5. 都换成静态同步方法后，情况又变化
  6. 所有的非静态同步方法用的都是同一把锁——实例对象本身，也就是说如果一个实例对象的非静态同步方法获取锁后，该实例对象的其他非静态同步方法必须等待获取锁的方法释放锁后才能获取锁，可是别的实例对象的非静态同步方法因为跟该实例对象的非静态同步方法用的是不同的锁，所以毋须等待该实例对象已获取锁的非静态同步方法释放锁就可以获取他们自己的锁。
  7. 所有的静态同步方法用的也是同一把锁——类对象本身，这两把锁是两个不同的对象，所以静态同步方法与非静态同步方法之间是不会有竞态条件的。但是一旦一个静态同步方法获取锁后，其他的静态同步方法都必须等待该方法释放锁后才能获取锁，而不管是同一个实例对象的静态同步方法之间，还是不同的实例对象的静态同步方法之间，只要它们同一个类的实例对象！
  8. 一个静态同步方法 一个普通同步方法，一个非同步方法，那么三者是都不具备竞态条件的。

3. 补充：当前类的Class对象和当前类的实例对象分别是什么?

实例：

  • 简单理解，就是new，就是对类的实例化，创建这个类对应的实际对象，类只是对事物的描述，而实例化就相当于为这个描述新开辟了一块内存，可以改变这块区域里的各种属性（成员变量），当然，也可以实例化多块区域，只是不同的对象而已。

Class：

  • 注意这里C大写了，与类概念区分开，在java里，Class是一个实实在在的类，在包 java.lang 下，有这样一个Class.java文件，它跟我们自己定义的类一样，是一个实实在在的类，Class对象就是这个Class类的实例了。在Java里，所有的类的根源都是Object类，而Class也不例外，它是继承自Object的一个特殊的类，它内部可以记录类的成员、接口等信息，也就是在Java里，Class是一个用来表示类的类。（o(∩_∩)o 有点绕啊，抓住关键一点，Class是一个实实在在的类，可以为它创建实例，也就是本文后面提到的Class对象，也看叫做Class实例）。

java提供了下面几种获取到类的Class对象的方法：

1) 利用对象实例调用getClass()方法获取该对象的Class实例；
2) 使用Class类的静态方法forName(“包名+类名”)，用类的名字获取一个Class实例
3) 运用 类名.class 的方式来获取Class实例；

我们知道java世界是运行在JVM之上的，我们编写的类代码，在经过编译器编译之后，会为每个类生成对应的.class文件，这个就是JVM可以加载执行的字节码。运行时期间，当我们需要实例化任何一个类时，JVM会首先尝试看看在内存中是否有这个类，如果有，那么会直接创建类实例；如果没有，那么就会根据类名去加载这个类，当加载一个类，或者当加载器(class loader)的defineClass()被JVM调用，便会为这个类产生一个Class对象（一个Class类的实例），用来表达这个类，该类的所有实例都共同拥有着这个Class对象，而且是唯一的。

Lumos`
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java线程(八)：锁对象Lock-同步问题更完美的处理方式
m0_70083038的博客
04-28 216
new Thread() { public void run() { output.output(“zhangsan”); }; }.start(); new Thread() { public void run() { output.output(“lisi”); }; }.start(); } } class Outputter1 {..
Java多线程-线程安全问题练习题
01-30
在Java多线程编程中，线程安全问题是非常关键的概念，它涉及到多个线程访问共享资源时可能出现的数据不一致或异常情况。本题主要通过两个练习题来加深对线程安全的理解。 ### 练习题1：新年倒计时 #### 题目描述 ...
Java8-Lock-No.01
weixin_34220179的博客
12-13 111
import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.locks.ReentrantLock; import java.util.stream.IntStream; p...
多线程8锁
weixin_42198596的博客
01-07 115
标准访问，请问先打印邮件还是短信？ 邮件方法暂停4秒钟，请问先打的邮件还是短信？ 新增一个普通方法hello（），请问先打印邮件还是hello？ 两部手机，请问先打印邮件还是短信？ 两个静态同步方法，同一部手机，请间先打印邮件还是短信？ 两个静态同步方法，2部手机，请问先打印邮件还是短信？ 1个普通同步方法，1个静态同步方法，1部手机，请间先打印邮件还是短信？ 1个普通同步方法，1个静态同步方法，2部手机，请问先打印邮件还是短信？ ...
java基础（8）-----Lock and synchronized
yuezisonghao的博客
11-22 255
     synchronized可以实现同步，为什么我们还需要Lock呢？jdk5之后增加了一个新的包java.util.concurrent，java在这里提供了新的并发编程的工具，其中下面的Locks包都是关于Lock这一部分的，如图： 1.和synchronized比较      synchronized可以修饰变量、代码块、方法，对象中有这个关键字的代码被访问的时候，线程就可以获...
java“锁事“ 之8lock
一个有信仰的技术人
06-24 276
java锁的八种示例
Java多线程-避免同步机制带来的死锁问题及用Lock锁解决线程安全问题
最新发布
02-02
### Java多线程-避免同步机制带来的死锁问题及用Lock锁解决线程安全问题 #### 死锁 ##### 1. 说明 在多线程编程中，死锁是一种常见的问题，指的是两个或多个线程在执行过程中，因为竞争资源而造成的一种相互等待...
Java多线程锁机制相关原理实例解析
08-18
Java多线程锁机制相关原理实例解析 Java多线程锁机制是指在Java编程语言中，用于解决多线程并发访问共享资源的机制。该机制主要通过锁机制来实现线程同步，确保多线程之间的安全访问共享资源。 锁机制是Java多线程...
java多线程实现大批量数据导入源码
09-29
本项目以"java多线程实现大批量数据导入源码"为题，旨在通过多线程策略将大量数据切分，并进行并行处理，以提高数据处理速度。 首先，我们需要理解Java中的线程机制。Java通过`Thread`类来创建和管理线程。每个线程...
java多线程面试题59题集合
03-15
以下是对Java多线程面试题59题集合中可能涉及的一些关键知识点的详细解析。 1. **线程的创建方式** - 继承Thread类：创建一个新的类，该类继承自Thread类，并重写其run()方法。 - 实现Runnable接口：创建一个实现...
Java8-Lock-No.06
weixin_34402090的博客
12-13 54
import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.locks.StampedLock; public class Lock6 { private stat...
Java8-Lock-No.03
weixin_34262482的博客
12-13 85
import java.util.HashMap; import java.util.Map; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.locks.Read...
Java8-Lock-No.02
weixin_34268169的博客
12-13 82
import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.locks.ReentrantLock; public class Lock2 { public st...
java8多线程锁_JUC全家桶 | Java多线程八锁问题
weixin_29696799的博客
02-13 78
问题1问：如下代码，两个方法谁先输出？答：先输出 call，后 sendMsg原因：被 synchronized 修饰的方法，锁的对象是方法调用者，所以说这里两个方法调用的对象是同一个，先调用的先执行！public class Lock1 {public static void main(String[] args) throws InterruptedException {Phone phone...
java8的锁
MXqihang的博客
04-17 728
java8锁 文章目录java8锁CAS算法 Compare And Swap 比较与交换自旋锁 VS 适应性自旋锁自旋锁unsafe自适应自旋锁无锁->偏向锁->轻量锁->重量锁无锁偏向锁轻量级锁重量级锁公平锁、非公平锁公平锁可重入锁、非可重入锁可重入锁非可重入锁共享锁、独享锁底部 同步资源上锁 锁住 ： 悲观锁 不锁住： 乐观锁 锁同步资源，线程状态 阻赛 不阻赛： 自旋锁、适应性自旋锁 多线程竞争同步资源的流行细节 不锁资源，多线程中只有一个修改成功，其他线程重试：无锁
Java 8 - juc - Lock和ReentrantLock
学无止境
06-01 142
【代码】Java 8 - juc - Lock和ReentrantLock。
Java8 Lock锁详解(AQS，CAS)
Leetp
07-01 3338
什么是Lock锁？ Lock锁提供了的比synchronized关键字更加灵活的锁操作，是代码层面的锁操作。 为什么要使用Lock锁？ Lock锁和synchronized关键字的对比 类型 synchronized关键字 Lock锁 获取锁 无超时时间，未获取到则阻塞等待（占用cpu资源），且无法被中断 非阻塞，可以被中断，未获取到则排队，中断，可以自定义超时时间 共享锁 不支持 读写锁ReadWriteLock支持 释放锁 必须在当前代码块中，因为synchronized是以{
java8-StampedLock
Java_feng的博客
08-02 358
import java.util.concurrent.locks.StampedLock;public class Test { private String str = "init"; private final StampedLock stampedLock = new StampedLock(); public static void main(String[] arg
Java多线程面试题答案解析与Lock接口优势
本文主要探讨了Java多线程面试中常见的15个问题及其答案。首先，对于如何确保线程T2在T1执行完后再执行，然后T3在T2之后执行的问题，答案是使用`join()`方法。`join()`方法的作用是使得调用它的线程等待被调用的线程...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值