【Java并发编程的艺术学习】第二章摘要补全

最新推荐文章于 2024-06-13 08:37:22 发布

一日三餐384

最新推荐文章于 2024-06-13 08:37:22 发布

阅读量992

点赞数 26

文章标签： java 学习 jvm

本文链接：https://blog.csdn.net/weixin_62647396/article/details/135154286

版权

1.并发编程

多线程情况下，一个线程需要读取到其他线程写后内容再开始操作。

2.如何保证写后读

2.1加锁

当前线程对资源进行加锁，在此时其他线程相对该资源操作的话是无法上锁的，所以无法对该资源进行任何操作。

在该线程写完之前不可以释放锁

如果一个方法加锁，那么不管什么线程想拷贝该方法都要事先对该方法加锁。

如果想进行加锁的话需要对读和写操作同时进行加锁，分开加锁的话可能没有执行完毕时间片就到了，这样是没有任何意义的。

public class Test {
	public static int a;
	public static void main(String[] args) throws InterruptedException {
		Thread t1=new Thread() {
			public void run() {
				getA();
			}
		};
		t1.start();
		t1.join();
	}
	
	
	public synchronized static int getA() {
		return a; //读
	}
	public synchronized static void setA(int x) {
		a = x; //写
	}
	public synchronized static void m1(int a) {
		a++; //int k=a+1； a=k； 读+写
		
	}
	
}

2.2不加锁的方式：先比较并且交换（CAS）

2.1volatile的应用

1.volatile保证可见性，什么是可见性

可见性是当一个线程修改一个共享变量，另一个线程能读到这个修改的值。

2.volatile能保证一定准确吗？

不一定。volatile只能保证任意时刻读取

比如有两个线程，线程1在t1时刻读取到值为20，恰好在读取后的下一瞬间t2线程2对该资源写回变为1000。在这个过程中，volatile只能保证在t1的一瞬间是正确的，在t2时刻我们在t1时刻读取到的值和t2并不同，所以说一定准确这个说法是不对的。

3.那我们如果不加volatile和加volatile还有什么区别，不加的话我们难道读取就是错的吗？

对于我们的代码来说，比如123456，在我们认知中通常执行顺序是123456，但是实际上并不是，在计算机内部会采用流水线执行，采用流水线执行的话会导致指令重排序，那么一些已经写完的读不到，就会导致计算错误，所以我们需要保证多线程下的可见性。

流水线：每个环节只做一件事

比如制造望远镜，每个人做一个那么需要完成所有，可能一个人完成一天完成一个，那么一百个人一天内最多完成一百个，效率很低下，但是如果每个人只需要完成一个部件，那么效率就会大大提升，所以计算机内部也采用流水线方式执行

4.除了volatile还有什么能保证线程的可见性？

final：防止指令重排序的作用，保证多线程的可见性。

2.2synchronized的实现原理和应用（重点）

1.Synchonized原理（锁的实现原理）？（我讲不清楚，就直接贴图了）

JVM 基于进入和退出 Monitor 对象来实现方法同步和代码块同步，但两者的实现细节不一样。代码块同步是使用 monitorenter和monitorexit 指令实现的，而方法同步是使用另外一种方式实现的，细节在 JVM 规范里并没有详细说明。但是，方法的同步同样可以使用这两个指令来实现。

monitorenter 指令是在编译后插入到同步代码块的开始位置，而 monitorexit 是插入到方法结束处和异常处， JVM 要保证每个 monitorenter 必须有对应的 monitorexit 与之配对。任何对象都有一个monitor 与之关联，当且一个 monitor 被持有后，它将处于锁定状态。线程执行到 monitorenter指令时，将会尝试获取对象所对应的 monitor 的所有权，即尝试获得对象的锁。

synchronized 用的锁是存在 Java 对象头里的。如果对象是数组类型，则虚拟机用 3 个字宽

（ Word ）存储对象头，如果对象是非数组类型，则用 2 字宽存储对象头。在 32 位虚拟机中， 1 字宽

等于 4 字节，即 32bit ，如表 2-2 所示

Java 对象头里的 Mark Word 里默认存储对象的 HashCode 、分代年龄和锁标记位。 32 位 JVM

的 Mark Word 的默认存储结构如表 2-3 所示。

在运行期间， Mark Word 里存储的数据会随着锁标志位的变化而变化。 Mark Word 可能变

化为存储以下 4 种数据，如表 2-4 所示。

在 64 位虚拟机下， Mark Word 是 64bit 大小的，其存储结构如表 2-5 所示。

2.对于synchronized的使用

源码

public class Test02 {
	public synchronized void m1() throws InterruptedException{
		System.out.println("开始执行m1");
		Thread.sleep(3000);
		System.out.println("结束执行m1");
	}
	public synchronized void m2() throws InterruptedException{
		System.out.println("开始执行m2");
		Thread.sleep(3000);
		System.out.println("结束执行m2");
	}
	public synchronized static  void m3() throws InterruptedException{
		System.out.println("开始执行m3");
		Thread.sleep(3000);
		System.out.println("结束执行m3");
	}
	public synchronized static void m4() throws InterruptedException{
		System.out.println("开始执行m4");
		Thread.sleep(3000);
		System.out.println("结束执行m4");
	}
	public  void m5() throws InterruptedException{
		System.out.println("开始执行m5");
		Thread.sleep(3000);
		System.out.println("结束执行m5");
	}
	public static  void m6() throws InterruptedException{
		System.out.println("开始执行m6");
		Thread.sleep(3000);
		System.out.println("结束执行m6");
	}
}

public class Test0201 {
	public static void main(String[] args) throws InterruptedException {
		final Test02 x=new Test02();
		final Test02 y=new Test02();
		Thread t1=new Thread() {
			public void run() {
				try {
					x.m1();//更改部分
				}catch(InterruptedException e){ 
					e.printStackTrace();
				}
				
			}
		};
		Thread t2=new Thread() {
			public void run() {
				try {
					y.m2();//更改部分
				}catch(InterruptedException e){ 
					e.printStackTrace();
				}
				
			}
		};
		t1.start();
		t2.start();
	}
	
}

1.类锁：锁住类

动态方法需要通过类来调用，通过运行