Java并发编程---volatile关键字与atomic原子类

柔光的暖阳◎ 2022-06-03 09:07 329阅读 0赞

**一.Volatile关键字**

**1.1 概念**

volatile关键字的主要作用是使变量在多个线程间可见

**1.2 示例程序**

package com.thread.variable;
    
    /**
     * volatile关键字的使用
     * @author lhy
     * @time   2017.12.23
     *
     */
    public class RunThread extends Thread {
    
    	//如果此处不使用volatile关键字,那么程序执行结束,线程也不会终止,因为线程的运行取值是在内存区,和程序变量的定义无关
    	private volatile boolean isRunning = true;
    	
    	private void setRunning(boolean isRunning){
    		this.isRunning = isRunning;
    	}
    	
    	@Override
    	public void run() {
    		// TODO Auto-generated method stub
    		System.out.println("进入run方法...");
    		while(isRunning == true){
    			boolean a = isRunning;
    		}
    		System.out.println("线程终止...");
    	}
    
    	public static void main(String[] args) throws InterruptedException {
    		// TODO Auto-generated method stub
            RunThread rt = new RunThread();
            rt.start();
            Thread.sleep(3000);
            rt.setRunning(false);
            System.out.println("isRunning的值已经被设置了false");
            Thread.sleep(1000);
            System.out.println(rt.isRunning);
    	}
    
    }

**1.3 代码分析**

在java中,每一个线程都会有一块工作内存区,其中存放着所有线程共享的主内存中的变量值的拷贝.当线程执行时,它在自己的工作内存区中操作这些变量.为了存取一个共享的变量,一个线程通常先获取锁定并去清除它的内存工作区,把这些共享变量从所有线程的共享内存区中正确地装入到他自己所在工作内存区中,当线程解锁时保证该工作内存区中变量的值写回到共享内存中.

一个线程可以执行的操作有使用(use),赋值(assign),装载(load),存储(store),锁定(lock),解锁(unlock)

而主内存可以执行的操作有读(Read),写(write),锁定(lock),解锁(unlock),每个操作都是原子的

**volatile的作用就是强制线程到主内存(共享内存)里去读取变量,而不去线程工作内存区里去读取,从而实现了多个线程间的变量可见,也就是满足线程安全的可见性**

**二.Volatile关键字的非原子性**

**2.1 概念**

volatile关键字虽然拥有多个线程之间的可见性,但是却不具备同步性(也就是原子性),可以算上是一个轻量级的synchronized强很多,不会造成阻塞(在很多开源的架构里,比如netty的底层代码就大量使用volatile,可见netty性能一定是非常不错的).这里需要注意.一般volatile用于只针对于多个线程可见的变量操作,并不能代替synchronized的同步功能.

**2.2 代码示例**

package com.thread.variable;
    
    import java.util.concurrent.atomic.AtomicInteger;
    
    /**
     * volatile关键字的非原子性
     * @author lhy
     * @time   2017.12.23
     *
     */
    public class VolatileNoAtomic extends Thread {
    
    //	private static volatile int count;	
    	private static AtomicInteger count = new AtomicInteger(0);
    	private static void addCount(){
    		for(int i=0; i<1000; i++){
    //			count++;
    			count.incrementAndGet();
    		}
    		System.out.println(count);
    	}
    	
    	@Override
    	public void run() {
    		// TODO Auto-generated method stub
    		addCount();
    	}
    
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
            VolatileNoAtomic[] arr = new VolatileNoAtomic [10];
            for(int i = 0 ; i<10; i++){
            	arr[i] = new VolatileNoAtomic();
            }
            
            for(int i=0 ; i<10 ; i++){
            	arr[i].start();
            }
    	}
    
    }

**2.3 代码分析**

volatile关键字只具有可见性,没有原子性.

**三. atomic原子类**

**3.1.概念**

要实现原子性,建议使用atomic类的系列对象,支持原子性操作.(注意atomic类只保证本身方法原子性,并不保证多次操作的原子性.除非在方法或对象上加synchronized锁)

**3.2 代码示例**

package com.thread.variable;
    
    import java.util.ArrayList;
    import java.util.List;
    import java.util.concurrent.atomic.AtomicInteger;
    
    public class AtomicUse {
        /**
         * 只能保证首个方法的原子性,不能保证整体的原子性,加锁synchronized后可以保证整体的原子性
         * AtomicInteger原子性操作
         */
    	private static AtomicInteger count = new AtomicInteger(0);
    	
    	//多个addAndGet在一个方法内是原子性的,需要加synchronized进行修饰,保证4个addAndGet整体原子性
    	
    	public int multiAdd(){
    		try {
    			Thread.sleep(1000);
    		} catch (InterruptedException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		}
    		count.addAndGet(1);
    		count.addAndGet(2);
    		count.addAndGet(3);
    		count.addAndGet(4);
    		return count.get();
    	}
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
            final AtomicUse au = new AtomicUse();
            
            List<Thread> ts = new ArrayList<Thread>();
            for(int i=0; i<100; i++){
            	ts.add(new Thread(new Runnable() {
    				
    				@Override
    				public void run() {
    					// TODO Auto-generated method stub
    					System.out.println(au.multiAdd());
    				}
    			}));
            }
            
            for(Thread t : ts){
            	t.start();
            }
    	}
    
    }