并发编程

1、保证可见性

2、不保证原子性

3、防止指令重排序

小明在银行存有100元，他来取50元钱，有AB两个线程同时执行，但是A由于某种原因导致线程阻塞，B成功执行了，账户余额从100变成50，此时小红小红向小明汇款50元，线程C成功执行汇款操作，小米账户余额从50变成100，此时A线程继续执行，由于CAS拿到的值时100，所以可以成功更改成50，A线程执行完毕后，小明账户余额50，造成了有50元丢失

加入版本号即可解决该问题

1、修饰普通方法，锁着的是方法的调用者

2、修饰static静态方法，锁住的是类模板

3、修饰的是方法块时，锁住的是括号里的对象

1、总线锁

2、缓存锁

1、循环CAS

2、通过锁机制

解决方法

1、源代码

2、编译器优化重排序

3、指令并行重排序

4、内存系统重排序

5、最终序列

不论怎么重排序，程序运行的结果不变

在不改变程序运行结果的前提下，尽可能的提高并行度

好处：可以提高程序并行度，加快程序运行速度

坏处：对于并发的情况，存在数据依赖的程序可能会造成结果改变

NEW(还未执行start方法)

RUNNABLE（运行中，运行和就绪都称为运行中）

BLOCKED(阻塞状态)

WAITING(等待状态)

TIME-WAITING(超时等待，一定时间内未执行就不再执行)

TERMINATED（终止）

Thread.setDaemon(true)将线程设置为Daemon线程。

当程序不存在非守护线程的线程，程序结束

一般被用来作为日志线程和GC线程

Thread.sleep(1000)

⭐TimeUnit.SECONED.sleep(1)

优点

优点

函数式接口（有参有返回）
Function<String,String> function = (str)->{ return str+"ok"; };

判定型接口（有参返回布尔值）
Predicate<String> predicate = (Str)->{ return Str.isEmpty(); };

供给型接口（无参有返回）
Supplier<Integer> supplier = ()->{ return 1024; };

消费型接口（有参无返回）
Consumer<String> consumer = (str)->{ System.out.println(str); };

3个字宽

MarkWord

引用地址指针

数组长度

2个字宽

MarkWord

引用地址指针

偏向锁在jdk6，7默认开启，但是有延迟
可以通过参数关闭：-XX:BiasedLockingStartupDelay=0

如果程序中线程经常竞争资源，可以通过参数关闭偏向锁
-XX:-UseBiasedLocking=false（关闭后默认进入轻量级锁）

加锁：将对象头的MarkWord设置成当前线程

解锁：将对象头的MarkWord记录当前线程的信息置0

优点：加锁解锁不需要额外消耗，速度块

缺点：如果存在锁竞争，锁撤销会带来额外的消耗

适用场景：只有一个线程访问同步块

加锁：把对象头的MarkWod复制到锁记录（DisplacedMarkWord）
将对象头的MarkWord替换为指向锁记录的指针（CAS原子操作）

解锁：把对象头的锁记录指针题换成锁记录存储的MarkWord（CAS原子操作）

一旦锁升级成重量级锁后不会退回轻量级锁，线程争夺资源时不会自旋，而是阻塞

优点：线程不会阻塞，提高相应速度

缺点：自旋消耗CPU

适用场景：追求响应速度，同步块执行非常快

优点：锁竞争不会自旋，不消耗CPU

缺点：线程阻塞，响应时间长

适用场景：追求吞吐量，同步块执行时间长

private int number = 0;
private Lock lock = new ReentrantLock();
private Condition condition = lock.newCondition();

//生产
public void increase() throws InterruptedException {
    lock.lock();
    try{
        while(number > 0){ //这里不用if而用while是为了虚假唤醒，因为if只会判断一次，while是循环多次判断
            condition.await();
        }
        System.out.println(Thread.currentThread().getName() + " ==> " + ++number);
        condition.signalAll();
    }finally {
        lock.unlock();
    }
}

//消费
public void decrease() throws InterruptedException {
    lock.lock();
    try{
        while(number == 0){ //这里不用if而用while是为了虚假唤醒，因为if只会判断一次，while是循环多次判断
            condition.await();
        }
        System.out.println(Thread.currentThread().getName() + " ==> " + --number);
        condition.signalAll();
    }finally {
        lock.unlock();
   }
}

condition0.await()；//该监视器监视方法阻塞
condition1.signal()；//唤醒condition1监视器监视的方法

Semaphore semaphore = new Semaphore(3)；//资源数量

semaphore.acquire(); //获取信号量，信号量-1

semaphore.release(); //释放信号量，信号量+1

HashMap是线程不安全的

Hashtable的效率低

1、jdk1.7时，Segment继承了ReentrantLock，具备锁和释放锁的功能。（分段锁）
ConcurrentHashMap只有16个Segment，并且不会扩容，最多可以支持16个线程并发写。

2、JDK1.8时，放弃了锁分段的做法，采用CAS和synchronized方式处理并发。
以put操作为例，CAS方式确定key的数组下标，synchronized保证链表节点的同步效果。

head=tail=null

1、先head=tail=null

2、遍历参数集合元素

3、checkNotNull（e）检查节点是否为空，空则报异常

4、若head=null，则head=tail=newNode

5、若head != null，t.lazySetNext(newNode);
lazySetNext方法调用的是native方法

1、调用add(e)

2、add(e)调用offer(e)

3、判断e是否为null，是则抛出异常

4、不为空，则循环CAS插入节点

5、tail节点不总是尾节点，插入第偶数个节点时tail节点才是尾节点
这么做的目的是减少循环CAS更新tail节点，加快入队，提升效率

1、调用poll

2、当头节点不为空时，直接弹出头节点

3、当头节点为空时，弹出头节点的下一个节点，并循环CAS更新头节点
这么做的目的是减少循环CAS更新头节点的次数，加快出队，提升效率

基于数组实现的一个阻塞队列，在创建ArrayBlockingQueue对象时必须制定容量大小。

除了一个定长数组外，ArrayBlockingQueue内部还保存着两个整形变量，分别标识着队列的头部和尾部在数组中的位置。

默认情况下为非公平的。多线程并发存在资源竞争。

插入或删除元素时不会产生或销毁任何额外的对象实例

4组API

基于链表实现的一个阻塞队列，在创建LinkedBlockingQueue对象时如果不指定容量大小，则默认大小为Integer.MAX_VALUE
如果生产者的速度一旦大于消费者的速度，也许还没有等到队列满阻塞产生，系统内存就有可能已被消耗殆尽了

因为其对于生产者端和消费者端分别采用了独立的锁来控制数据同步
在高并发的情况下生产者和消费者可以并行地操作队列中的数据，以此来提高整个队列的并发性能

插入或删除元素时会生成一个额外的Node对象

按照元素的优先级对元素进行排序，按照优先级顺序出队，每次出队的元素都是优先级最高的元素。

注意，此阻塞队列为无界阻塞队列，即容量没有上限，生产者生产数据的速度绝对不能快于消费者消费数据的速度，否则最终耗尽所有的可用堆内存空间

在实现PriorityBlockingQueue时，内部控制线程同步的锁采用的是公平锁。

延时阻塞队列，DelayQueue中的元素只有当其指定的延迟时间到了，才能够从队列中获取到该元素。
DelayQueue也是一个无界队列，因此往队列中插入数据的操作（生产者）永远不会被阻塞，而只有获取数据的操作（消费者）才会被阻塞。

可以用DelayQueue实现一个管理超时未响应的连接队列

一种无缓冲的等待队列，类似于无中介的直接交易

声明一个SynchronousQueue有两种不同的方式，即构造方法传入一个布尔值，默认是false，即非公平锁

来一个拿一个，只有一个存储空间

操作

解释：任务分割出的子任务会添加到当前工作线程所维护的双端队列中，进入队列的头部。
当一个工作线程的队列里暂时没有任务时，它会随机从其他工作线程的队列的尾部获取一个任务

优点：：充分利用线程进行并行计算，减少了线程间的竞争。

缺点：在某些情况下还是存在竞争，比如双端队列里只有一个任务时。并
且该算法会消耗了更多的系统资源，比如创建多个线程和多个双端队列。

通常情况下我们不需要直接集成ForkJoinTask类，只需要继承它的子类

ForkJoinTask需要通过ForkJoinPool来执行

使用示例

AtomicBoolean：原子更新布尔类型

AtomicInteger：原子更新整型

AtomicLong：原子更新长整型

AtomicIntegerArray：原子更新整型数组里的元素。

AtomicLongArray：原子更新长整型数组里的元素。

AtomicReferenceArray：原子更新引用类型数组里的元素

AtomicIntegerArray类主要是提供原子的方式更新数组里的整型

AtomicReference：原子更新引用类型。

AtomicReferenceFieldUpdater：原子更新引用类型里的字段。

CountDownLatch countDownLatch = new CountDownLatch(6); 

countDownLatch.countDown();

countDownLatch.await();

CyclicBarrier cyclicBarrier = new CyclicBarrier(n, () -> {});

cyclicBarrier.await();

遗传算法

结果核对

Executors.newSingleThreadExecutor(); //单一线程的线程池

Executors.newFixedThreadPool(5); //固定线程的线程池

Executors.newCachedThreadPool(); //可变线程，数量可伸缩的线程池

1、ExecutorService pool = Executors.newCachedThreadPool();

2、pool.execute(()->{System.out.println(Thread.currentThread().getName() + " ok");});
     ⭐类似new Thread(()->{});

3、pool.shutdown();   //用完必须关闭，最好放在finally块中

FutureTask交由Executor执行

也可以直接用线程调用执行(futureTask.run())