1.
package com.imooc.testThread;
/**
* 可见性:一个线程对共享变量值的修改,能给及时的被其他线程看到.
* 共享变量:如果一个变量在多个线程的工作内存中都存在副本,那么这个变量就是这几个线程的共享变量
* @author think
*jmm(java内存模型):描述了java程序中各种变量(线程共享变量)的访问规则,以及在虚拟机中将变量存储到内存和从内存中读取出变量这样的底层细节)
*所有的变量都存储在主内存中,每个线程都有自己的工作内存,里面保存该线程使用到的变量副本(主内存中该变量的一份拷贝)
*两条规定:线程对共享内存的所有操作都必须在自己的工作内存中进行,不能直接从主内存中读写.
* 不同线程之间不能访问其他线程工作内存中的变量,线程间变量值的传递需要在主内存中进行.
*线程1对共享变量的修改,要想被线程2看到:两个步骤:
*1.把线程1工作内存中变量修改的值刷新到主内存中
*2.将主内存中最新的共享变量的值赋值给线程2
*
*java语言层面对于可见性的实现
*1.synchronized:同步,保证同一时刻只有一个线程在执行synchronized内的代码,保证锁内操作的一个原子性.可见性(内存)
* jmm对于synchronized的两条规定:1.在线程解锁前,必须将工作内存的修改值刷新到主内存中去.
* 2.线程加锁时,将清空工作内存中共享变量的值,使用共享变量时从主内存中获取
* (加锁与解锁需要的是同一把锁):线程解锁前对共享变量的可见性在下次加锁的时候能够被其他线程可看到
* 线程执行互斥代码的过程
* 1.获得互斥锁
* 2.清空工作内存
* 3.从主内存中拷贝最新的变量副本到工作内存
* 4.执行代码
* 5.将更改后的工作内存的变量刷新到主内存
* 6.释放互斥锁
*
* 两个概念:
* 1) 重排序:代码书写的顺序和实际执行的顺序不同,指令重排序是编译器或者处理器为了提高程序性能而做的优化.
* 1.编译器优化的重排序(编译器优化)
* 2.指令集并行重排序(处理器优化)
* 3.内存系统的重排序(处理器优化)
*
* 2) as-if-serial语义:无论如何重排序,程序执行的结果应该与代码顺序执行的结果一致(java编译器,运行时和处理器都会保证java在单线程下遵循as-if-serial语义)
* int a = 3;
* int b = 4;
* int sum = a + b;
* 单线程: 1,2行的顺序可以重排序,但第三行不行
* 重排序不会给单线程带来内存可见性问题
* 多线程中程序交错执行时,重排序可能会造成内存可见性问题.
*
*
*
*2.volatile
*
*/
public class ThreadDemo {
}
2.
package com.imooc.testThread;
/**
* 共享变量在线程间不可见的原因
* 1.线程的交叉执行
* 2.重排序结合线程交叉执行
* 3.共享变量更新后的值没有在主内存与工作内存中及时更新
*
* Synchronized可解决
* @author think
*
*/
public class SynchronizedDemo {
// 共享变量
private boolean ready = false;
private int result = 0;
private int number = 1;
// 写操作
public void write() {
ready = true; // 1.1
number = 2; // 1.2
}
// 读操作
public void read() {
if (ready) { // 2.1
result = number * 3; // 2.2
}
System.out.println("result的值为：" + result);
}
// 内部线程类
private class ReadWriteThread extends Thread {
// 根据构造方法中传入的flag参数，确定线程执行读操作还是写操作
private boolean flag;
public ReadWriteThread(boolean flag) {
this.flag = flag;
}
@Override
public void run() {
if (flag) {
// 构造方法中传入true，执行写操作
write();
} else {
// 构造方法中传入false，执行读操作
read();
}
}
}
public static void main(String[] args) {
SynchronizedDemo synDemo = new SynchronizedDemo();
// 启动线程执行写操作
synDemo.new ReadWriteThread(true).start();
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
// 启动线程执行读操作
synDemo.new ReadWriteThread(false).start();
}
}
3.
package com.imooc.testThread;
/**
*
* @author think
*/
public class VolatileDemo0 {
private volatile int number = 0;
public int getNumber() {
return number;
}
public void setNumber(int number) {
this.number = number;
}
public void increase() {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
this.number++;//number++不是原子性操作的:
/**
* 1.首先会从内存中读取number的值,然后将number的值进行+1,最后将+1后的值写入到内存中去.
* 2.但volatile不能保证这个number++的原子性.这个时候有可能会有三个线程来进行交叉执行这三个操作(1).
* 解决方案
* 1.使用synchronized关键字
* 2.使用ReentrantLock(java.util.concurrent.locks)
* 3.使用AtomicInteger(java.uitl.concurrent.atomic)
*/
}
public static void main(String[] args) {
final VolatileDemo0 volatileDemo = new VolatileDemo0();
for (int i = 0; i < 500; i++) {
new Thread(new Runnable() {
@Override
public void run() {
volatileDemo.increase();
}
}).start();
}
/**
* 如果还有子线程在运行,主线程就让出cpu资源,直到所有的子线程都运行完,主线程再继续运行
*/
while (Thread.activeCount() > 1) {
Thread.yield();
}
System.out.println("number:" + volatileDemo.getNumber());
}
}
4.
package com.imooc.testThread;
/**
*
* 1.首先会从内存中读取number的值,然后将number的值进行+1,最后将+1后的值写入到内存中去.
* 2.但volatile不能保证这个number++的原子性.这个时候有可能会有三个线程来进行交叉执行这三个操作(1).
*
* 解决方案
* 1.使用synchronized关键字
*
* @author think
*/
public class VolatileDemo1 {
private volatile int number = 0;
public int getNumber() {
return number;
}
public void setNumber(int number) {
this.number = number;
}
public /*synchronized*/ void increase() {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized(this){//缩小锁粒度
this.number++;// number++不是原子性操作的:
}
}
public static void main(String[] args) {
final VolatileDemo1 volatileDemo = new VolatileDemo1();
for (int i = 0; i < 500; i++) {
new Thread(new Runnable() {
@Override
public void run() {
volatileDemo.increase();
}
}).start();
}
/**
* 如果还有子线程在运行,主线程就让出cpu资源,直到所有的子线程都运行完,主线程再继续运行
*/
while (Thread.activeCount() > 1) {
Thread.yield();
}
System.out.println("number:" + volatileDemo.getNumber());
}
}
5.
package com.imooc.testThread;
import java.util.concurrent.locks.ReentrantLock;
/**
* 1.首先会从内存中读取number的值,然后将number的值进行+1,最后将+1后的值写入到内存中去.
* 2.但volatile不能保证这个number++的原子性.这个时候有可能会有三个线程来进行交叉执行这三个操作(1).
* 解决方案
* 2.使用ReentrantLock(java.util.concurrent.locks)
*
* @author think
*/
public class VolatileDemo2 {
ReentrantLock lock = new ReentrantLock();
private volatile int number = 0;
public int getNumber() {
return number;
}
public void setNumber(int number) {
this.number = number;
}
public /* synchronized */ void increase() {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
lock.lock();//加锁
try{
this.number++;// number++不是原子性操作的:
}finally{
lock.unlock();//释放锁
}
}
public static void main(String[] args) {
final VolatileDemo2 volatileDemo = new VolatileDemo2();
for (int i = 0; i < 500; i++) {
new Thread(new Runnable() {
@Override
public void run() {
volatileDemo.increase();
}
}).start();
}
/**
* 如果还有子线程在运行,主线程就让出cpu资源,直到所有的子线程都运行完,主线程再继续运行
*/
while (Thread.activeCount() > 1) {
Thread.yield();
}
System.out.println("number:" + volatileDemo.getNumber());
}
}
/**
* volatile使用场景:
*1.对变量的写操作不依赖于当前值(比如:number++,count=count*5);满足(Boolean变量值,记录温度变化的变量)
*2.该变量没有包含在其他变量的不变式中
*比如(low<up)
*
*对比:
*volatile不需要加锁,执行的效率要比synchronized要高
*
*补充:final也可以保证内存的可见性(其修饰的变量,一旦复制就不能被修改了)
*/
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
