多线程之volatile方法(2)

最新推荐文章于 2024-10-05 12:07:50 发布

道墟

最新推荐文章于 2024-10-05 12:07:50 发布

阅读量143

点赞数

文章标签： java 多线程

本文链接：https://blog.csdn.net/qq_27581753/article/details/106053225

版权

1.volatile非原子的特性

关键字volatile虽然增加了实例变量在多个线程之间的可见性，但它却不具备同步性，那么也就不具备原子性。
示例代码：

package volatileTest;

/**
 * @Author LiBinquan
 */
public class MyThread extends Thread{
    volatile public static int count;
    synchronized private static void addCount(){
        for (int i = 0; i < 100; i++) {
            count++;
        }
        System.out.println("count = "+count);
    }

    @Override
    public void run() {
        addCount();
    }
}

运行类：

package volatileTest;

/**
 * @Author LiBinquan
 */
public class Run {
    public static void main(String[] args) {
        MyThread[] myThreads = new MyThread[100];
        for (int i = 0; i < 100; i++) {
            myThreads[i] = new MyThread();
        }
        for (int i = 0; i < 100; i++) {
            myThreads[i].start();
        }
    }
}

输出：
在这里插入图片描述
注意在MyThread类中一定要添加static关键字，这样synchronized与static锁的内容就是MyThread类，也就达到同步效果了。
在这个示例当中，如果方法private static void addCount()前加入synchronized同步关键字，也就没有必要再使用volatile关键字来声明count变量了。
关键字volatile提示线程每次从共享内存中读取变量，而不是从私有内存中读取，这样就保证了同步数据的可见性。但在这里需要注意的是：如果修改实例变量中的数据，比如 i++ ，也就是 i=i+1，则这样的操作其实并不是一个原子操作，也就是非线程安全的。表达式i++的操作步骤分解如下：
1、从内存中取出i的值；
2、计算i的值；
3、将i的值写到内存中。
假如在第2步计算值得时候，另外一个线程也修改i的值，那么这个时候就会出现脏数据。解决的办法其实就是使用synchronized关键字，这个知识点在前面的案例中已经介绍过了。所以volatile本身并不处理数据的原子性，而是强制对数据的读写及时影响到主内存的。
下面说明一下使用关键字volatile时出现非线程安全的原因。变量在内存中工作的过程。

在这里插入图片描述
由上图，可以得出：
1、read和load阶段：从主存赋值变量到当前线程工作内存；
2、use和assign阶段：执行代码，改变共享变量值；
3、store和write阶段：用工作内存数据刷新主内存对应变量的值。
在多线程环境中，use和assign是多次出现的。但这一操作并不是原子性，也就是在read和load之后，如果主内存count变量发生修改之后，线程工作内存中的值由于已经加载，不会产生对应变化，也就是私有内存和公共内存中的变量不同步，所以计算出来的结果会和预期不一样，也就出现了非线程安全问题。
对于用volatile修饰的变量，JVM虚拟机只是保证从主内存加载到线程工作内存的值是最新的，例如线程1和线程2在进行read和load的操作中，发现主内存中count的值都是5，那么都会加载这个最新的值。也就是说，volatile关键字解决的是变量读时的可见性问题，但无法保证原子性，对于多个线程访问同一个实例变量还是需要加锁同步。

2.使用原子类进行i++操作

除了在i++操作时使用synchronized关键字实现同步外，还可以使用AtomicInteger原子类。原子操作时不能分割的整体，没有其他线程能够中断或检查正在原子操作中的变量。一个原子(atomic)类型就是一个原子操作可用的类型，它可以在没有锁的情况下做到线程安全。
示例代码如下：

package volatileTest;

import java.util.concurrent.atomic.AtomicInteger;

/**
 * @Author LiBinquan
 */
public class AddCountThread extends Thread{
    private AtomicInteger count = new AtomicInteger(0);

    @Override
    public void run() {
        for (int i = 0; i < 10000; i++) {
            System.out.println(count.incrementAndGet());
        }
    }
}

运行类：

package volatileTest;

/**
 * @Author LiBinquan
 */
public class Run {
    public static void main(String[] args) {
        AddCountThread countThread = new AddCountThread();
        Thread t1 = new Thread(countThread);
        t1.start();
        Thread t2 = new Thread(countThread);
        t2.start();
        Thread t3 = new Thread(countThread);
        t3.start();
        Thread t4 = new Thread(countThread);
        t4.start();
        Thread t5 = new Thread(countThread);
        t5.start();

    }
}

输出：
在这里插入图片描述
成功累加到了50000.

3.原子类也并不完全安全

原子类在具有有逻辑性的情况下输出结果也具有随机性。
示例代码如下：

package volatileTest;

import java.util.concurrent.atomic.AtomicLong;

/**
 * @Author LiBinquan
 */
public class MyService {
    public static AtomicLong atomicLong = new AtomicLong();
    public void addNum(){
        System.out.println(Thread.currentThread().getName()+" 加了100之后的值是： "+atomicLong.addAndGet(100));
        atomicLong.addAndGet(1);
    }
}

线程：

package volatileTest;

/**
 * @Author LiBinquan
 */
public class MyThread extends Thread{
    private MyService myService;
    public MyThread(MyService myService){
        super();
        this.myService = myService;
    }

    @Override
    public void run() {
        myService.addNum();
    }
}

运行：

package volatileTest;

/**
 * @Author LiBinquan
 */
public class Run {
    public static void main(String[] args) {
        try{
            MyService service = new MyService();
            MyThread[] threads = new MyThread[1000];
            for (int i = 0; i < threads.length; i++) {
                threads[i] = new MyThread(service);
            }
            for (int i = 0; i < threads.length; i++) {
                threads[i].start();
            }
            Thread.sleep(1000);
            System.out.println(service.atomicLong.get());
        }catch (InterruptedException e){
            e.printStackTrace();
        }
    }
}

输出：
在这里插入图片描述
由上图可以看到，打印顺序出错了，应该每加1次100再加1次1.出现这样的情况是因为addAndGet()方法是原子的，但方法和方法之间的调用却不是原子的。解决这样的问题必须要用同步。
代码修改如下：

package volatileTest;

import java.util.concurrent.atomic.AtomicLong;

/**
 * @Author LiBinquan
 */
public class MyService {
    public static AtomicLong atomicLong = new AtomicLong();
    synchronized public void addNum(){
        System.out.println(Thread.currentThread().getName()+" 加了100之后的值是： "+atomicLong.addAndGet(100));
        atomicLong.addAndGet(1);
    }
}

输出：
在这里插入图片描述
从运行结果可以看到，是每次加100再加1，这就是我们想要得到的过程，结果是505的同时还保证在过程中累加的顺序也是正确的。

3.synchronized代码块有volatile同步的功能

关键字synchronized可以使多个线程访问同一个资源具有同步性，而且它还具有将线程工作内存中的私有变量与公共内存中的变量同步的功能，在此实验中进行验证。
示例代码：

package volatileTest;

/**
 * @Author LiBinquan
 */
public class Service {
    private boolean isContinueRun = true;
    public void runMethod(){
        while (isContinueRun == true){

        }
        System.out.println("停下来！");
    }
    public void stopMethod(){{
        isContinueRun = false;
    }}
}

线程A:

package volatileTest;

/**
 * @Author LiBinquan
 */
public class ThreadA extends Thread {
    private Service service;
    public ThreadA(Service service){
        this.service = service;
    }

    @Override
    public void run() {
        service.runMethod();
    }
}

线程B：

package volatileTest;

/**
 * @Author LiBinquan
 * @since dw 3.0.0
 */
public class ThreadB extends Thread{
    private Service service;
    public ThreadB(Service service){
        this.service = service;
    }

    @Override
    public void run() {
        service.stopMethod();
    }
}

输出：

package volatileTest;

/**
 * @Author LiBinquan
 */
public class Run {
    public static void main(String[] args) {
        try{
            Service service = new Service();
            ThreadA a = new ThreadA(service);
            a.start();
            Thread.sleep(1000);
            ThreadB b = new ThreadB(service);
            b.start();
            System.out.println("已经发起停止的命令了！");
        }catch (InterruptedException e){
            e.printStackTrace();
        }
    }
}

输出：
在这里插入图片描述
得到这个结果是各线程间的数据值没有可视性造成的，而关键字synchronized可以具有可视性。更改代码如下：

package volatileTest;

/**
 * @Author LiBinquan
 */
public class Service {
    private boolean isContinueRun = true;
    public void runMethod(){
        String string = new String();
        while (isContinueRun == true){
            synchronized (string){}
        }
        System.out.println("停下来！");
    }
    public void stopMethod(){{
        isContinueRun = false;
    }}
}

输出：
在这里插入图片描述
关键字synchronized可以保证在同一时刻，只有一个线程可以执行某一个方法或某一个代码块。它包含两个特征：互斥性和可见性。同步synchronized不仅可以解决一个线程看到对象处于不一致的状态，还可以保证进入同步方法或者同步代码块的每个线程，都看到由同一个锁保护之前所有的修改效果。