多线程与高并发 Synchronize

（1）概念：计算机的核心是CPU，它承担了所有的计算任务。它就像一座工厂，时刻在运行。假定工厂的电力有限，一次只能供给一个车间使用。也就是说，一个车间开工的时候，其他的车间必须停工。背后的含义就是，单个CPU一次只能运行一个任务。

进程就好比工厂车间，它代表CPU所能处理的单个任务。任一时刻，CPU总是运行一个进程，其它进程处于非运行状态
一个车间里，可以有很多工人。他们协同完成一个任务！（线程就好比车间里的工人。一个进程可以包括多个线程）
车间里的空间是工人们共享的，比如许多房间是每个工人都可以进出的。这象征一个进程的内存空间是共享的，每个线程都可以使用这些共享内存
可是每个房间的大小不同，有些房间最多只能容纳一个人，比如厕所。里面有人的时候，其他人就不能进去了。这代表一个线程使用某些共享内存时，其他线程必须等他结束，才能使用这一块内存
一个防止他人进入的简单方法，就是门口加一把锁。先到的人锁上门，后到的人看到上锁，就在门口排队，等锁打开在进去。这就叫“互斥锁”（Mutual exclusion，缩写Mutex）,防止多个线程同时读写某一块内存区域
还有些房间，可以同时容纳n个人，比如厨房。也就是说，如果人数大于n，多出来的人只能在外面等着。这好比某些内存区域，只能供给固定数目的线程使用
- 解决方法，就在门口挂n把锁。进去的人就取一把钥匙，出来时再把钥匙挂回原处。后到的人发现钥匙架空了，就知道必须在门口排队等着了。这种做法就叫“信号量”（Semaphore），用来保证多个线程不会互相冲突

（2）创建线程的几种方式：

　　https://www.cnblogs.com/xiaoxi/p/8303574.html(Future Callable FutureTask)讲解

package day_01;

import java.util.concurrent.*;

/**
 * @author: zdc
 * @date: 2020-03-18
 */
public class _1HowToCreateThread {
    //1.继承Thread类，覆写run方法
    static class MyThread extends Thread {
        @Override
        public void run() {
            System.out.println("hello mythread");
        }
    }
    //2.实现Runnable接口，实现run方法
    static class MyRun implements Runnable{
        @Override
        public void run() {
            System.out.println("hello myrun");
        }
    }
    //3.实现Callable接口，实现call方法
    static class MyCall implements Callable<String>{
        @Override
        public String call() throws Exception {
            System.out.println("hello mycall");
            return "sucess";
        }
    }

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //1
        new MyThread().start();
        //2
        new Thread(new MyRun()).start();
        //3
        new Thread(()-> System.out.println("hello my lambda"));

        //4 futuretask callable 
        FutureTask<String> futureTask = new FutureTask<>(new MyCall());
        Thread t = new Thread(futureTask);
        t.start();
        System.out.println(futureTask.get());  //阻塞式

        //5 future callable threadpool
        ExecutorService executorService = Executors.newCachedThreadPool();
        Future<String> future = executorService.submit(new MyCall());
        System.out.println(future.get());

        //6 submit有返回值，而execute没有    runnable threadpool
        executorService.execute(new MyRun());
        executorService.shutdown();
    }

}

(3) yield join讲解

yield()方法：暂停当前正在执行的线程对象，并执行其他线程。

yield()应该做的是让当前运行线程回到可运行状态，以允许具有相同优先级的其他线程获得运行机会。因此，使用yield()的目的是让相同优先级的线程之间能适当的轮转执行。但是，实际中无法保证yield()达到让步目的，因为让步的线程还有可能被线程调度程序再次选中。

结论：yield()从未导致线程转到等待/睡眠/阻塞状态。在大多数情况下，yield()将导致线程从运行状态转到可运行状态，但有可能没有效果。

jion()方法：线程实例的join()方法可以使得一个线程在另一个线程结束后再执行，即也就是说使得被调用的线程可以阻塞当前线程执行；

thread.Join把指定的线程加入到当前线程，可以将两个交替执行的线程合并为顺序执行的线程。

比如在线程B中调用了线程A的Join()方法，直到线程A执行完毕后，才会继续执行线程B。

package day_01;

import java.util.Timer;
import java.util.concurrent.TimeUnit;

/**
 * @author: zdc
 * @date: 2020-03-18
 */
public class _2YieldAndJoin {
    public static void main(String[] args) {
       // testYied();
        testJoin();
    }
  /*  Thread.yield()方法作用是：暂停当前正在执行的线程对象，并执行其他线程。
    yield()应该做的是让当前运行线程回到可运行状态，以允许具有相同优先级的其他线程获得运行机会。
    因此，使用yield()的目的是让相同优先级的线程之间能适当的轮转执行。但是，实际中无法保证yield()达到让步目的，
    因为让步的线程还有可能被线程调度程序再次选中。
    结论：yield()从未导致线程转到等待/睡眠/阻塞状态。在大多数情况下，yield()将导致线程从运行状态转到可运行状态，但有可能没有效果。*/
    public static void testYied(){
        new Thread(()->{
            for (int i = 0; i < 100; i++) {
                System.out.println("A"+i);
                if (i%10==0)
                    Thread.yield();
            }
        }).start();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                System.out.println("B"+i);
                if (i%10==0)
                    Thread.yield();
            }
        }).start();
    }
    //当前线程调用别的线程join后，当前线程会等待被调用的线程运行完再去执行。
    static void testJoin(){
       Thread t1 = new Thread(()->{
            for (int i = 0; i < 10; i++) {
                System.out.println("a"+i);
                try {
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
       t1.start();
        new Thread(()->{
            for (int i = 0; i < 100; i++) {
                System.out.println("b"+i);
                if(i==5){
                    try {
                        t1.join();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }

                try {
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }).start();
    }
}

（4）线程的状态转换

1:新建状态当我们new出一个线程并，并没有start时

2：Runnable状态：当线程调用start方法后。此时又可分为Ready就绪态和Running运行态。

就绪态：线程被扔进CPU的等待队列排队等待执行

运行态：当CPU真正运行该线程时。

package day_01;

import java.util.concurrent.TimeUnit;

/**
 * @author: zdc
 * @date: 2020-03-18
 */
public class _3ThreadState {
    public static void main(String[] args) {
        Thread thread = new Thread(new MyRunnable());
        System.out.println(thread.getState());
        thread.start();
        System.out.println(thread.getState());
    }
    static class MyRunnable implements Runnable{
        @Override
        public void run() {
            for (int i = 0; i < 10; i++) {
                System.out.println("hahah");
                try {
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

3：Terminated结束状态

4：在Runnable这个状态中有一些其他状态的变迁。

TimedWaiting等待 Thread.Sleep() 、TimeUnit.SECONDS.sleep() 、o.wait(time)等
Waiting等待　　o.wait() t.jion() lockSupport.park()等

线程挂起的概念：CPU调度执行线程时。从runing态扔出去就叫挂起。

(5)wait和notify的区别

最主要是sleep方法没有释放锁，而wait方法释放了锁，使得其他线程可以使用同步控制块或者方法。

sleep不出让系统资源；wait是进入线程等待池等待，出让系统资源，其他线程可以占用CPU。一般wait不会加时间限制，因为如果wait线程的运行资源不够，再出来也没用，要等待其他线程调用notify/notifyAll唤醒等待池中的所有线程，才会进入就绪队列等待OS分配系统资源。sleep(milliseconds)可以用时间指定使它自动唤醒过来，如果时间不到只能调用interrupt()强行打断。
Thread.Sleep(0)的作用是“触发操作系统立刻重新进行一次CPU竞争”。

（6）sychronized

1.只给写加锁，而未给读加锁，会产生脏读现象。

2.sychronized是可重入的 m1(m2) m1和m2方法都加了相同的锁。锁对象上有数字记录加了几次。

3.异常锁:当程序出现异常后，锁将被释放。因次需要在出现异常处catch处理。

package day_01;

import java.util.concurrent.TimeUnit;

/**
 * @author: zdc
 * @date: 2020-03-18
 */
public class _5Account {
    String name;
    double balance;

    public synchronized void set(String name, double balance) throws InterruptedException {
        this.name = name;
        TimeUnit.SECONDS.sleep(2);
        this.balance = balance;
    }

    public double getBalance(String name) {
        return this.balance;
    }

    public static void main(String[] args) throws InterruptedException {
        _5Account account = new _5Account();
        
        new Thread(() -> {
            try {
                account.set("zzz", 58);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();
        
        TimeUnit.SECONDS.sleep(1);
        System.out.println(account.getBalance("zzz"));
        
        TimeUnit.SECONDS.sleep(1);
        System.out.println(account.getBalance("zzz"));
    }
}

sychronized锁升级的概念

Synchronized实现原理

我们要知道对象在内存中的布局：

已知对象是存放在堆内存中的，对象大致可以分为三个部分，分别是对象头、实例变量和填充字节

知对象是存放在堆内存中的，对象大致可以分为三个部分，分别是对象头、实例变量和填充字节。

对象头的主要是由MarkWord和Klass Point(类型指针)组成，其中Klass Point是是对象指向它的类元数据的指针，虚拟机通过这个指针来确定这个对象是哪个类的实例，Mark Word用于存储对象自身的运行时数据。如果对象是数组对象，那么对象头占用3个字宽（Word），如果对象是非数组对象，那么对象头占用2个字宽。（1word = 2 Byte = 16 bit）
实例变量存储的是对象的属性信息，包括父类的属性信息，按照4字节对齐
填充字符，因为虚拟机要求对象字节必须是8字节的整数倍，填充字符就是用于凑齐这个整数倍的

Synchronized不论是修饰方法还是代码块，都是通过持有修饰对象的锁来实现同步，那么Synchronized锁对象是存在哪里的呢？答案是存在锁对象的对象头的MarkWord中。那么MarkWord在对象头中到底长什么样，也就是它到底存储了什么呢？

锁升级

https://blog.csdn.net/tongdanping/article/details/79647337

锁的4中状态：无锁状态、偏向锁状态、轻量级锁状态（自旋锁）、重量级锁状态

　　（1）偏向锁：

为什么要引入偏向锁？

因为经过HotSpot的作者大量的研究发现，大多数时候是不存在锁竞争的，常常是一个线程多次获得同一个锁，因此如果每次都要竞争锁会增大很多没有必要付出的代价，为了降低获取锁的代价，才引入的偏向锁。

偏向锁的升级

当线程1访问代码块并获取锁对象时，会在java对象头和栈帧中记录偏向的锁的threadID，因为偏向锁不会主动释放锁，因此以后线程1再次获取锁的时候，需要比较当前线程的threadID和Java对象头中的threadID是否一致，如果一致（还是线程1获取锁对象），则无需使用CAS来加锁、解锁；如果不一致（其他线程，如线程2要竞争锁对象，而偏向锁不会主动释放因此还是存储的线程1的threadID），那么需要查看Java对象头中记录的线程1是否存活，如果没有存活，那么锁对象被重置为无锁状态，其它线程（线程2）可以竞争将其设置为偏向锁；如果存活，那么立刻查找该线程（线程1）的栈帧信息，如果还是需要继续持有这个锁对象，那么暂停当前线程1，撤销偏向锁，升级为轻量级锁，如果线程1 不再使用该锁对象，那么将锁对象状态设为无锁状态，重新偏向新的线程。

偏向锁的取消：

偏向锁是默认开启的，而且开始时间一般是比应用程序启动慢几秒，如果不想有这个延迟，那么可以使用-XX:BiasedLockingStartUpDelay=0；

如果不想要偏向锁，那么可以通过-XX:-UseBiasedLocking = false来设置；

　　（2）轻量级锁（自旋锁）

为什么要引入轻量级锁？

轻量级锁考虑的是竞争锁对象的线程不多，而且线程持有锁的时间也不长的情景。因为阻塞线程需要CPU从用户态转到内核态，代价较大，如果刚刚阻塞不久这个锁就被释放了，那这个代价就有点得不偿失了，因此这个时候就干脆不阻塞这个线程，让它自旋这等待锁释放。

轻量级锁什么时候升级为重量级锁？

线程1获取轻量级锁时会先把锁对象的对象头MarkWord复制一份到线程1的栈帧中创建的用于存储锁记录的空间（称为DisplacedMarkWord），然后使用CAS把对象头中的内容替换为线程1存储的锁记录（DisplacedMarkWord）的地址；

如果在线程1复制对象头的同时（在线程1CAS之前），线程2也准备获取锁，复制了对象头到线程2的锁记录空间中，但是在线程2CAS的时候，发现线程1已经把对象头换了，线程2的CAS失败，那么线程2就尝试使用自旋锁来等待线程1释放锁。

但是如果自旋的时间太长也不行，因为自旋是要消耗CPU的，因此自旋的次数是有限制的，比如10次或者100次，如果自旋次数到了线程1还没有释放锁，或者线程1还在执行，线程2还在自旋等待，这时又有一个线程3过来竞争这个锁对象，那么这个时候轻量级锁就会膨胀为重量级锁。重量级锁把除了拥有锁的线程都阻塞，防止CPU空转。

*注意：为了避免无用的自旋，轻量级锁一旦膨胀为重量级锁就不会再降级为轻量级锁了；偏向锁升级为轻量级锁也不能再降级为偏向锁。一句话就是锁可以升级不可以降级，但是偏向锁状态可以被重置为无锁状态。

（3）这几种锁的优缺点（偏向锁、轻量级锁、重量级锁）

　　锁粗化
按理来说，同步块的作用范围应该尽可能小，仅在共享数据的实际作用域中才进行同步，这样做的目的是为了使需要同步的操作数量尽可能缩小，缩短阻塞时间，如果存在锁竞争，那么等待锁的线程也能尽快拿到锁。
但是加锁解锁也需要消耗资源，如果存在一系列的连续加锁解锁操作，可能会导致不必要的性能损耗。
锁粗化就是将多个连续的加锁、解锁操作连接在一起，扩展成一个范围更大的锁，避免频繁的加锁解锁操作。

　　锁消除
Java虚拟机在JIT编译时(可以简单理解为当某段代码即将第一次被执行时进行编译，又称即时编译)，通过对运行上下文的扫描，经过逃逸分析，去除不可能存在共享资源竞争的锁，通过这种方式消除没有必要的锁，可以节省毫无意义的请求锁时间

（7）volatile https://www.jianshu.com/p/ccfe24b63d87

如果一个变量被volatile修饰了，那么肯定可以保证每次读取这个变量值的时候得到的值是最新的，但是一旦需要对变量进行自增这样的非原子操作，就不会保证这个变量的原子性了。

举个栗子

一个变量i被volatile修饰，两个线程想对这个变量修改，都对其进行自增操作也就是i++，i++的过程可以分为三步，首先获取i的值，其次对i的值进行加1，最后将得到的新值写会到缓存中。
线程A首先得到了i的初始值100，但是还没来得及修改，就阻塞了，这时线程B开始了，它也得到了i的值，由于i的值未被修改，即使是被volatile修饰，主存的变量还没变化，那么线程B得到的值也是100，之后对其进行加1操作，得到101后，将新值写入到缓存中，再刷入主存中。根据可见性的原则，这个主存的值可以被其他线程可见。
问题来了，线程A已经读取到了i的值为100，也就是说读取的这个原子操作已经结束了，所以这个可见性来的有点晚，线程A阻塞结束后，继续将100这个值加1，得到101，再将值写到缓存，最后刷入主存，所以即便是volatile具有可见性，也不能保证对它修饰的变量具有原子性。