多线程学习-线程八锁的分析

最新推荐文章于 2022-07-12 14:03:20 发布
最新推荐文章于 2022-07-12 14:03:20 发布
阅读量233 收藏
点赞数
分类专栏： java 文章标签： 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/taoweidong1/article/details/91474215
版权

线程八锁的关键：

  1. 非静态方法的锁默认为 this, 静态方法的锁为 对应的 Class 实例
  2. 某一个时刻内，只能有一个线程持有锁，无论几个方法。

分析

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

锁的是当前对象this，被锁定后，其它的线程都不能进入到当前对象的其它的synchronized方法。

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

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

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

package com.juc;
/**
 * 题目：判断输出结果，分析多线程锁的概念</br>
 * 1. 两个普通同步方法，两个线程，标准打印， 打印? //one two
 */
public class TestThread8Monitor {
	public static void main(String[] args) {
		Number number = new Number();
		new Thread(new Runnable() {
			@Override
			public void run() {
				number.getOne();
			}
		}).start();

		new Thread(new Runnable() {
			@Override
			public void run() {
				number.getTwo();
			}
		}).start();
	}
}

class Number {
	public synchronized void getOne() {
		System.out.println("one");
	}
	public synchronized void getTwo() {
		System.out.println("two");
	}
}

输出结果
在这里插入图片描述

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

package com.juc;
/**
 * 题目：判断输出结果，分析多线程锁的概念</br>
 * 1. 两个普通同步方法，两个线程，标准打印， 打印? //one two
 */
public class TestThread8Monitor {
	public static void main(String[] args) {
		Number number = new Number();
		new Thread(new Runnable() {
			@Override
			public void run() {
				number.getOne();
			}
		}).start();

		new Thread(new Runnable() {
			@Override
			public void run() {
				number.getTwo();
			}
		}).start();
	}
}

class Number {
	public synchronized void getOne() {
	    try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
			e.printStackTrace();
        }
		System.out.println("one");
	}
	public synchronized void getTwo() {
		System.out.println("two");
	}
}

输出结果
在这里插入图片描述

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

package com.juc;

/**
 * 题目：判断输出结果，分析多线程锁的概念</br>
 * 1. 两个普通同步方法，两个线程，标准打印， 打印? //one two
 */
public class TestThread8Monitor {
	public static void main(String[] args) {
		Number number = new Number();
		new Thread(new Runnable() {
			@Override
			public void run() {
				number.getOne();
			}
		}).start();

		new Thread(new Runnable() {
			@Override
			public void run() {
				number.getTwo();
			}
		}).start();

		new Thread(new Runnable() {
			@Override
			public void run() {
				number.getThree();
			}
		}).start();
	}
}

class Number {
	public synchronized void getOne() {
		try {
			Thread.sleep(3000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out.println("one");
	}

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

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

输出结果
在这里插入图片描述

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

package com.juc;

/**
 * 题目：判断输出结果，分析多线程锁的概念</br>
 * 1. 两个普通同步方法，两个线程，标准打印， 打印? //one two
 * 2. 新增 Thread.sleep() 给 getOne() ,打印? //one two
 * 3. 新增普通方法 getThree() , 打印? //three one two
 * 4. 两个普通同步方法，两个 Number 对象，打印? //two one
 */
public class TestThread8Monitor {

	public static void main(String[] args) {
		Number number = new Number();
		Number number2 = new Number();

		new Thread(new Runnable() {
			@Override
			public void run() {
				number.getOne();
			}
		}).start();

		new Thread(new Runnable() {
			@Override
			public void run() {
				number2.getTwo();
			}
		}).start();
	}
}

class Number {

	public synchronized void getOne() {
		try {
			Thread.sleep(3000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out.println("one");
	}

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

}

输出结果
在这里插入图片描述

修改 getOne() 为静态同步方法，打印? //two one

package com.juc;
/**
 * 题目：判断输出结果，分析多线程锁的概念</br>
 * 1. 两个普通同步方法，两个线程，标准打印， 打印? //one two
 * 2. 新增 Thread.sleep() 给 getOne() ,打印? //one two
 * 3. 新增普通方法 getThree() , 打印? //three one two
 * 4. 两个普通同步方法，两个 Number 对象，打印? //two one
 * 5. 修改 getOne() 为静态同步方法，打印? //two one
 */
public class TestThread8Monitor {

	public static void main(String[] args) {
		Number number = new Number();
		new Thread(new Runnable() {
			@Override
			public void run() {
				number.getOne();
			}
		}).start();

		new Thread(new Runnable() {
			@Override
			public void run() {
				number.getTwo();
			}
		}).start();

	}
}

class Number {

	public static synchronized void getOne() {
		try {
			Thread.sleep(3000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out.println("one");
	}

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

输出结果
在这里插入图片描述

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

package com.juc;

/**
 * 题目：判断输出结果，分析多线程锁的概念</br>
 * 1. 两个普通同步方法，两个线程，标准打印， 打印? //one two
 * 2. 新增 Thread.sleep() 给 getOne() ,打印? //one two
 * 3. 新增普通方法 getThree() , 打印? //three one two
 * 4. 两个普通同步方法，两个 Number 对象，打印? //two one
 * 5. 修改 getOne() 为静态同步方法，打印? //two one
 * 6. 修改两个方法均为静态同步方法，一个 Number 对象? //one two
 */
public class TestThread8Monitor {

	public static void main(String[] args) {
		Number number = new Number();

		new Thread(new Runnable() {
			@Override
			public void run() {
				number.getOne();
			}
		}).start();

		new Thread(new Runnable() {
			@Override
			public void run() {
				number.getTwo();
			}
		}).start();
	}
}

class Number {
	public static synchronized void getOne() {
		try {
			Thread.sleep(3000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out.println("one");
	}

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

}

输出结果
在这里插入图片描述

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

package com.juc;

/**
 * 题目：判断输出结果，分析多线程锁的概念</br>
 * 1. 两个普通同步方法，两个线程，标准打印， 打印? //one two
 * 2. 新增 Thread.sleep() 给 getOne() ,打印? //one two
 * 3. 新增普通方法 getThree() , 打印? //three one two
 * 4. 两个普通同步方法，两个 Number 对象，打印? //two one
 * 5. 修改 getOne() 为静态同步方法，打印? //two one
 * 6. 修改两个方法均为静态同步方法，一个 Number 对象? //one two
 * 7. 一个静态同步方法，一个非静态同步方法，两个 Number 对象? //two one
 */
public class TestThread8Monitor {

	public static void main(String[] args) {
		Number number = new Number();
		Number number2 = new Number();
		
		new Thread(new Runnable() {
			@Override
			public void run() {
				number.getOne();
			}
		}).start();

		new Thread(new Runnable() {
			@Override
			public void run() {
				number2.getTwo();
			}
		}).start();
	}
}

class Number {

	public static synchronized void getOne() {
		try {
			Thread.sleep(3000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out.println("one");
	}

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

}

输出结果

在这里插入图片描述

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

package com.juc;

/**
 * 题目：判断输出结果，分析多线程锁的概念</br>
 * 1. 两个普通同步方法，两个线程，标准打印， 打印? //one two
 * 2. 新增 Thread.sleep() 给 getOne() ,打印? //one two
 * 3. 新增普通方法 getThree() , 打印? //three one two
 * 4. 两个普通同步方法，两个 Number 对象，打印? //two one
 * 5. 修改 getOne() 为静态同步方法，打印? //two one
 * 6. 修改两个方法均为静态同步方法，一个 Number 对象? //one two
 * 7. 一个静态同步方法，一个非静态同步方法，两个 Number 对象? //two one
 * 8. 两个静态同步方法，两个 Number 对象? //one two
 */
public class TestThread8Monitor {
	public static void main(String[] args) {
		Number number = new Number();
		Number number2 = new Number();

		new Thread(new Runnable() {
			@Override
			public void run() {
				number.getOne();
			}
		}).start();

		new Thread(new Runnable() {
			@Override
			public void run() {
				number2.getTwo();
			}
		}).start();
	}
}

class Number {

	public static synchronized void getOne() {
		try {
			Thread.sleep(3000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out.println("one");
	}

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

输出结果

在这里插入图片描述

Taowiedong
关注
专栏目录
线程8锁（详细）
cookies___的博客
05-13 1365
线程8锁，超详细。 1.两个线程调用同一个对象的两个同步方法 结果是：one two 分析：第一个线程调用了getOne方法，获得了number对象的互斥锁，第二个线程等待第一个线程的getOne执行 完毕后，再执行getTow方法 2. 结果： 休眠1秒钟 后 one two 分析：线程1的Thread.sleep不释放互斥锁 3.新增一个线程调用新增的一个普通方法 结果是：three 休眠1秒 one two 分析：没有synchronized修饰的方法，线程调用时是和锁无关的 4.两个线程调用两个
java单线程上锁,Java多线程详解-锁
weixin_35711852的博客
03-15 646
前言最近工作有点忙，周末也一直在996加班，所以没有时间来写博客，今早忙里偷闲来写一下多线程的第二篇。废话不多说，开始这次的主题。复习上一张我们学习了Java多线程的基础知识。回顾一下：1：实现多线程的两种方式，继承Thread类以及实现Runable接口，然后重写里面的run方法即可。2：线程的状态：新建状态，就绪状态，运行状态，阻塞状态，死亡状态。其中最重要的地方，也是难点就是线程的阻塞状态，...
多线程--线程八锁
喝醉的咕咕鸟
01-30 241
线程八锁:理解锁的关键。 案例分析： 1 标准访问，先打印吃鸡还是LOL 2 新增Thread.sleep(4000),先打印吃鸡还是LOL class Game{ public synchronized void getChicken() throws Exception { //TimeUnit.SECONDS.sleep(4); 第二种情况时候需要放...
线程八锁
dizan4060的博客
08-26 72
锁的是当前对象this，被锁定后，其他线程都不能进入到当前对象的其他的synchronized方法。 所有的非静态同步方法用的都是同一把锁 -- 实例对象本身 所有的静态同步方法用的也是同一把锁 -- 类对象本身 /* * 题目：判断打印的 "one" or "two" ？ * * 1. 两个普通同步方法，两个线程，标准打印， 打印? //one two * 2. 新增...
多线程8锁
weixin_42198596的博客
01-07 118
标准访问，请问先打印邮件还是短信？ 邮件方法暂停4秒钟，请问先打的邮件还是短信？ 新增一个普通方法hello（），请问先打印邮件还是hello？ 两部手机，请问先打印邮件还是短信？ 两个静态同步方法，同一部手机，请间先打印邮件还是短信？ 两个静态同步方法，2部手机，请问先打印邮件还是短信？ 1个普通同步方法，1个静态同步方法，1部手机，请间先打印邮件还是短信？ 1个普通同步方法，1个静态同步方法，2部手机，请问先打印邮件还是短信？ ...
Java多线程：线程8锁案例分析
HTZW的博客
06-22 494
线程8锁案例分析 通过分析代码，推测打印结果，并运行代码进行验证 1、两个线程调用同一个对象的两个同步方法 被synchronized修饰的方法，锁的对象是方法的调用者。因为两个方法的调用者是同一个，所以两个方法用的是同一个锁，先调用方法的先执行。 public class Demo { public static void main(String[] args) { Number number = new Number(); new Thread(() -&g
人工智能-项目实践-多线程-多线程与高并发.zip
01-04
此外，同步机制是多线程编程中的关键，包括互斥锁（synchronized关键字）、读写锁（ReentrantReadWriteLock）、条件变量（Condition）等，它们确保了共享数据在多线程环境下的安全性。避免死锁和活锁也是多线程编程...
人工智能-项目实践-多线程-Java多线程高并发实例.zip
最新发布
01-04
通过分析和运行这些代码，你将能够更深入地理解Java多线程在高并发场景下的实际运用，从而在你的人工智能项目中实现更高效、更稳定的数据处理。 总之，这个项目实例旨在帮助开发者掌握Java多线程技术，提升处理高...
超级列表框多线程源码-易语言
06-12
通过这个“超级列表框多线程源码”，开发者不仅可以学习到易语言的多线程编程，还能深入理解如何在实际项目中应用这些技术，提升软件的性能和用户体验。在学习过程中，分析源码，理解每个函数和命令的作用，然后尝试...
借助乐玩图色脚本多线程例子-易语言
06-12
通过阅读和分析这个源码，我们可以学习到如何在易语言中有效地利用多线程，以及如何将图形处理与多线程结合。 总结来说，这个例子展示了易语言中如何利用第三方库实现多线程编程，以及如何将这种技术应用到图形处理...
java多线程 线程八锁
qq_38718211的博客
01-18 340
package com.java.juc;/** * 题目：判断打印 "one" or "two" *  * 1.两个普通同步方法，两个线程 ，标准打印，打印？// one two * 2.新增Thread.sleep(3000) 给getOne() 打印？ // 3s 后打印 one two * 3.新增普通方法 getThreee 打印？// 先打印three 三秒后打印 one two *
并发编程学习之线程8锁
weixiaohuai的博客
02-26 799
一、简介 所谓线程八锁，其实就是就是线程锁的8种情况，对应于是否加上synchronized，是否加上static等8种常见情况，具体见下面详解。 二、线程8锁 第一种情况: 两个线程调用同一个对象的两个普通同步方法,先打印one还是two? /** * 线程八锁第一种情况: 两个线程调用同一个对象的两个普通同步方法,先打印one还是two? * <p> * 运行结果: ...
线程8锁
weixin_41047933的博客
01-23 718
思路： 线程 操作 共享资源 1）创建资源类，在资源类中定义线程操作方法，根据需要添加同步锁或同步代码块 2）创建线程对象，使用线程对象调用响应的同步方法 对象锁和类锁的定义： 对象锁： 1）对象锁也叫方法锁，是针对一个对象实例的，它只在该对象的某个内存位置声明一个标识该对象是否拥有锁，所有它只会锁住当前的对象，而并不会对其他对象实例的锁产生任何影响，不同对象访问同一个被syn...
线程的8锁
wxd_1024的博客
12-25 186
/** * 1.两个普通同步方法，两个线程 ，标准打印，打印？// one two * 2.新增Thread.sleep(3000) 给getOne() 打印？ // 3s后打印 one two * 3.新增普通方法 getThreee 打印？// 先打印three 3s后打印 one two * 4.两个普通同步方法，两个number对象，打印？ // two 3s后打印 one *...
【面试：并发篇12：多线程：线程八锁】
m0_71229547的博客
07-12 199
如果有任何问题请指出，感谢。线程八锁 其实就是考察 synchronized 锁住的是哪个对象 结果这个很好理解 两个锁的监听器都是 Number的对象n1，不过结果为什么有21 因为虽然可能性很小 但依然有可能先运行b线程 结果解释如果a b线程的监听器都是 n1对象，所以如果a线程执行 那么就会是先等1s 再12，如果是b线程先执行 就会是2等1s再1 结果解释因为c线程没有加锁，ab线程加锁且监听器都是n1，又因为 线程a等待1s，所以 要么b线程先执行要么c先执行，所以答案就是上述结果 结果解释因为
Java多线程同步问题解析-线程同步实例分析
"该资源是2007年版的计算机网络原理自考教材，重点关注的是线程同步的内容。在第三章中，通过一个修改过的线程叫号小程序，展示...通过不断地实践和学习，开发者可以更好地理解和应用这些概念，提升多线程编程的能力。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值