零、前言

由于一些技术点不太常用或业务上不需要使用，所以变成生疏或遗忘。最近有些时间了，整理了一下，简单的记录下来，做个笔记。越发觉得只有写下来的东西才不会被遗忘。

一、如何创建一个线程

我知道的常用的就是一共三种方式（还有两种是线程池），
要注意如果继承Runnable的话，线程启动时要使用thread.run，
而不是thread.start，如下:

另外可以通过线程池来Executors.newXXXThread(); 
或者可以使用new ForkJoin(num);

public class Thread_01 {
    public void start(){
        //第一种
        Thread thread=new Thread(()-> System.out.println("one..."));
        thread.start(); //start

        new ThreadCus1().run();//run

        new ThreadCus2().run(); //run 或 start
        new ThreadCus2().start();
    }

    //第二种
     static class ThreadCus1 implements Runnable { //继承Runnable

        @Override
        public void run() {
            System.out.println("two...");
        }
    }
    //第三种
     static class  ThreadCus2 extends  Thread{ //继承Thread
         @Override
         public void run() {
             System.out.println("cus2");
         }
     }
    public static void main(String[] args) {
        Thread_01 t=new Thread_01();
        t.start();
    }
}

二、Thread类内部方法

1.Thread.Sleep

Thread.Sleep(xxx)；执行这段代码的线程睡眠多少秒，什么是睡眠，
让出Cpu的使用权，记录当前执行位置，在睡眠时间的定时器结束之后在去抢

2.Thread.yield

1.  Thread.yield();//CPU的使用权让出一下，别人能不能抢到不管
2. 然后自己开抢

3.线程的状态变化

（盗图）

4 .interupt | stop

可以自己看看源码上已经不推荐使用了。

5.join

先看伪代码
Thread t1=new Thread(()->{
     Thread.sleep(1s);
     sout("t1 end");
});
Thread t2=new Thread(()->{
    sout（“t2 start”）
     t1.join();//等待t1完成后再继续进行
     sout("t2 end");
});
t2.start();
t1.start();
最后输出的结果就是 :
t2start
t1end
t2end

以上可以说明 join是等待其他线程完成之后 ,join调用着的线程才继续执行。

6.notify、notifyAll、wait

1.每个对象都有这三个方法，说明每个对象其实都可以作为锁来使用。
2.notify只会通知这个对象上等待的线程队列的第一个线程
3.notifyAll是通知所有这个对象上等待的线程
4.notify和notifyall不会主动让出锁。
5.wait方法会且只会等待其他线程notify或notifyAll后才会继续去抢锁，否则即使其他线程都挂了，
这个wait的线程也会继续wait，造成死锁。
6.notify后使用wait方法，这样可以主动的将锁给别人用，别人用完后 要记得感恩，使用notify或者notifyAll
告诉人家，谢谢你，我已经用完了，你继续用吧

三、synchronized

这里说的是hotspot jvm里的实现
每个对象头上有两位去记录当前持有该对象使用权的线程

锁了谁

  可以写在方法体 、也可以写在方法上，用在不同位置时，
  其锁的对象也不同，比如：
1.  Object o=new object();
    synchronized(o){...}  此时锁定的是 o 这个对象
2.public synchronized void fuck(){...}此时锁的是这个实例化的类对象，
   等同于在方法实现里写synchronize(this)，如果这个类是静态类，那锁的就是T.Class这个对象
3.public synchronized  static void fuck(){...}此时锁的是classLoader加载的类，就是T.Class对象


如果锁的对象本身属性改变，不会有影响，如果变成了其他对象，就完了，所以加上final是比较好的。

可重入锁

可重入锁（也必须是可重入锁）：同一个线程，同步方法m1调用同步方法m2，如果m1和m2使用的是同一把锁，那么就可以直接调用。

如果同步方法中程序出现了异常，会自动释放锁

锁升级

锁升级：
sync (object) 
 1.偏向锁：在第一个线程来访问时，会在对象头上有个markword，记录这个线程的ID，
 如果来一个线程A，线程A的id和对象头上记录的线程id相同，那么该线程就可以继续执行。
 2.自旋锁：如果有其他线程B进来想征用这个锁，就升级为自旋锁，发现这个锁被别人占用着，那线程B就走一个while循环，等着这把锁。
 3.如果B等了很多次后，还没有拿到锁，就升级为重量级锁（就是去操作系统那申请资源）（os锁）

结论： 
a. 锁不能降级、只能升级
b.执行时长，线程数长使用系统锁，执行时间短、线程数少用自旋锁。因为自旋是要消耗cpu资源。

Atomic的实现都是自旋锁。
锁的粒度是指 锁的细化和粗化，如果一个方法中很多的业务，但是只有一小端代码是需要加锁的，那只给这一段代码加锁。

自旋锁的特点

1.sychronized 如果升级到了 悲观锁后（os锁）时，其他抢这把锁的线程是阻塞着，不会消耗cpu。
2.自旋锁（cas：compareAndSet）是通过unsafe实现了原子性，是通过对比期待值的内存地址，
   a.不适应于执行时间长的逻辑块,因为 cas 是判断当前内存是否与期待值内存地址相同来设置目标值，
   如果不是期待值，就重新从主存中get值并设置为新的期待值，此过程一直是一个死循环，对长时间
   拿不到锁的线程来说 需要一直原地打转，对cpu有消耗。
   b.普通的CAS会发生ABA问题,ABA问题就是 一共有3个线程，分别为线程一、二、三，有一个变量m，
   线程一、二的目标是把m的值修改为B，线程三的目标是把m修改为A，这时，线程一和线程二执行时，
   由于一些原因，线程二 阻塞了，线程一执行成功，此时m的值变成了B，这时线程三把m又成功的修改
   为A，线程二开始执行，又将A修改为B。因为线程二执行的时候期待值和主存中的指向的地址都是A，
   这就是ABA问题。
     ABA现实中对应的例子：小明去取钱，想取100块钱，他的银行卡里有150，因为提款机年久失修，他点了一下没反应，他就去旁边的提款机上又点了一次，可以理解为这里是线程二（发生故障的提款机）和线程一（好的替换机），这两个线程同时执行，首先去卡里 get期望值为150，目标值肯定是150-100=50，线程一执行完成后，卡里还剩50块钱，这时线程二突然由于一些原因阻塞了（提款机突然不好使了），本来如果不阻塞的话，线程二目标值是150，结果卡里只剩50了，肯定会执行失败的，但是就真的发生了阻塞（提款机卡），而此时这次小明的朋友 给他转了100块钱（线程三执行并结束），然后线程二不阻塞了，发现卡里真的是150，因为（剩余50+朋友转100），结果线程二（坏提款机）又取出100块钱，这时小明没有发现 之前那个提款机好使了，钱已经取出来，他也没看到。
     ABA的解决方式：对值加上版本号，Atomic中提供了一个带版本号的CAS操作的类：
     AtomicStampedReference,下方图片有简单的实例：

不能lock的对象

不能用String常量，Integer Long ,基础类型中的值只要修改一下后，这个对象就会改变。

四、volatile

原理

1.保证线程可见性
2.禁止指令重排序

解释

1.线程将变量的从公共内存堆中拉到自己私有的工作区后，不能保证下次什么时候再去重新获取这个变量的最新值，所以不能保障当一个线程A修改了变量后，线程B可以立即获取到这个变量最新的值。而volatile可以保障线程之间这个变量的值是最新的。volatile的实现原理是MESI、.CPU的缓存一直性协议

volatile 可以保证线程可见性，但是不具备原子性，所以volatile不能代替synchronize的

2.禁止指令重排序，也是和cpu有关系的，比如代码层面的实现是：

例子一：
a=1;
b=2;
b=4;
cpu为了优化执行效率，很有可能将上述的执行顺序改成
b=2;
b=4;
a=1;

例子二：
Integer a=new Integer(8);
对象创建的过程可以简单分成4步：
1.创建一个栈对象a
2.申请一块内存，并设置初始值为0
3.将内存的值修改为8
4.将栈对象的指针指向这块内存

但是在超高并发的情况有可能出现：
1.创建一个栈对象a
2.申请一块内存，并设置初始化值为0
3.将栈对象的指针指向这块内存
4.指针a指向这块内存

这就是指令排序

结论

关于volatile 推荐一篇文章：
https://www.zhihu.com/question/329746124

这里写一些自己对volatile不能保证原子性的理解

《深入了解java虚拟机》中说：
 “观察加入volatile关键字和没有加入volatile关键字时所生成的汇编代码发现，加入volatile关键字时，
 会多出一个lock前缀指令。”
 
 lock前缀指令实际上相当于一个内存屏障（也成内存栅栏），内存屏障会提供3个功能：
 
1） 它确保指令重排序时不会把其后面的指令排到内存屏障之前的位置，也不会把前面的指令排到内存屏障的后面；
即在执行到内存屏障这句指令时，在它前面的操作已经全部完成。
2）它会强制将对缓存的修改操作立即写入主存；
3）如果是写操作，它会导致其他CPU中对应的缓存行无效。

既然可以保证在修改后 使得其他cpu中缓存行无效，从而会从主存中重新获取变量的值然后拷贝到线程自己的工作
区间，那就可以保证值是最新的啊，为什么还不能保证原子性呢？

答：还有从i++这个操作说起，比如 i 已经被volatile所修饰，i++这个操作大致分为3步。
假设 主存中 i=3;
线程一要去执行i++的操作
1. 获取 i的值 ，即：i =3
2. int tmp=i+1 ,假设这里有个临时变量去存储 i 这个值
3. i = tmp; 将tmp赋值给 i，假设在这一步，还没有把tmp赋值给i，所以不会将i刷新回 主存中，
   此时第二个线程也来操作 i 了，从主存中拿到了 i 的值为3，然后将i 赋值为了10，即执行了
   i=10的操作，并将i=10写回了主存，这时 线程二执行了写操作，会让线程一种的缓存行无效，
   也就是i=3的值在线程一中已经无效了，如果此时此刻，我们去执行tmp =i +1,那么 发现 i 的缓存无效
   后，就会去主存中拿i=10这个值，但是我们的线程一 都已经执行完tmp=i+1=4的操作了 ，
   已经不需要 get  i 的值了，所以接下来会执行 第三部 i=tmp 的命令，将 i 变成了 4，然后写回主存，
   这时主存上的i 变成了 4，显然 线程一和线程二的操作无法让i++ 保证原子性。
   也就是说 写操作的确会让其他cpu中对应的缓存行无效，但是如果其他cpu中已经使用过了这个
   缓存行（已经完成计算了），即使缓存行无效了 ，对人家也没有什么影响。并不能让人家cpu重新计算。

五、Atomic | CAS

能够保证原子性，因为他的操作都是CAS（优化自旋），没有加锁，
没有使用操作系统线程。
使用cpu原语进行读->比较->写

1.compareAndSet

上述的计算结果还是1，因为期待值是2，所以如果当前值和期待值
不一样的话，就不会修改这个值。如果是期望的值，说明没有人在我之前改过，

cas之后会细致更新一下

六、基于cas的一些新的锁

1.ReenTrantLock

reenTrantLock还是和synchronized进行对比 比较好

1.sync和reenlock都是独占锁，但当sync抢锁失败时会一直阻塞，
而后者通过tryLock方法抢锁失败时，会自动放弃，且可以指定尝
试抢锁的时间，但要注意的一点是：当tryLock的结果为false时 使
用lock.unlock会出异常

2.sync不需要手动的去释放锁，当占用锁的线程发生异常或线程
结束后会自动释放锁，但是reenlock需要在finaly中是显式的调用
lock.unlock();

3,reenlock可以可以监听线程的异常而自动释放锁,之后展开说

原理
reenTrantLock的原理是AQS（AbstractQueuedSynchroizer）
画了一个简单的图。

简单说一下lock.lock()的过程

2.countDownLaunch

我把它当做一个线程安全的计数器，不需要自己加锁来保证线程的安全，我用它写过让多个线程来分别执行一个事务，当某线程发生异常时，让所有事务回滚，反之所有线程提交事务，主线程await来控制是否执行回滚或者提交。

先上图

上图中 实例化了一个计数器，可计数为3，创建了三个线程，每个线程执行完后减一，主线程使用await
方法进行阻塞，等三个线程执行完后，阻塞解除并打印 “end wait”，切记是await，不是wait方法

同理可以使用 join来代替countdownlanch, 即：在await代码块上 将3个子线程join一次后，即等待3个子线程都结束后主线程再解除阻塞，如下图代码

但是countDown更灵活一些，完成可以在一个子线程中countDown 3次，这样也可以解除主线程上await
方法的阻塞

3.CyclicBarrier

循环栅栏，满足了阀值就把栅栏推倒，然后再立起来。我的理解就是人够了就发车

设置一个阀值，当await次数到达了这个阀值后，就会调用这个 Runable实现中的内容，下图例子中是打印了一条
消息“够了，老铁”，循环了101次后，打印了5次。

变换一下，在一个线程中for缓存101次，如下图：

会发现并不能打印出信息，说明这个await只在使用不同的线程调用时才会生效

Guava RateLimiter 

4.Phaser

Phaser 是让n个线程 按自己设定的阶段 按阶段执行，当线程数量到达了 指定的数量后，就会触发一次
阶段实现，然后可以选择前往下一个阶段或者离开注册。
通过
phaser.bulkRegister（数量）指定当前有多少线程时前往下一个阶段
phaser.arriveAndAwaitAdvance方法可以等待线程达到数量并前往下一个阶段
phaser.arriveAndDeregister 可以取消前往下一个阶段
继承Phaser类，重写onAdvance方法来控制在不同阶段时需要触发的实现
额外要说一点，arriveAndDeregister只能在最后一个阶段使用，在中间阶段使用时会报错（后续研究一下）
简单呈现一下代码，如下

public class TestPhaser_01 {
    MyPhaser p;
    private int id;

    public TestPhaser_01(int id, MyPhaser p) {
        this.p = p;
        this.id = id;
    }

    void origin() {
        a();
        b();
        c();
    }

    void a() {
        System.out.println(id + " finish  a");
        p.arriveAndAwaitAdvance();
    }

    void b() {
        System.out.println(id + " finish  b");
        p.arriveAndAwaitAdvance();
    }

    void c() {
        System.out.println(id + " finish  c");
        if (id == 3 || id == 4)
            p.arriveAndAwaitAdvance();
        else
            p.arriveAndDeregister();
    }
    public static void main(String[] args) {
        MyPhaser myPhaser = new MyPhaser();
        myPhaser.bulkRegister(7);

        for (int i = 0; i < 7; i++) {
            int tmp = i;
            Thread t = new Thread(() -> {
                TestPhaser_01 p = new TestPhaser_01(tmp, myPhaser);
                p.origin();
            });
            t.start();
        }
    }

    static class MyPhaser extends Phaser {

        @Override
        protected boolean onAdvance(int phase, int registeredParties) {
            switch (phase) {
                case 0:
                    System.out.println("第一阶段完成，当前参与人数为 ：" + registeredParties);
                    return false;

                case 1:
                    System.out.println("第二阶段完成，当前参与人数为 ：" + registeredParties);
                    return false;

                case 2:
                    System.out.println("第三阶段完成，当前参与人数为 ：" + registeredParties);
                    return true;
                default:
                    return true;
            }
        }
    }
}

5.重点：读写锁 ReadWriteLock

读锁：共享锁
写锁：排他锁=互斥锁

先说使用的原因

如果是使用ReenTrantLock时，这个锁 的 读读、读写、写写三种不同操作时都是互斥的，
所以效率比较低，那如果我们的读操作可以采用共享锁，只有写操作是排他锁，那么就
可以在读操作很多，写操作少的时候大大的提高效率，因此引出了ReadWriteLock，使用
起来很简单。只需要实例化一个对象，并在读方法时使用readLock对象进行lock，写方法
时使用writeLock对象进行lock就可以了

 public class ReadWriteLock_01 {
    public static void main(String[] args) {
        ReadWriteLock lock = new ReentrantReadWriteLock();
        
        Lock readLock = lock.readLock();
        Lock writeLock = lock.writeLock();
        
        read(readLock);
        write(writeLock);
    }

    static void read(Lock lock) {
        lock.lock();
        System.out.println("read");
    }

    static void write(Lock lock) {
        lock.lock();
        System.out.println("write");
    }
}
        

6.Semaphore

主要用途就是限流，n个线程，但是程序要求最多每次过m个线程，与线程池概念不同。
可以类比高速公路的收费站，一共5个收费口，就是限流。

下面是示例

7.Exchanger

我的理解是两个线程想要交换数值，先想交换的线程等待第二个线程完成交换后再继续执行
示例如下图

8.LockSupport

1.某线程内可以直接使用LockSupport的静态方法.park();来暂停当前线程
2.可以在其他线程中使用LockSupport的静态方法unPark（object t） 并将 某线程对象 作为参数传入,
可以让某线程继续运行，但是 同等条件下 却不能让线程t park。

七、java中的引用类型

1.分别四种类型：分别为: 强引用、软引用、弱引用，虚引用

1.new 出来的对象为强引用
2.softReference 创建出的对象为 软引用，它在gc时可能不被回收，只有在内存不够时才会回收
3.weakReference创建出来的对象为弱引用，gc时必被回收。一般用于容器中
4.虚引用用来直接内存中，比如jvm中的DerectByteBuffer，这部分内存是操作系统管理的，不属于虚拟机，虚引用的对象会将回收后的对象放入一个队列中。

ThreadLocal源码

和它的名字一样，线程私有，同一个ThreadLocal对象被不同的线程修改后 
就有不同的值，使用后一定要调用 remove方法，不然map中会有大量
null key的情况

下图描述了一下 ThreadLocal的源码实现图，已经为什么entry继承了WeakReference的原因，但是threadLocal 使用完之后要调用remove方法，该方法会将threadLocal从map中移除。

八、线程池

阿里规范中要求不可以使用Excutors提供的线程池，因为queue的
长度最长为Integer.max，如果到了这个值后就会OOM。

1.Runnable、Callable、Future

1.Runnable和Callable用途是一样的，执行一段想执行的逻辑，但是后者可以拥有返回值
2.Future 提供了拥有阻塞功能的get方法，举个例子，主线程中创建了一个线程池，主线程交了线程池一个任务：让它去把地球挖穿，线程池立刻将Future对象返回给了主线程，并说道：我们即将出发了，你该干什么就干什么去吧，实在没意思的话，你就用这个future.get()方法看我们挖，但是只要开始看就不能停下来了，直到我们挖穿地球为止，这时候主线程心想太好了，就去看了一会片儿，又吃了个苹果，顺便和邻居又生了个孩子，所有琐事都做完后，没事干了，实在太无聊了，那就看看他们挖怎么样了吧，于是调用了future.get(),  看了几分钟后 主线程又点后悔，但是他除了观看以外（阻塞），什么都不能做了，直到线程池挖穿了地球后，主线程才可以去做其他事情。
以上主线程 这样就实现了异步的效果，以下是示例代码

以上代码执行结果：

另外还有一些类是三者混合的衍生类，需要时可以自己看源码使用一下。

2.ThreadPoolExecutor源码分析

线程池的几种状态

盗图一下

   解释一下shutDown状态和stop状态
   stop是既不接受新的任务，也要干掉正在执行的任务
   shutDown是不接受新的任务，但是把正在执行的任务执行完
   之后工作线程数为0后，进入Tidying状态，然后执行钩子函数terminated（没有实现，有需要可以去重写。

execute

 public void execute(Runnable command) {
        if (command == null)
            throw new NullPointerException();
    
        int c = ctl.get();
        //1.如果线程池当前线程数小于核心线程数
        if (workerCountOf(c) < corePoolSize) {
            //addWorker创建一个核心线程执行任务
            if (addWorker(command, true))
                return;
            c = ctl.get();
        }
        //如果线程池的状态是running状态，且将该任务加入任务队列成功
        if (isRunning(c) && workQueue.offer(command)) {
            int recheck = ctl.get();
            //双重检查，因为上层if 判断后到现在位置可能有线程已经死亡 或者线程池可以已经shutdown了
            if (! isRunning(recheck) && remove(command))
                reject(command);
            //如果线程池的状态 是running状态 且核心线程 个数为0 ，则创建一个 max_size 中的线程去处理
            else if (workerCountOf(recheck) == 0)
                addWorker(null, false);
        }
        //线程不是running状态 或者 入队失败，就尝试创建maxSize的线程去处理，如果失败了，就采用拒绝策略
        else if (!addWorker(command, false))
            reject(command);
    }

直接上连接吧，我感觉这里自己看的不是很清楚

第一篇文章比较细，第二篇文章也可以看看，第三个我还没看

https://blog.csdn.net/LitterLy/article/details/107357979
https://blog.csdn.net/weixin_43934607/article/details/109089137
https://www.jianshu.com/p/a977ab6704d7

自己总结一下吧