JAVA线程回顾

多线程

多个并行的线程来完成个自的任务，优点是程序响应速度更快，程序性能得到提升。

并行执行与并发执行

 并发执行就是在单核CPU下，现成实际上是串行执行的，任务调度器将cpu的时间片分给不同的线程使用，但是cpu在线程间的切换很快，给人感觉是同时执行的(微观串行，宏观并行)

并行执行多核cpu下，每个CPU都可以单独调度运行线程，这个时候线程是并行执行的。

多线程带来的问题

线程安全问题

        加锁

并发编程

并发编程是一种通过设计程序使其能够同时处理多个任务的编程范式。

目标在于提高资源利用率，增强系统吞吐量。

并发编程 的核心挑战

多线程场景下，对共享资源的访问也是并发执行的

1.不可见性

一个线程对共享变量的修改，其他的线程不能立刻看到，称为不可见性。

JMM(JAVA内存模型):主内存与工作内存

Java内存模型中规定所有变量都存储在主内存中，每个线程都有自己的工作区内存，每个线程在对共享变量进行操作时，必须要从主内存中先读取到工作内存。

2乱序性

指令在执行过程中，为了优化将一些指令的顺序调整了，这种改变肯呢个会影响程序的运行结果。

{
    int a = 10;    //1
    int b = 20;    //2
    int c = a + b; //3
}

一般情况下会按照123的顺序进行，在一些情况下也会存在213这种情况。 

3.非原子性

原子性指一个或多个线程在CPU执行过程中不被中断的特性。

线程切换带来的非原子性问题，像A线程运行中断，切换执行B线程。

解决办法

1.volatile关键字

        可以解决不可见性，volatile关键字修饰的变量在一个线程修改后，对其他线程立即可见；

        同时解决乱序性，volatile关键字修饰的变量在执行过程中禁止指令重排序。

2.加锁

互斥锁，在A线程执行过程中，其他线程必须等待A线程执行完毕。

synchronized一定能够保证原子性，同时也能解决不可见性与乱序性问题。

3.原子变量

在juc包下面提供的一些类，可以在不加锁的情况下实现++操作的原子性。

这些类称之为原子类。

原子类

        原理：通过volatile+CAS机制实现的

加锁是一种阻塞式方式保证原子性

原子变量是一种非阻塞式 的方式保证原子性

CAS(Compare-And-Swap) 

 CAS是乐观锁的一种实现，采用自旋的思想，是一种轻量级的锁机制。

 当一个线程要对共享变量进行操作时，首先从内存中去除共享变量，

记录一个预估值，然后在工作区中进行修改，

当要将修改后的变量虚入主内存之前会判断是否主内存中的值一致，

如果一致说明没有线程对共享变量修改过，

否则需要重新获取共享变量，重复之前的操作。

这种方式线程不会被阻塞，但是在访问量大的情况下，会导致CPU消耗过高。 

ABA问题--->使用有版本号的原子类

 锁

1.乐观锁/悲观锁

乐观锁：其实就是不加锁，乐观的认为不加锁的并发操作是没有问题的，通常采用CAS算法

悲观锁：认为并发操作时一定会出现问题，使用JAVA中提供的锁进行加锁。

乐观锁适合读操作，悲观锁适合写操作

2.可重入锁

当一个线程进入到一个同步方法中，然后在此方法中要调用另一个同步方法，而且这两个方法共用一把锁，此时线程是可以进入到另一个同步方法中的。

public class Demo {
    synchronized void setA()throws Exception{
        System.out.println("A");
        setB();

    }
    synchronized void setB()throws Exception{
        System.out.println("B");
    }
}

public class Test {
    public static void main(String[] args) {
        Demo demo = new Demo();
        try {
            demo.setA();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

//A

//B

3.读写锁

ReentrantTreaWriteLock

可以实现写锁和读锁，共用一个锁实现；

读读不互斥，读写互斥，写写互斥。

加读锁是防止在另外的线程在此时写入数据，防止赃读。

4.分段锁

 并非是实际的锁，而是一种思想，用于将数据分段，并在每一个分段上单独加锁，将锁进一步细粒度化，提高并发效率。

这里是作者的理解：

        举个例子，这里有一个hashtable,整个加锁，有多个线程要进行访问，但是有一个锁直接锁住这个hashtable,线程就得排队，并发效率低；

        使用分段锁，对hashtable的每一个节点进行加锁，取消之前锁住整体的大锁，多个线程进行访问时，就可以从多个节点往下并行执行，提高了并发效率。

        多个线程过来，各个线程只要操作他要的节点下的数据，没有必要将整个hashtable进行加锁，限制了并发效率。

5.自旋锁

类比CAS，自行尝试，当线程抢锁失败后，重试几次

比较消耗CPU，适合加锁时间较短的场景

6.共享锁/独占锁

共享锁：多个线程共用一把锁，并发访问共享资源，读写锁中的读锁

独占锁：一个锁只能被一个线程持有，也叫互斥锁。synchronized,ReentrantLock,读写锁中的写锁

7.公平锁/非公平锁

公平锁：按照请求锁的顺序进行分配，哪个线程先来，哪个线程先获取锁

        ReentrantLock底层可以设置为公平锁         

非公平锁： 不按照请求顺序分配，哪个线程抢到，哪个线程获得

        synchronized，ReentrantLock(默认非公平锁)

8.偏向锁/轻量级锁/重量级锁

针对synchrpnized锁的状态分

无锁：没有任何线程使用锁对象

偏向锁：就是一段代码一直被一个线程访问，这个线程就会自动获取锁

轻量级锁：当锁是轻量级锁时，此时又有别的线程来访问，这时偏向锁就会升级为轻量级锁，其他线程就会通过自旋的方式尝试获取锁，不会阻塞，提高性能。

重量级锁：当锁是轻量级锁时，线程自旋获取达到一定次数还没有获取到锁时，就会进入阻塞，该锁膨胀为重量级锁，获取不到锁的线程进入阻塞，等待操作系统的调度。

作者理解，仅供参考，如有错误，敬请指出！

        偏向锁：某一共享资源，除了A线程外没有别的线程来对他进行操作，A就会自动获取锁。

        轻量级锁：这时X线程要对这一共享资源进行访问，这时之前的偏向锁就会升级成轻量级锁，X线程只能进行自旋获取锁。

        重量级锁：X线程自旋许多次还是无法获取到锁，进入阻塞了，锁这时就是重量级锁，X线程也只能等操作系统来调度了。

这些设计都是Java为了优化synchronized锁 

对象结构 

对象头中有一块区域MarkWord，储存对象自身运行时数据，就包含锁状态，hash码，GC分代年龄，线程持有的锁，偏向线程ID等。