一、volitile的理解
- Volatile称之为轻量级锁，被volatile修饰的变量，在线程之间是可见的。
- 可见即一个线程修改了这个变量的值，在另外一个线程中能够读到这个修改后的值。
- Synchronized除了线程之间互斥以外，还有一个非常大的作用就是保证可见性。
- 保证可见性的前提，多个线程拿到的是同一把锁，否则是保证不了的。
二、多个线程获取值案例（没有使用同步的情况）
1、代码
package com.xz.thread.t6;
/**
* @description: 保证可见性的前提：多个线程拿到的是同一把锁，否则是保证不了的。
*
* @author: xz
*/
public class Demo {
private int a=1;
public int getA() {
return a;
}
public void setA(int a) {
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
this.a = a;
}
public static void main(String[] args) {
Demo d=new Demo();
//第一个线程
new Thread(new Runnable() {
@Override
public void run() {
d.setA(10);
}
}).start();
//第二个线程
new Thread(new Runnable() {
@Override
public void run() {
System.out.println(d.getA());
}
}).start();
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("最终的结果："+d.getA());
}
}
2、输出结果
3、结论
- 在没有使用同步的情况下，同一个实例中多个线程获取的值是不相同的。
三、多个线程获取值案例（使用Volatile关键字的情况）
1、代码
package com.xz.thread.t6;
/**
* @description: 保证可见性的前提：多个线程拿到的是同一把锁，否则是保证不了的。
* @author: xz
*/
public class Demo2 {
public volatile int a = 1;
public static void main(String[] args) {
Demo2 d=new Demo2();
new Thread(new Runnable() {
@Override
public void run() {
d.a = 10;
}
}).start();
new Thread(new Runnable() {
@Override
public void run() {
System.out.println(d.a);
}
}).start();
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("最终的结果："+d.a);
}
}
2、输出结果
3、结论
- 在使用Volatile关键字的情况下，同一个实例中多个线程获取的值是相同的。
四、多个线程获按顺序执行的案例
1、代码
package com.xz.thread.t6;
/**
* @description:
* @author: xz
*/
public class Demo3 {
public volatile Boolean run =false;
public static void main(String[] args) {
Demo3 d3=new Demo3();
//第一个线程
new Thread(new Runnable() {
@Override
public void run() {
for(int i=0;i<10;i++){
System.out.println("第【"+i+"】次执行");
try {
Thread.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
d3.run =true;//第一个线程执行完把run变量改成true
}
}).start();
//第二个线程
new Thread(new Runnable() {
@Override
public void run() {
while (!d3.run){
//当run ！=true 时，不执行
}
System.out.println("线程2执行了===========");
}
}).start();
}
}
2、输出结果
六、 Lock指令的理解
- volatile可见性是通过汇编加上Lock前缀指令完成的。由此引出Lock指令的理解。
- 在多处理器的系统上
- 将当前处理器缓存行的内容写回到系统内存；
- 这个写回到内存的操作会使在其他CPU里缓存了该内存地址的数据失效。
七、有Volatile为什么还使用synchronized
- volatile关键字可以保证内存可见性和有序性，但不能保证原子性；
- 也就是说synchronized可以取代Volatile，但是Volatile不能取代synchronized；
八、synchronized可以取代Volatile，为什么还用Volatile
- Volatile称之为轻量级锁。
转载：https://blog.csdn.net/li1325169021/article/details/115840286
查看评论