synchronized、volatile

synchronized & volatile

synchronized关键字和volatile关键字比较

• volatile关键字是线程同步的轻量级实现，所以volatile性能肯定比synchronized关键字要好。但是volatile关键字只能用于变量而synchronized关键字可以修饰方法以及代码块。
• 多线程访问volatile关键字不会发生阻塞，而synchronized关键字可能会发生阻塞
• volatile关键字能保证数据的可见性，但不能保证数据的原子性。synchronized关键字两者都能保证。
• volatile关键字主要用于解决变量在多个线程之间的可见性，而 synchronized关键字解决的是多个线程之间访问资源的同步性。

synchronized

​ **修饰普通方法：**锁住对象实例

​ **修饰静态方法：**锁住整个类

​ **修饰代码块：**锁住一个对象 synchronized（lock） 即lock的内容

/**

- @author : fzz
  */
  public class ThreadDemo {

  public static void main(String[] args){
      ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(10,30,3L, TimeUnit.SECONDS,new LinkedBlockingQueue<Runnable>());
      threadPoolExecutor.submit(()->{
          ThreadDemo threadDemo = new ThreadDemo();
          threadDemo.showB();
      });
      threadPoolExecutor.submit(()->{
          ThreadDemo threadDemo1 = new ThreadDemo();
          threadDemo1.showB();
      });
      threadPoolExecutor.submit(()->{
          ThreadDemo.showA();
      });
      threadPoolExecutor.submit(()->{
          ThreadDemo.showA();
      });
      threadPoolExecutor.shutdown();
  }

  private static synchronized void  showA(){
      try {
          Thread.sleep(3000L);
      } catch (InterruptedException e) {
          e.printStackTrace();
      }
      System.out.println(Thread.currentThread().getName()+"===========> A");
  }

  private synchronized void  showB(){
      try {
          Thread.sleep(3000L);
      } catch (InterruptedException e) {
          e.printStackTrace();
      }
      System.out.println(Thread.currentThread().getName()+"===========> B");
  }

}

打印结果：（前三个一起，过三秒后最后一个打印）
pool-1-thread-3===========> A
pool-1-thread-2===========> B
pool-1-thread-1===========> B
pool-1-thread-4===========> A

volatile：

​ 仅能修饰变量、保证该变量的可见性（线程A：修改volatile修饰的对象，对线程B来说是可见的），但并不保证原子性，禁止指令重排

/**
 * @author : fzz
 */
public class VolatileDemo {

    private static volatile Integer count = 0;

    public static void main(String[] args) throws InterruptedException {
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(10,30,3L, TimeUnit.SECONDS,new LinkedBlockingQueue<Runnable>());
        CountDownLatch countDownLatch = new CountDownLatch(10);
        for (int i = 0; i < 10; i++) {
            threadPoolExecutor.submit(()->{
                for (int j = 0; j < 1000; j++) {
                    count++;
                }
                System.out.println(Thread.currentThread().getName()+"==> A ==》"+ count);
                countDownLatch.countDown();
            });
        }
        countDownLatch.await();
        System.out.println(count);
        threadPoolExecutor.shutdown();
    }
}
输出结果：最后count的值不是1000，不能保证原子性

synchronized & volatile 应用（懒汉单例模式）

/**
 * @author : fzz
 */
public class SingletonDemo {
    private volatile static SingletonDemo singletonDemo;

    public static SingletonDemo getSingletonDemo(){
        if(singletonDemo == null){
            synchronized (SingletonDemo.class){
                if (singletonDemo==null){
                    singletonDemo = new SingletonDemo();
                }
            }
        }
        return singletonDemo;
    }

    private SingletonDemo(){}
}

内置锁：

​ 每个java对象都可以用做一个实现的同步锁，这些锁称为内置锁。线程进入同步代码块（方法）时，会自动获取该锁；退出时，会自动释放该锁。获取所得唯一方法就是进入同步代码块（方法）。

互斥锁：

​ 内置锁是一个互斥锁，一个线程获取该锁，其他线程就会等待、或者阻塞。