线程八锁详解

最新推荐文章于 2024-01-22 14:18:47 发布
最新推荐文章于 2024-01-22 14:18:47 发布
阅读量881 收藏 6
点赞数 1
分类专栏： 并发编程 文章标签： 多线程 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43521756/article/details/107401896
版权
线程八锁得到的结论：
  1. 非静态方法的锁默认为 this, 静态方法的锁为 对应的 Class 实例
  2. 某一个时刻内，只能有一个线程持有锁，无论几个方法。

论证过程：

1、八锁案例：判断打印的 “one” or “two”
  1. 两个普通同步方法，两个线程，标准打印， 打印? //one two
public class TestThread8Monitor {
	
	public static void main(String[] args) {
		Number number1 = new Number();
		
		new Thread(new Runnable() {
			@Override
			public void run() {
				number1.getOne();
			} 
		},"A").start();
		
		new Thread(new Runnable() {
			@Override
			public void run() {
				number1.getTwo();
			}
		},"B").start();	
	}

}

class Number{
	public synchronized void getOne(){
		System.out.println("one");
	}
	
	public synchronized void getTwo(){
		System.out.println("two");
	}
	
}
  1. 新增 Thread.sleep() 给 getOne() ,打印? //one two
public class TestThread8Monitor {
	
	public static void main(String[] args) {
		Number number1 = new Number();
		
		new Thread(new Runnable() {
			@Override
			public void run() {
				number1.getOne();
			} 
		},"A").start();
		
		new Thread(new Runnable() {
			@Override
			public void run() {
				number1.getTwo();
			}
		},"B").start();	
	}

}

class Number{
	public synchronized void getOne(){
        
		try {
			Thread.sleep(3000);
		} catch (InterruptedException e) {}
		
		System.out.println("one");
	}
	
	public synchronized void getTwo(){
		System.out.println("two");
	}
	
}
  1. 新增普通方法 getThree() , 打印? //three one two
public class TestThread8Monitor {
	
	public static void main(String[] args) {
		Number number1 = new Number();
		
		new Thread(new Runnable() {
			@Override
			public void run() {
				number1.getOne();
			} 
		},"A").start();
		
		new Thread(new Runnable() {
			@Override
			public void run() {
				number1.getTwo();
			}
		},"B").start();	
        
        new Thread(new Runnable() {
			@Override
			public void run() {
				number1.getThree();
			}
		},"C").start();	
	}

}

class Number{
	public synchronized void getOne(){
        
		try {
			Thread.sleep(3000);
		} catch (InterruptedException e) {}
		
		System.out.println("one");
	}
	
	public synchronized void getTwo(){
		System.out.println("two");
	}
    
    public void getThree(){
        System.out.println("three")
    }
	
}
  1. 两个普通同步方法，两个 Number 对象，打印? //two one
public class TestThread8Monitor {
	
	public static void main(String[] args) {
		Number number1 = new Number();
        Number number2 = new Number();
		
		new Thread(new Runnable() {
			@Override
			public void run() {
				number1.getOne();
			} 
		},"A").start();
		
		new Thread(new Runnable() {
			@Override
			public void run() {
				number2.getTwo();
			}
		},"B").start();	
     
	}

}

class Number{
	public synchronized void getOne(){
        
		try {
			Thread.sleep(3000);
		} catch (InterruptedException e) {}
		
		System.out.println("one");
	}
	
	public synchronized void getTwo(){
		System.out.println("two");
	}
	
}
  1. 修改 getOne() 为静态同步方法，一个 Number 对象，打印? //two one
public class TestThread8Monitor {
	
	public static void main(String[] args) {
		Number number1 = new Number();
		
		new Thread(new Runnable() {
			@Override
			public void run() {
				number1.getOne();
			} 
		},"A").start();
		
		new Thread(new Runnable() {
			@Override
			public void run() {
				number1.getTwo();
			}
		},"B").start();	
     
	}

}

class Number{
	public static synchronized void getOne(){
        
		try {
			Thread.sleep(3000);
		} catch (InterruptedException e) {}
		
		System.out.println("one");
	}
	
	public synchronized void getTwo(){
		System.out.println("two");
	}
	
}
  1. 修改两个方法均为静态同步方法，一个 Number 对象? //one two
public class TestThread8Monitor {
	
	public static void main(String[] args) {
		Number number1 = new Number();
		
		new Thread(new Runnable() {
			@Override
			public void run() {
				number1.getOne();
			} 
		},"A").start();
		
		new Thread(new Runnable() {
			@Override
			public void run() {
				number1.getTwo();
			}
		},"B").start();	
     
	}

}

class Number{
	public static synchronized void getOne(){
        
		try {
			Thread.sleep(3000);
		} catch (InterruptedException e) {}
		
		System.out.println("one");
	}
	
	public static synchronized void getTwo(){
		System.out.println("two");
	}
	
}
  1. 一个静态同步方法，一个非静态同步方法，两个 Number 对象? //two one
public class TestThread8Monitor {
	
	public static void main(String[] args) {
		Number number1 = new Number();
        Number number2 = new Number();
		
		new Thread(new Runnable() {
			@Override
			public void run() {
				number1.getOne();
			} 
		},"A").start();
		
		new Thread(new Runnable() {
			@Override
			public void run() {
				number2.getTwo();
			}
		},"B").start();	
     
	}

}

class Number{
	public static synchronized void getOne(){
        
		try {
			Thread.sleep(3000);
		} catch (InterruptedException e) {}
		
		System.out.println("one");
	}
	
	public synchronized void getTwo(){
		System.out.println("two");
	}
	
}
  1. 两个静态同步方法，两个 Number 对象? //one two
public class TestThread8Monitor {
	
	public static void main(String[] args) {
		Number number1 = new Number();
        Number number2 = new Number();
		
		new Thread(new Runnable() {
			@Override
			public void run() {
				number1.getOne();
			} 
		},"A").start();
		
		new Thread(new Runnable() {
			@Override
			public void run() {
				number2.getTwo();
			}
		},"B").start();	
     
	}

}

class Number{
	public static synchronized void getOne(){
        
		try {
			Thread.sleep(3000);
		} catch (InterruptedException e) {}
		
		System.out.println("one");
	}
	
	public static synchronized void getTwo(){
		System.out.println("two");
	}
	
}
2、分析：

  1. 两个普通同步方法，两个线程，标准打印， 打印? //one two

  2. 新增 Thread.sleep() 给 getOne() ,打印? //one two

  3. 新增普通方法 getThree() , 打印? //three one two

  4. 两个普通同步方法，两个 Number 对象，打印? //two one

  5. 修改 getOne() 为静态同步方法，一个 Number 对象，打印? //two one

  6. 修改两个方法均为静态同步方法，一个 Number 对象? //one two

  7. 一个静态同步方法，一个非静态同步方法，两个 Number 对象? //two one

  8. 两个静态同步方法，两个 Number 对象? //one two

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

所有的非静态同步方法用的都是同一把锁——实例对象本身，也就是说如果一个实例对象的非静态同步方法获取锁后，该实例对象的其他非静态同步方法必须等待获取锁的方法释放锁后才能获取锁，可是别的实例对象的非静态同步方法因为跟该实例对象的非静态同步方法用的是不同的锁，所以毋须等待该实例对象已获取锁的非静态同步方法释放锁就可以获取他们自己的锁。

1 、2 和 3 对比：加个普通方法后发现和同步锁无关

2 和 4 对比：换成两个对象后，不是同一把锁了，情况立刻变化。 锁的是当前对象this，被锁定后，其它的线程都不能进入到当前对象的其它的 synchronized方法。

5 和 6 对比：都换成静态同步方法后，情况又变化

5 和 7 分析对比：情况没有发生改变，说明静态同步方法和非静态同步方法并不是同一把锁。

6 和 8 分析对比：所有的静态同步方法用的也是同一把锁——类对象本身（Object.class），这两把锁是两个不同的对 象，所以静态同步方法与非静态同步方法之间是不会有竞态条件的。但是一旦一个 静态同步方法获取锁后，其他的静态同步方法都必须等待该方法释放锁后才能获取 锁，而不管是同一个实例对象的静态同步方法之间，还是不同的实例对象的静态同 步方法之间，只要它们同一个类的实例对象！

小污鲨
关注
  • 1
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
线程8锁（详细）
cookies___的博客
05-13 1335
线程8锁，超详细。 1.两个线程调用同一个对象的两个同步方法 结果是：one two 分析：第一个线程调用了getOne方法，获得了number对象的互斥锁，第二个线程等待第一个线程的getOne执行 完毕后，再执行getTow方法 2. 结果： 休眠1秒钟 后 one two 分析：线程1的Thread.sleep不释放互斥锁 3.新增一个线程调用新增的一个普通方法 结果是：three 休眠1秒 one two 分析：没有synchronized修饰的方法，线程调用时是和锁无关的 4.两个线程调用两个
线程八锁问题超简单理解
weixin_45953000的博客
11-15 231
在并发的环境中，锁机制一个良好的控制同步的方法，使用synchronize关键字对临界资源的锁，在普通的成员方法中添加锁的是调用该方法的对象public synchronized void Sem(){//普通同步的发邮件的方法 System.out.println("发邮件"); }，而在静态方法中使用 则锁的整个类对象（类对象是在class加载的时候进行创建的，每一个类只用有一个）public static synchronized void Sem(){//普通同步的发邮件的方法 System.out
【字节一面】线程八锁
激流丶的博客
07-04 512
线程八锁是指在多线程环境下，使用synchronized关键字对代码进行同步时，可能出现的八种不同的情况。 线程八锁。也是常见的面试题，**主要是针对锁对象的提问。**
线程八锁
The_Best_Hacker的博客
08-16 222
【问题一】 class Number{ public synchronized void a() { System.out.println(1); } public synchronized void b() { System.out.println(2); } } public static void main(String[]...
Java并发之线程八锁
fyphome
01-30 1682
一、引入 先了解什么是synchronized 不加 synchronzied 的方法就好比不遵守规则的人，不去老实排队（好比翻窗户进去的），记住一点，synchronized不是锁住了方法，而是锁住了使用了该方法的类对象或者对象实例，如： 1. 锁住对象实例： class Test{ public synchronized void test() { } } //等价于 class Test{ public void test() { synchronized(th
Java 线程八锁
最新发布
WaaTong的博客
01-22 380
关键字时的八种不同的锁现象，也被称为"著名的八个锁"。这主要是通过对静态方法、非静态方法、静态变量和非静态变量的组合使用。关键字来产生不同的效果。"线程八锁"通常是指在Java中使用。
python线程中同步锁详解
09-20
Python线程中的同步锁是确保多线程程序正确运行的关键工具。它们主要用于解决在多线程环境下访问共享资源时可能出现的竞态条件和死锁问题。以下是对标题和描述中涉及知识点的详细解释： 1. **Lock（互斥锁）** - *...
Java多线程 ReentrantLock互斥锁详解
08-25
Java多线程ReentrantLock互斥锁详解 ReentrantLock是Java多线程编程中的一种锁机制，它可以实现线程之间的同步访问资源。ReentrantLock的主要特点是可以重入，即一个线程可以多次获得锁，而不需要释放锁。这种机制...
java锁详解.pdf
12-31
Java 锁详解 Java 锁是 Java 并发编程中的一种基本机制，用于确保线程安全和避免竞争条件。Java 锁可以分为两大类：synchronized 锁和 ReentrantLock 锁。 一、Synchronized 锁 1. 锁的原理：synchronized 锁是...
java 多线程-锁详解及示例代码
09-01
Java 多线程编程中，锁机制是保证并发安全的关键技术。本文主要讲解了Java中锁的基本概念、使用方式以及示例代码，旨在帮助开发者理解如何在多线程环境下实现线程安全。 首先，Java从5版本开始引入了`java.util....
八锁现象——synchronized关键字实战详解
欢迎。
05-24 1439
synchronized关键字到底锁的是谁？
并发编程学习之线程8锁
weixiaohuai的博客
02-26 752
一、简介 所谓线程八锁，其实就是就是线程锁的8种情况，对应于是否加上synchronized，是否加上static等8种常见情况，具体见下面详解。 二、线程8锁 第一种情况: 两个线程调用同一个对象的两个普通同步方法,先打印one还是two? /** * 线程八锁第一种情况: 两个线程调用同一个对象的两个普通同步方法,先打印one还是two? * <p> * 运行结果: ...
11.线程八锁
DevOps海洋的渔夫@专栏
03-01 374
11.线程八锁线程八锁•一个对象里面如果有多个synchronized方法，某一个时刻内，只要一个线程去调用其中的一个synchronized方法了，其它的线程都只能等待，换句话说，某一...
java并发编程笔记3----详解线程八锁
baidu_41860619的博客
04-20 617
原课程B站地址：全面深入学习java并发编程，中级程序员进阶必会 基础概念 临界区：一段代码块内如果对共享资源的多线程读写操作，称这段代码块为临界区 竞态条件：多个线程在临界区内执行，由于代码的执行序列不同而导致结果无法预测，称之为发生了竞态条件 为了避免临界区内竞态条件发生，有两种主要手段，阻塞式(采用synchronized,lock)和非阻塞式(原子变量) 而此篇介绍的线程八锁指的是使用sy...
synchronized介绍&线程八锁
qq_49567286的博客
02-24 205
synchronized基本叫啥以及线程八锁情况
线程8锁问题
prefect_start的博客
03-17 234
1、线程8锁问题 1.1、代码 /* * * 资源类 */ class Resource { public static synchronized void sendEmail() { try { TimeUnit.SECONDS.sleep(3); System.out.println("*******sendEmail"); } catch (InterruptedException e) {
线程八锁问题
小鲁蛋的博客
02-03 345
考察内容：synchronized 锁住的是哪个对象。
掌握多线程编程：详解线程结构与互斥锁应用
4. **同步对象编程**：这部分内容着重讲解了如何通过同步机制（如互斥锁）来控制多线程环境中的并发访问。互斥锁（Mutex）是关键的同步工具，它提供了对共享资源的独占访问，防止多个线程同时修改同一数据，从而避免...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值