java线程与并发

1 线程安全问题

  1.1 线程安全问题的主要诱因

      1   存在共享数据（也称为临界资源）。

      2  存在多条线程共同操作这些共享数据。

  1.2 解决问题的根本方法

        同一时刻有且只有一个线程在操作共享数据，其他线程必须等到该线程处理完数据后再对共享数据进行操作。

  1.3 互斥锁的特性

       互斥性：即在同一时间只允许一个线程持有某个对象锁，通过这种特性来实现多线程的协调机制，这样在同一时间只有一个线程对需要同步的代码块（复合操作）进行访问。互斥性也称为操作的原子性、

     可见性：必须确保在锁被释放之前，对共享变量所做的修改，对随后获得该锁的另一个线程是可见的（即在获得锁时应获得最新共享变量的值），否则另一个线程可能是在本地缓存的某个副本上继续操作，从而引起不一致。

     synchronized锁的不是代码，锁的都是对象。

1.4 根据获取锁的分类：获取对象锁和获取类锁

      1.4.1获取对象锁的两种用法：

           1.同步代码块（synchronized(this), synchronized(类实例对象) ），锁是小括号（）中的实例对象。

           2 同步非静态方法（synchronized method），锁是当前对象的实例对象。

       1.4.2 获取对象锁的两种用法

            1.同步代码块（synchronized(类.class) ），锁是小括号的（）中的类对象（class对象）。

            2.同步静态方法（synchronized static method ），锁是当前对象的类对象（class对象）。

       1.4.3 对象锁和类锁的总结

             1.有线程访问对象的同步代码时，另外的线程可以访问该对象的非同步代码块。

             2.若锁住的是同一个对象，一个线程在访问对象的同步代码块时，另一个访问对象的同步代码块的线程会被阻塞。

            3.若锁着的是同一个对象，一个线程在访问对象的同步方法时，另一个访问对象同步方法的线程会被阻塞。

            4.若锁住的是同一个对象，一个线程在访问对象的同步代码块时，另一个访问对象同步方法的线程会被阻塞。反之亦然。

            5.同一个类的不同对象的对象锁互不干扰。

            6.类锁由于也是一把特殊的对象锁，因此表现与1,2,3,4一致，而由于一个类只有一把对象锁，所以同一个类的不同对象使用类锁将会是同步的；

           7.类锁和对象锁互不干扰。

    

2 synchronized底层实现原理

2.1 实现synchronized的基础

         1 java对象头

         2 Monitor

2.2 对象在内存中的布局

      1 对象头            

      2  实例数据

      3  对其填充

 对象头的结构：synchronized使用的锁对象是存储在java对象头中的。

 

Mark  Word

 

 Monitor:每个java对象天生自带了一把看不见的锁。

      Mintor锁的竞争、获取与释放

   

 2.3 什么是重入

      从互斥锁的设计上来说，当一个线程试图操作一个由其他线程持有的对象锁的临界资源时，将会处于阻塞状态，但是当一个线程再次请求自己持有对象锁的临界资源时，这种情况属于重入，请求会成功。

       

2.4 早期synchronized 的效率低下的原因

       1 早期版本中，synchronized属于重量级锁，以来与Mutex Lock实现。

      2  线程之间的切换需要从用户态转换到核心态，开销比较大。 

      3 java6之后，synchronized性能得到了很大的提升

3 自旋锁与自适应锁

   3.1 自旋锁

           1.在许多情况下，共享数据的锁定状态持续时间较短，切换线程不值得。

           2. 通过让线程执行忙循环等待锁的释放，不让出CPU

           3. 缺点：若锁被其他线程长时间占用，会带来很多性能上的开销。

          4 用户可以使用PreBlockSpin参数调节自旋锁的等待时间。

  3.2 自适应自旋锁

           1 自旋的次数不在固定。

           2 由前一次在同一个锁上的自旋时间及锁的拥有者的状态来决定。

3.3 锁消除

     3.3.1  更彻底的优化

              JIT编译时，对运行上下文进行扫描，去除不可能存在竞争的锁。

      

          append方法查看源码发现是非静态锁方法  

 3.4 锁粗化

         另一种极端：

             通过扩大加锁的范围，避免返回加锁和解锁。

   JVM会检测到while中一连串的动作都会使用到append中的同步锁，JVM就会粗化加锁范围，使整个while是需要加一次锁就可以。

4 synchronized的四种状态

           1 无锁、偏向锁、 轻量级锁、重量级锁

   锁膨胀的方向：无锁、偏向锁、 轻量级锁、重量级锁

4.1 偏向锁：减少同一线程获取锁的代价

       大多数情况下，锁并不存在多线程竞争，总是由同一个线程多次获得。

 核心思想：

          如果一个线程获得了锁，那么锁就进入偏向模式，此时Mark Word的结构也变为偏向锁结构，当该线程再次请求锁时，无需再做任何同步操作，即获取锁的过程只需要检查Mark Word的锁标记位为偏向锁 以及当前线程ID等于Mark Word的Thread ID即可，这样就会省去大量有关锁申请的操作。

         不适用锁竞争比较激烈的多线程场合。

4.2 轻量级锁

         轻量级锁是由偏向锁升级来的，偏向锁运行在一个线程进入同步块的情况下，当第二个线程加入锁争用的时候，偏向锁就会升级为轻量级锁。

        适应场景：线程交替执行同步代码块。

       若存在同一时间多线程访问同一锁的情况，就是导致轻量级锁膨胀至重量级锁。

4.3 加锁的过程

    

    

4.4 解锁的过程

  

4.5 锁的内存语义

        1 当线程释放锁时，java内存模型就会把该线程对应的本地内存中的共享变量刷新到主内存中；

        2 当线程获取锁时，java内存模型就会把该线程对应的本地变量设置为无效，从而使得被监视器保护的临界区代码必须从主内存中读取共享变量。

 4.6 偏向锁、轻量级锁、重量级锁的汇总

 

 

5 synchronized 和 Reentrantlock 的区别 

    5.1 ReentrantLock(再入锁)

        1  位于java.util.comcurrent.locks 包

        2 和CountDownLatch、FutureTask、Semaphore一样基于AQS实现 （AQS就是一个抽象类）

        3 能够实现比synchronized 更加细粒的控制，如控制fairness

        4 调用lock（）后，必须调用unlock（）释放锁。

        5 性能未必比synchronized高，并且元素可重入的。

5.2 ReentrantLock公平性的设置

      1   ReentrantLock fairLock=new ReentrantLocke(true)

      2  参数为true时，倾向于将锁赋予等待时间最久的线程。

      3  公平锁：获取锁的顺序按照先后调用的Lock方法的顺序（慎用）

      4  非公平锁：抢占顺序不一定，看运气。

      5  synchronized是非公平锁。

public class ReentrantLockDemo implements Runnable{
    private static ReentrantLock lock=new ReentrantLock(true);
    @Override
    public void run(){
        while(true){
            try {
                lock.lock();
                System.out.println(Thread.currentThread().getName()+"get lock");
                Thread.sleep(1000);
            }catch (Exception e){
                e.printStackTrace();
            }finally {
                lock.unlock();
            }
        }
    }

    public static void main(String[] args) {
        ReentrantLockDemo rtld=new ReentrantLockDemo();
        Thread t1=new Thread(rtld);
        Thread t2=new Thread(rtld);
        t1.start();
        t2.start();
    }
}

       结果可以看到线程1和线程2 交替执行

Thread-0get lock
Thread-1get lock
Thread-0get lock
Thread-1get lock
Thread-0get lock
Thread-1get lock

   5.3  ReentrantLock 将锁对象化

       1 判断是否有等待的线程，或者某个特定线程，在排队等待获取锁。

       2 带超时的获取锁的尝试。

       3 感知有没有成功获取到锁。

 5.4 Synchronized和ReentrantLock的区别

      1 synchronizied是关键字，ReentrantLock是类。

      2 ReentrantLock可以对获取锁的等待时间进行设置，避免死锁。

      3 ReentrantLock可以获取各种锁的信息。

      4 ReentrantLock可以灵活实现多路通知。

      5 机制：Synchronized操作Mark Word  ，ReentrantLock调用Unsafe类的park方法。