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

日常开发过程中：关键字 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 ：

加上 volatile 修饰：

不加 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，说明不能保证原子性：

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