JAVA多并发的本质

Android 并发

    通俗的解释：一次做两件事。

优点：
    
    提高资源利用率：当一个任务没有完全占用系统资源，可以利用并发来提供资源利用率，同时也能更快的完成任务。

    程序更精简: 提高效率，逻辑有清晰

    
    更好的相应程序：上传图片是，当界面还是正常运转没有卡死，图片也能正常上传，既保证界面被响应，有保证图片可以上传。

缺点：
  
      开线程需要占用更多资源
    
      设计并发框架不容易
    
      并发资源交互问题复杂
    
      子线程与主线程容易误调
      
      结果与预期不符合

 

 并发的原理是多线程

 并发的控制核心是锁。

 

锁的方式有以下两种：

        Java中每个对象都有一个锁，并且是唯一的。

    Synchronized 的三种方式

        1.修饰实例的方法

                class Lock implements Runable{
                        
                    public Synchronized  void  a(){ }

                    public void run(){
                        a();
                    }
                    
                }

                

                Lock lock=new Lock();
            
                Thread t1=new Thread(lock);
                Thread t2=new Thread(lock);
    

                t1.start();
                t2.start();

                t1.join();
                t2.join();

                Synchronized   锁是lock类对象，t1和t2用同一把锁

                class Lock implements Runable{
                        
                    public Synchronized  void  a(){ }

                    public void run(){
                        a();
                    }
                    
                }

                

                Lock lock=new Lock();
                Lock lock2=new Lock();
            
                Thread t1=new Thread(lock);
                Thread t2=new Thread(lock2);
    

                t1.start();
                t2.start();

                t1.join();
                t2.join();

                Synchronized   锁标记是lock类对象和lock2对象，t1和t2用的不是同一把锁    
                如果需要使用同一把锁，需要使用类锁 参考2 一个类只有一个类锁
                    
                            
        2.修饰静态方法

            public static Synchronized  void  a(){ }

        3.修饰代码块

             ....

 

  

 线程join()方法

在很多情况下，主线程生成并起动了子线程，如果子线程里要进行大量的耗时的运算，主线程往往将于子线程之前结束，但是如果主线程处理完其他的事务后，需要用到子线程的处理结果，也就是主线程需要等待
子线程执行完成之后再结束，这个时候就要用到join()方法了
 

 

Synchronized  原理

Object任何类的父类，存在wait()和notify()

            object.wait(); 线程没有执行完毕，释放锁等待状态

            object.notify();

Java是为了更好的处理高并发，在object中定义wait()和notify()

 在JVM中创建对象，对象在堆内存中的表现形式见下图

  

 

在JVM中创建对象，就会生成对象，对象头32位/64位（jdk 32位或者64位） 如下图：  hashcode class标识符  锁标记    (备注：每个对象都
会只有一把锁，存在对象的头部）
 

锁的本质： 就是定义了对象的内存信息 如下图：

 

缺点：

　           1）获取锁的线程执行完了该代码块，然后线程释放对锁的占有。（只有代码执行完了（或者异常），才会释放锁）；

　　        2）线程执行发生异常，此时JVM会让线程自动释放锁。
    
            这个获取锁的线程由于要等待IO或者其他原因（比如调用sleep方法）被阻塞了，但是又没有释放锁，其他线程便只能干巴巴地等待，试想一下，这多么影响程序执行效率（线程竞争非常消费资源）

            因此就需要有一种机制可以不让等待的线程一直无期限地等待下去（比如只等待一定的时间或者能够响应中断），通过Lock就可以办到。

　　            再举个例子：当有多个线程读写文件时，读操作和写操作会发生冲突现象，写操作和写操作会发生冲突现象，但是读操作和读操作不会发生冲突现象。但是采用synchronized关键字来实现同步的
话，就会导致一个问题：如果多个线程都只是进行读操作，所以当一个线程在进行读操作时，其他线程只能等待无法进行读操作。

　　            因此就需要一种机制来使得多个线程都只是进行读操作时，线程之间不会发生冲突，通过Lock就可以办到。

　　            另外，通过Lock可以知道线程有没有成功获取到锁。这个是synchronized无法办到的

 

    Synchronized  锁（锁优化）。基于JVM实现
         

  会根据线程运行自动进入执行锁的方式

    前提

    if(）{

        偏向锁

    }else if( ){

        亲量级锁  （释放锁时，锁对象不会被回收）

    }else if(){

        自旋锁

    }else if(){

        重量级锁

    }

    偏向锁 （一个线程）
         JDK1.6开始

         锁不仅存在多线程竞争，而且总是由同一线程获得。

         条件：当一个线程获得了锁，那么锁就进入偏向模式，当线程再次请求锁时，无需再做同步操作

        获取锁是非常耗时的 ,获取过程：  用户内存  》JVM内存  JVM内存中将objectmonitor  中owner 重新赋值，count+1。

         用户内存 (java 堆 属于 《app进程》)  进入去 JVM内存是耗时操作。JVM内存（系统内存）。

         偏向锁核心：当一个线程获得了锁，那么锁就进入偏向模式，当线程再次请求锁时，无需再做同步操作 ，即获取锁的过程，这样就省去了大量有关锁申请锁的操作，从而也就提供程序性能。 

    每一个线程都有独立的内存，执行的代码需要从主内存进行

    轻量级锁（两个）

    
        当出现两个线程，自动进入轻量级锁    
        
        两个线程交替同步进行，偏向锁失败，两个线程多次获取对象锁
        

        

    
    自旋锁
        
        当交替线程增多，出现同时两个线程获取资源，就是自动进入自旋锁

        自旋锁:虚拟机会让某一个线程随机空循环（进行交替等待）。
    
        因此虚拟机会让当前想要获取锁的线程做几个空循环（这也是称为自旋的原因），一般不会太久,
        50-100个循环 没有得到锁，进顺利进入临界区，如果还不能获得锁，那就会将线程在操作系统层面挂起。
        
    
    
    重量级锁

        当挂起的线程增多到一定程度之后，系统挂起的线程增多,就会进入重量级锁，每次不循环了，直接挂起。

?        当竞争线程尝试占用轻量级锁失败多次之后，轻量级锁就会膨胀为重量级锁，重量级线程指针指向竞争线程，竞争线程也会阻塞，等待轻量级线程释放锁后唤醒他。

        性能最好

            随机等待

 

 

Lock锁

 

Lock 是接口 （也就是一个标准）

    1）Lock不是Java语言内置的，synchronized是Java语言的关键字，因此是内置特性。Lock是一个类，通过这个类可以实现同步访问；

　 2）Lock和synchronized有一点非常大的不同，采用synchronized不需要用户去手动释放锁，当synchronized方法或者synchronized代码块执行完之后，系统会自动让线程释放对锁的占用；而Lock则必须要用户去
手动释放锁，如果没有主动释放锁，就有可能导致出现死锁现象。

 

.Lock和synchronized的选择：

　　总结来说，Lock和synchronized有以下几点不同：

　　1）Lock是一个接口，而synchronized是Java中的关键字，synchronized是内置的语言实现；

　　2）synchronized在发生异常时，会自动释放线程占有的锁，因此不会导致死锁现象发生；而Lock在发生异常时，如果没有主动通过unLock()去释放锁，则很可能造成死锁现象，因此使用Lock时需要在finally块中释放
锁；

　　3）Lock可以让等待锁的线程响应中断，而synchronized却不行，使用synchronized时，等待的线程会一直等待下去，不能够响应中断；（I/O和Synchronized都能相应中断，即不需要处理interruptionException异常
）

　　4）通过Lock可以知道有没有成功获取锁，而synchronized却无法办到。

　　5）Lock可以提高多个线程进行读操作的效率。

　　在性能上来说，如果竞争资源不激烈，两者的性能是差不多的，而当竞争资源非常激烈时（即有大量线程同时竞争），此时Lock的性能要远远优于synchronized。所以说，在具体使用时要根据适当情况选择。

最后锁的方式

 

　1.可重入锁

　　如果锁具备可重入性，则称作为可重入锁。像synchronized和ReentrantLock都是可重入锁，可重入性在我看来实际上表明了锁的分配机制：基于线程的分配，而不是基于方法调用的分配。举个简单的例子，当一个线
程执行到某个synchronized方法时，比如说method1，而在method1中会调用另外一个synchronized方法method2，此时线程不必重新去申请锁，而是可以直接执行方法method2。

原理：对象头32位中  存在count计数，当有线程进入就count 就+1，释放就-1，当有持有锁的线程再次进入，就继续+1（备注：一个线程能够重复去拿一把锁） 

        objectmonitor 是存在对象头部的锁信息。每个对象都会对应一个objectmonitor 

        参考https://www.cnblogs.com/549294286/p/3688829.html 

        每一个线程都有单独的内存。互相之间独立。运行时会copy主内存中的数据。
 

   class MyClass{

    public synchronized void method1(){
        method2();
    }
    
    public synchronized void method2(){
    
    }
 }
     　上述代码中的两个方法method1和method2都用synchronized修饰了，假如某一时刻，线程A执行到了method1，此时线程A获取了这个对象的锁，而由于method2也是synchronized方法，假如synchronized不具备可
重入性，此时线程A需要重新申请锁。但是这就会造成一个问题，因为线程A已经持有了该对象的锁，而又在申请获取该对象的锁，这样就会线程A一直等待永远不会获取到的锁。
而由于synchronized和Lock都具备可重入性，所以不会发生上述现象。

2.可中断锁

    可中断锁：顾名思义，就是可以相应中断的锁。

　　在Java中，synchronized就不是可中断锁，而Lock是可中断锁。

　　如果某一线程A正在执行锁中的代码，另一线程B正在等待获取该锁，可能由于等待时间过长，线程B不想等待了，想先处理其他事情，我们可以让它中断自己或者在别的线程中中断它，这种就是可中断锁。

　　在前面演示lockInterruptibly()的用法时已经体现了Lock的可中断性

3.公平锁

    公平锁即尽量以请求锁的顺序来获取锁。比如同是有多个线程在等待一个锁，当这个锁被释放时，等待时间最久的线程（最先请求的线程）会获得该所，这种就是公平锁。

　　非公平锁即无法保证锁的获取是按照请求锁的顺序进行的。这样就可能导致某个或者一些线程永远获取不到锁。

　　在Java中，synchronized就是非公平锁，它无法保证等待的线程获取锁的顺序。

　　而对于ReentrantLock和ReentrantReadWriteLock，它默认情况下是非公平锁，但是可以设置为公平锁。

4.读写锁
 
　  读写锁将对一个资源（比如文件）的访问分成了2个锁，一个读锁和一个写锁。

　　正因为有了读写锁，才使得多个线程之间的读操作不会发生冲突。

　　ReadWriteLock就是读写锁，它是一个接口，ReentrantReadWriteLock实现了这个接口。

　　可以通过readLock()获取读锁，通过writeLock()获取写锁