关键字 synchronized和volatile的使用分析（三）

素颜马尾好姑娘i 2022-11-21 11:22 51阅读 0赞

日常开发过程中：关键字 synchronized和volatile 经常使用，下面我们详细分析一下：

***一、synchronized ：*** ***内置锁***

线程开始运行，拥有自己的栈空间，就如同一个脚本一样，按照既定的代码 一步一步地执行，直到终止。但是，每个运行中的线程，如果仅仅是孤立地运行， 那么没有一点儿价值，或者说价值很少，如果多个线程能够相互配合完成工作， 包括数据之间的共享，协同处理事情。这将会带来巨大的价值。 Java 支持多个线程同时访问一个对象或者对象的成员变量，关键字 synchronized 可以修饰方法或者以同步块的形式来进行使用，它主要确保多个线 程在同一个时刻，只能有一个线程处于方法或者同步块中，它保证了线程对变量 访问的可见性和排他性，又称为内置锁机制。

1、对象锁和类锁：

对象锁是用于对象实例方法，或者一个对象实例上的，类锁是用于类的静态 方法或者一个类的 class  对象上的。我们知道，类的对象实例可以有很多个，但 是每个类只有一个 class  对象，所以不同对象实例的对象锁是互不干扰的，但是 每个类只有一个类锁。 但是有一点必须注意的是，其实类锁只是一个概念上的东西，并不是真实存 在的，类锁其实锁的是每个类的对应的 class  对象。类锁和对象锁之间也是互不 干扰的。对象锁和类锁，以及锁 static  变量之间的运行情况，请参考如下代码。 使用方式：

/**
     *类说明：synchronized关键字的使用方法
     */
    public class SynTest {
    
    	private long count =0;
    	private Object obj = new Object();//作为一个锁
    	public long getCount() {
    		return count;
    	}
    	public void setCount(long count) {
    		this.count = count;
    	}
    
    	/*用在同步块上*/
    	public void incCount(){
    		synchronized (obj){//对象锁
    			count++;
    		}
    	}
    
    	/*用在方法上*/
    	public synchronized void incCount2(){
    			count++;
    	}
    
    	/*用在同步块上，但是锁的是当前类的对象实例*/
    	public void incCount3(){
    		synchronized (this){//类锁
    			count++;
    		}
    	}
    
    	//线程
    	private static class Count extends Thread{
    		private SynTest simplOper;
    
    		public Count(SynTest simplOper) {
    			this.simplOper = simplOper;
    		}
    		@Override
    		public void run() {
    			for(int i=0;i<10000;i++){
    			//	simplOper.incCount();//count = count+10000  
    			//	simplOper.incCount2();//count = count+10000
    				simplOper.incCount3();//count = count+10000
    			}
    		}
    	}
    
    	public static void main(String[] args) throws InterruptedException {
    		SynTest simplOper = new SynTest();
    		//启动两个线程
    		Count count1 = new Count(simplOper);
    		Count count2 = new Count(simplOper);
    		count1.start();
    		count2.start();
    		Thread.sleep(50);
    		System.out.println(simplOper.count);//20000
    	}
    }

2、错误加锁方式：

private Integer i;
            private Object o = new Object();
    
            public Worker(Integer i) {
                this.i=i;
            }
    
            @Override
            public void run() {
                synchronized (i) {//这种参数加锁方式是错误的，本质上是返回了一个新的 Integer 对象。也就是每个线程实际加锁的是不同的 Integer 对象；换成 o 对象就OK了
                     //业务代码
                    }

因此，加锁尽量是一个object类型的标准对象

***二、volatile*** ***，最轻量的同步机制***

1、volatile  保证了不同线程对这个变量进行操作时的可见性，即一个线程修改了某 个变量的值，这新值对其他线程来说是立即可见的。参见代码：

/**
     * 类说明：演示Volatile的提供的可见性
     */
    public class VolatileCase {
       // private volatile static boolean ready;
        private  static boolean ready;
        private static int number;
    
        //
        private static class PrintThread extends Thread{
            @Override
            public void run() {
                System.out.println("PrintThread is running.......");
                while(!ready);//如果不加 volatile，会无限循环
                System.out.println("number = "+number);
            }
        }
    
        public static void main(String[] args) {
            new PrintThread().start();
            SleepTools.second(1);
            number = 51;
            ready = true;
            SleepTools.second(5);
            System.out.println("main is ended!");
        }
    }

不加 volatile 修饰ready ：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25hbmRhbzE1OA_size_16_color_FFFFFF_t_70][]

加上 volatile 修饰：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25hbmRhbzE1OA_size_16_color_FFFFFF_t_70 1][]

不加  volatile  时，子线程无法感知主线程修改了  ready  的值，从而不会退出循环， 而加了 volatile  后，子线程可以感知主线程修改了  ready  的值，迅速退出循环。 但是 volatile  不能保证数据在多个线程下同时写时的线程安全，参见代码：

public class NotSafe {
        private  long count =0; //不能保证可见性
     //   private volatile long count =0;//能保证可见性
    
        public long getCount() {
            return count;
        }
    
        public void setCount(long count) {
            this.count = count;
        }
    
        //count进行累加
        public void incCount(){
            count++;
        }
    
        //线程
        private static class Count extends Thread{
    
            private NotSafe simplOper;
    
            public Count(NotSafe simplOper) {
                this.simplOper = simplOper;
            }
    
            @Override
            public void run() {
                for(int i=0;i<10000;i++){
                    simplOper.incCount();
                }
            }
        }
    
        public static void main(String[] args) throws InterruptedException {
            NotSafe simplOper = new NotSafe();
            //启动两个线程
            Count count1 = new Count(simplOper);
            Count count2 = new Count(simplOper);
            count1.start();
            count2.start();
            Thread.sleep(50);
            System.out.println(simplOper.count);//20000?
        }
    }

加上volatile 修饰也不能得到2000，说明不能保证原子性：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25hbmRhbzE1OA_size_16_color_FFFFFF_t_70 2][]

volatile  最适用的场景：一个线程写，多个线程读；不适合多写多读。这俩关键字使用分析到此结束，以后有机会我们分析一下源码，敬请期待！

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25hbmRhbzE1OA_size_16_color_FFFFFF_t_70]: /images/20221120/abb2399343a74a2b9e4bdc0dc306915d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25hbmRhbzE1OA_size_16_color_FFFFFF_t_70 1]: /images/20221120/0739052477484a77a7ddfbf261480102.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25hbmRhbzE1OA_size_16_color_FFFFFF_t_70 2]: /images/20221120/9dd9a6b8901b47529de73361618341cf.png