java多线程---volatile
被volatile修饰的变量能够保证每个线程能够获取该变量的最新值，从而避免出现数据脏读的现象。
当把变量声明为volatile类型后，编译器与运行时都会注意到这个变量是共享的，因此不会将该变量上的操作与其他内存操作一起重排序。volatile变量不会被缓存在寄存器或者对其他处理器不可见的地方，因此在读取volatile类型的变量时总会返回最新写入的值。在访问volatile变量时不会执行加锁操作，因此也就不会使执行线程阻塞，因此volatile变量是一种比sychronized关键字更轻量级的同步机制。
- 1.非volatile变量，读写时，每个线程从内存copy到cpu缓存中，多核cpu，每个线程在不同的cpu上被处理。变量会被copy到不同的cpu缓存中
- 2.volatile变量，每次从内存中读，跳过了cpu缓存这一步。
- 特性
1.可见性。可见性是指当多个线程访问同一个变量时，一个线程修改了这个变量的值，其他线程能够立即看得到修改的值。
2.有序性。禁止指令重排序优化。
eg
public class VolatileTest {
public static volatile int i = 0 ;
public static class VTTest implements Runnable{
@Override
public void run() {
for (int j = 0; j < 1000; j++) {
i++; //可以理解为3步，1：读到工作内存，2：进行+1计算 3：写入新的i+1
System.out.println(Thread.currentThread().getId() + ":" + i);
}
}
}
public static void main(String[] args) throws InterruptedException {
Thread[] t = new Thread[10];
for (int i = 0; i < 10; i++) {
t[i] = new Thread(new VTTest());
t[i].start();
}
for (int i = 0; i < 10; i++) {
t[i].join();
}
}
}
由于volatile保证了可见性，那么在每个线程中对i自增完之后，在其他线程中都能看到修改后的值啊，所以有10个线程分别进行了1000次操作，那么最终i的值应该是1000*10=10000。这里面就有一个误区了，volatile关键字能保证可见性没有错，但是上面的程序错在没能保证原子性。可见性只能保证每次读取的是最新的值，但是volatile没办法保证对变量的操作的原子性。比如现在有2个线程，线程1开始读取i到工作内存，进行+1操作，在线程1还没有进行写操作，线程2也开始读取i到工作内存，进行+1操作，由于线程1还没有写操作，所以线程2的i还是有效的，线程1将递增的结果写到主内存，线程2读取到工作内存中的i无效，但是线程2已经对i递增完，也开始对i进行写入到主内存操作，所以最终2个线程最终只对i进行一次递增操作。那么怎么保证原子性呢，答案是加锁，使用synchronized或lock。
lock---eg
public class VolatileTest {
public static volatile int i = 0 ;
public static ReentrantLock lock = new ReentrantLock();
public static class VTTest implements Runnable{
@Override
public void run() {
for (int j = 0; j < 1000; j++) {
lock.lock();
i++; //i = i + 1;非原子操作
System.out.println(Thread.currentThread().getId() + ":" + i);
lock.unlock();
}
}
}
public static void main(String[] args) throws InterruptedException {
Thread[] t = new Thread[10];
for (int i = 0; i < 10; i++) {
t[i] = new Thread(new VTTest());
t[i].start();
}
for (int i = 0; i < 10; i++) {
t[i].join();
}
}
}
synchronized---eg
public class VolatileTest {
public static volatile int i = 0 ;
public static class VTTest implements Runnable{
@Override
public void run() {
increase();
}
}
public synchronized static void increase(){
for (int j = 0; j < 1000; j++) {
i++; //i = i + 1;非原子操作
System.out.println(Thread.currentThread().getId() + ":" + i);
}
}
public static void main(String[] args) throws InterruptedException {
Thread[] t = new Thread[10];
for (int i = 0; i < 10; i++) {
t[i] = new Thread(new VTTest());
t[i].start();
}
for (int i = 0; i < 10; i++) {
t[i].join();
}
}
}
