java多线程基础之synchronized和volatile

一、 多线程锁synchronized

1. 概念说明：synchronized是java语言的关键字，当它用来修饰一个方法或者一个代码块的时候，能保证在同一时刻最多只有一个线程执行该段代码。

2. 使用方式：

   a. 修饰代码块：注意在锁的时候，一定要保证是同一个对象

   /**
    * 不使用synchronized加锁的情况下，线程A,B交替执行
    * 可能输出的结果:
    * Thread B print 0
    * Thread B print 1
    * Thread B print 2
    * Thread A print 0
    * Thread B print 3
    * Thread A print 1
    * Thread B print 4
    * Thread A print 2
    * Thread A print 3
    * Thread A print 4
    */
   public class SyncDemo implements Runnable {
       @Override
       public void run() {
           for (int i = 0; i < 5; i++) {
               System.out.println(Thread.currentThread().getName() + " print " + i);
           }
       }
   
       public static void main(String[] args) {
           SyncDemo syncDemo = new SyncDemo();
           Thread threadA = new Thread(syncDemo, "Thread A");
           Thread threadB = new Thread(syncDemo, "Thread B");
           threadA.start();
           threadB.start();
       }
   }
   

   /**
    * 使用synchronized加锁的情况下，线程A和线程B必须排队等待其中一个线程执行完成释放锁后才能继续执行
    * 可能输出的结果:
    * Thread A print 0
    * Thread A print 1
    * Thread A print 2
    * Thread A print 3
    * Thread A print 4
    * Thread B print 0
    * Thread B print 1
    * Thread B print 2
    * Thread B print 3
    * Thread B print 4
    */
   public class SyncDemo implements Runnable {
       @Override
       public void run() {
           synchronized (this) {
               for (int i = 0; i < 5; i++) {
                   System.out.println(Thread.currentThread().getName() + " print " + i);
               }
           }
       }
   
       public static void main(String[] args) {
           SyncDemo syncDemo = new SyncDemo();
           Thread threadA = new Thread(syncDemo, "Thread A");
           Thread threadB = new Thread(syncDemo, "Thread B");
           threadA.start();
           threadB.start();
           
           // 稍微改动一下,此时为两个不同对象，则无法保证线程C和线程D必须等待对方执行完成才继续执行
           Thread threadC = new Thread(new SyncDemo(), "Thread C");
           Thread threadD = new Thread(new SyncDemo(), "Thread D");
           threadC.start();
           threadD.start();
       }
   }
   

   b. 修饰普通方法:

   /**
    * 使用synchronized修饰普通方法，线程A和线程B必须排队等待其中一个线程执行完成释放锁后才能继续执行
    * 可能输出的结果:
    * Thread A print 0
    * Thread A print 1
    * Thread A print 2
    * Thread A print 3
    * Thread A print 4
    * Thread B print 0
    * Thread B print 1
    * Thread B print 2
    * Thread B print 3
    * Thread B print 4
    */
   public class SyncDemo implements Runnable {
       @Override
       public synchronized void run() {
           for (int i = 0; i < 5; i++) {
               System.out.println(Thread.currentThread().getName() + " print " + i);
           }
       }
   
       public static void main(String[] args) {
           SyncDemo syncDemo = new SyncDemo();
           Thread threadA = new Thread(syncDemo, "Thread A");
           Thread threadB = new Thread(syncDemo, "Thread B");
           threadA.start();
           threadB.start();
       }
   }
   

   c. 修饰静态方法：上面的演示了，当创建两个不同的对象时，添加synchronized块或者是在方法上面添加synchronized，两个不同对象是彼此独立的锁，但是使用在静态方法上面使用synchronized，两个对象却保持了同步，这是因为run中调用的静态方法，而静态方法是属于同一个类的，所有两个对象相当与持有了同一把锁。

   /**
    * synchronized修饰静态方法，当两个不同的对象同时启动静态方法，因为静态方法是同一个方法，
    * 无论你创建多少个类对象，静态方法都是同一个，则线程A和线程B在调用静态方法时，都持有同一
    * 把锁
    * 可能输出的结果:
    * Thread A print 0
    * Thread A print 1
    * Thread A print 2
    * Thread A print 3
    * Thread A print 4
    * Thread B print 0
    * Thread B print 1
    * Thread B print 2
    * Thread B print 3
    * Thread B print 4
    */
   public class SyncDemo implements Runnable {
       @Override
       public void run() {
           method();
       }
   
       public synchronized static void method() {
           for (int i = 0; i < 5; i++) {
               System.out.println(Thread.currentThread().getName() + " print " + i);
           }
       }
   
       public static void main(String[] args) {
           // 此时线程A和线程B为不同对象的线程
           Thread threadA = new Thread(new SyncDemo(), "Thread A");
           Thread threadB = new Thread(new SyncDemo(), "Thread B");
           threadA.start();
           threadB.start();
       }
   }
   

二. 多线程之volatile

1. 概念：volatile关键字修饰一个共享变量(类的成员变量、类的静态成员变量)，则会具备两层意义：

   a. 保证了不同线程对这个变量进行操作时的可见性，即一个线程修改了某个变量的值，则新值对其他线程来说是立即可见的。

   b. 禁止指令进行重排序

   /**
    * 使用volatile终止线程
    */
   public class VolatileDemo implements Runnable {
       // 如果不是用volatile关键字，可以能导致线程死锁，永远无法终止线程
       private static volatile boolean flag = false;
   
       @Override
       public void run() {
           while (!flag) {
               System.out.println(Thread.currentThread().getName() + "线程被中断");
           }
       }
   
       public static void main(String[] args) throws InterruptedException {
           Thread thread = new Thread(new VolatileDemo(), "Thread A ");
           thread.start();
           TimeUnit.SECONDS.sleep(5);
           flag = true;
       }
   }
   

2. volatile关键字无法保证原子性，仅仅只能保证可见性：

   /**
    * volatile关键字无法保证操作的原子性，只能保证可见性
    *   结果始终都会小于10000
    */
   public class VolatileDemo2 {
       private volatile int num = 0;
   
       public void increase() {
           num++;
       }
   
       public static void main(String[] args) throws InterruptedException {
           CountDownLatch countDownLatch = new CountDownLatch(10);
           final VolatileDemo2 volatileDemo = new VolatileDemo2();
           for (int i = 0; i < 10; i++) {
               new Thread(() -> {
                   try {
                       for (int j = 0; j < 1000; j++) {
                           volatileDemo.increase();
                       }
                   } finally {
                       countDownLatch.countDown();
                   }
               }).start();
   
           }
           // 需要测试结果，需要让所有的线程全部执行完成
           countDownLatch.await();
           System.out.println(volatileDemo.num);
       }
   }