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

最新推荐文章于 2021-03-15 04:35:34 发布
最新推荐文章于 2021-03-15 04:35:34 发布
阅读量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 1364
线程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 242
在并发的环境中，锁机制一个良好的控制同步的方法，使用synchronize关键字对临界资源的锁，在普通的成员方法中添加锁的是调用该方法的对象public synchronized void Sem(){//普通同步的发邮件的方法 System.out.println("发邮件"); }，而在静态方法中使用 则锁的整个类对象（类对象是在class加载的时候进行创建的，每一个类只用有一个）public static synchronized void Sem(){//普通同步的发邮件的方法 System.out
多线程--线程八锁
喝醉的咕咕鸟
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 71
锁的是当前对象this，被锁定后，其他线程都不能进入到当前对象的其他的synchronized方法。 所有的非静态同步方法用的都是同一把锁 -- 实例对象本身 所有的静态同步方法用的也是同一把锁 -- 类对象本身 /* * 题目：判断打印的 "one" or "two" ？ * * 1. 两个普通同步方法，两个线程，标准打印， 打印? //one two * 2. 新增...
多线程8锁
weixin_42198596的博客
01-07 117
标准访问，请问先打印邮件还是短信？ 邮件方法暂停4秒钟，请问先打的邮件还是短信？ 新增一个普通方法hello（），请问先打印邮件还是hello？ 两部手机，请问先打印邮件还是短信？ 两个静态同步方法，同一部手机，请间先打印邮件还是短信？ 两个静态同步方法，2部手机，请问先打印邮件还是短信？ 1个普通同步方法，1个静态同步方法，1部手机，请间先打印邮件还是短信？ 1个普通同步方法，1个静态同步方法，2部手机，请问先打印邮件还是短信？ ...
Java多线程：线程8锁案例分析
HTZW的博客
06-22 491
线程8锁案例分析 通过分析代码，推测打印结果，并运行代码进行验证 1、两个线程调用同一个对象的两个同步方法 被synchronized修饰的方法，锁的对象是方法的调用者。因为两个方法的调用者是同一个，所以两个方法用的是同一个锁，先调用方法的先执行。 public class Demo { public static void main(String[] args) { Number number = new Number(); new Thread(() -&g
多线程锁的分析
qq_22121229的博客
11-16 420
多线程锁的分析 首先我们知道锁主要有两种，悲观锁和乐观锁。对于悲观锁(mutex,spin_lock)，它永远会假定最糟糕的情况，就像我们上面说到的互斥机制，每次我们都假定会有其他的线程和我们竞争资源，因此必须要先拿到锁，之后才放心的进行我们的操作，这就使得争夺锁成为了我们每次操作的第一步。乐观锁(CAS,原子操作)则不同，乐观锁假定在很多情况下，资源都不需要竞争，因此可以直接进行读写，但是如果碰...
人工智能-项目实践-多线程-多线程与高并发.zip
01-04
此外，同步机制是多线程编程中的关键，包括互斥锁（synchronized关键字）、读写锁（ReentrantReadWriteLock）、条件变量（Condition）等，它们确保了共享数据在多线程环境下的安全性。避免死锁和活锁也是多线程编程...
java单线程上锁,Java多线程详解-锁
weixin_35711852的博客
03-15 645
前言最近工作有点忙，周末也一直在996加班，所以没有时间来写博客，今早忙里偷闲来写一下多线程的第二篇。废话不多说，开始这次的主题。复习上一张我们学习了Java多线程的基础知识。回顾一下：1：实现多线程的两种方式，继承Thread类以及实现Runable接口，然后重写里面的run方法即可。2：线程的状态：新建状态，就绪状态，运行状态，阻塞状态，死亡状态。其中最重要的地方，也是难点就是线程的阻塞状态，...
人工智能-项目实践-多线程-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 796
一、简介 所谓线程八锁，其实就是就是线程锁的8种情况，对应于是否加上synchronized，是否加上static等8种常见情况，具体见下面详解。 二、线程8锁 第一种情况: 两个线程调用同一个对象的两个普通同步方法,先打印one还是two? /** * 线程八锁第一种情况: 两个线程调用同一个对象的两个普通同步方法,先打印one还是two? * <p> * 运行结果: ...
线程8锁
weixin_41047933的博客
01-23 717
思路： 线程 操作 共享资源 1）创建资源类，在资源类中定义线程操作方法，根据需要添加同步锁或同步代码块 2）创建线程对象，使用线程对象调用响应的同步方法 对象锁和类锁的定义： 对象锁： 1）对象锁也叫方法锁，是针对一个对象实例的，它只在该对象的某个内存位置声明一个标识该对象是否拥有锁，所有它只会锁住当前的对象，而并不会对其他对象实例的锁产生任何影响，不同对象访问同一个被syn...
Socket通讯-Netty框架实现Java通讯(字符串信息的传输)
热门推荐
半度微凉
09-16 1万+
Netty简介Netty是由JBOSS提供的一个java开源框架。Netty提供异步的、事件驱动的网络应用程序框架和工具，用以快速开发高性能、高可靠性的网络服务器和客户端程序。也就是说，Netty 是一个基于NIO的客户、服务器端编程框架，使用Netty 可以确保你快速和简单的开发出一个网络应用，例如实现了某种协议的客户，服务端应用。
Java多线程同步问题解析-线程同步实例分析
"该资源是2007年版的计算机网络原理自考教材，重点关注的是线程同步的内容。在第三章中，通过一个修改过的线程叫号小程序，展示...通过不断地实践和学习，开发者可以更好地理解和应用这些概念，提升多线程编程的能力。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值