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