JAVA多线程系列--关键字(volatile,synchronized)

1.Synchronized 

使用范围：1.对于普通同步方法，锁水当前实例对象 
                 2.对于静态同步方法，锁是当前类的class对象 
                 3.对于同步方法快，锁是synchonized内配置的对象 
实现原理：JVM要保证每个monitorenter必须有对应的monitorexit与之配对。 
任何对象都有一个monitor与之关联，当且一个monitor被持有后，它将处于锁定状态；直到monitor被释放。

 

例子：

/**
 * Synchronized 举例
 * @author niyuelin
 *
 */
public class SynchronizedExample {
   public Integer inc = 0;

   /**
    * 方法锁
    */
   public synchronized void increase1() {
      inc++;
   }
   
   /**
    * 代码块锁
    */
   public void increase2() {
      synchronized(this){
         inc++;
      }
   }
   
   /**
    * 对象锁
    */
   public void increase3() {
      synchronized(inc.getClass()){
         inc++;
      }
   }

   public static void main(String[] args) {
      final SynchronizedExample test = new SynchronizedExample();
      System.out.println("========================111");
      for (int i = 0; i < 10; i++) {
         new Thread() {
            public void run() {
               for (int j = 0; j < 1000; j++)
                  test.increase3();
            };
         }.start();
      }

      while (Thread.activeCount() > 2){
         // 保证前面的线程都执行完
         Thread.yield();
//       System.out.println(Thread.activeCount());
      }

      System.out.println(test.inc);
   }
}

1.volatile

内存语义：1.保证了不同线程对这个变量进行操作时的可见性，即一个线程修改了某个变量的值，这新值对其他线程来说是立即可见的。 
                  2.禁止进行指令重排序。 
实现原理： 1.lock前缀指令会引起处理器缓存回写到内存 
                  2.一个处理器的缓存回写到内存会导致其他处理器的缓存无效

通俗的讲：Volatile修饰的成员变量在每次被线程访问时，都强迫从共享内存中重读该成员变量的值。而且，当成员变量发生变化时，强迫线程将变化值回写到共享内存。这样在任何时刻，两个不同的线程总是看到某个成员变量的同一个值。 但是Volatile不保证原子性

例子1：

public class TestWithVolatile {
    private static volatile boolean bChanged;

    public static void main(String[] args) throws InterruptedException {
        new Thread() {
            @Override
            public void run() {
                for (; ; ) {
                    if (bChanged == !bChanged) {
                        System.out.println("!=");
                        System.exit(0);
                    }
                }
            }
        }.start();
        Thread.sleep(10);
        new Thread() {
            @Override
            public void run() {
                for (; ; ) {
                    bChanged = !bChanged;
                }
            }
        }.start();
    }
}

输出：

若变量bChanged，有volatile修饰；则程序将立即结束并退出。

若无volatile修饰；则程序不会立即结束退出。

原因：每次使用它都到主存中进行读取,从而导致volatile修饰的值会不一样。

例子2：

/**
 * volatile不保证原子性
 * @author niyuelin
 *
 */
public class VolatileExample2 {
   public volatile int inc = 0;
   
    public void increase() {
        inc++;
    }
     
    public static void main(String[] args) {
        final VolatileExample2 test = new VolatileExample2();
        for(int i=0;i<10;i++){
            new Thread(){
                public void run() {
                    for(int j=0;j<1000;j++)
                        test.increase();
                };
            }.start();
        }
         
        while(Thread.activeCount()>2)  //保证前面的线程都执行完
            Thread.yield();
        System.out.println(test.inc);
    } 
}

输出：

小于1000的值。

原因：volatile不保证原子性