JUC并发编程

什么是JUC

学习方法：官方文档+源码

java.util工具包

一些业务普通的线程代码Thread无法实现

Runnable 没有返回值、效率相比于Callable较低！

线程和进程

进程：是程序的一次执行过程，一个进程可以包含多个线程，至少包含一个！

Java默认有2个线程：main、GC

Java通过Thread、Runnable、Callable开启线程

Java真的可以开启线程吗？不可以，因为开启线程调用start0(private native void start0()😉，这是一个本地方法，使用底层C++；Java无法直接操作硬件

并发编程：并发和并行

并发(多线程操作同一个资源 )：CPU一核，模拟出来多条线程，快速交替

并行(多个人一起行走)：CPU多核，多个线程可以同时执行

public static void main(String[] args) {
    //获取cpu的核数
    System.out.println(Runtime.getRuntime().availableProcessors());//16
}

并发编程的本质：充分利用cpu资源

线程有几个状态：

public enum State {
    //线程新生
    NEW,

    //运行
    RUNNABLE,

    //阻塞
    BLOCKED,

    //等待，无限期
    WAITING,

   //超时等待，限时
    TIMED_WAITING,

    //终止
    TERMINATED;
}

wait/sleep的区别：

来自不同的类，wait来自Object类，sleep是Thread类的
关于锁的释放：wait会释放锁，sleep抱着锁睡觉，不会释放！
使用范围不同：wait必须在同步代码块中，sleep可以在任何地方睡
是否需要捕获异常：wait不需要捕获异常，sleep必须要捕获异常

常用的休眠方法：使用java.util.concurrent里的TimeUnit

Lock锁(重点)

传统Synchronized

package com.lin.demo01;

//基本的卖票例子
//真正的多线程开发，公司中的开发：降低耦合性
//线程就是单独的资源类，没有任何附属操作
//属性、方法
public class SaleTicketDemo01{
    public static void main(String[] args) {
        //并发：多线程操作同一个资源类,把资源类丢入线程
        Ticket ticket = new Ticket();

        //@FunctionalInterface 函数式接口 lambda表达式(参数)->{代码}
        new Thread(()->{
            for (int i = 0; i < 40; i++) {
                ticket.sale();
            }
        },"A").start();

        new Thread(()->{
            for (int i = 0; i < 40; i++) {
                ticket.sale();
            }
        },"B").start();

        new Thread(()->{
            for (int i = 0; i < 40; i++) {
                ticket.sale();
            }
        },"C").start();
    }


}

//资源类 OOP
class Ticket{
    private int number = 50;

    //买票的方式
    //synchronized本质：队列，锁
    public synchronized void sale(){
        if(number > 0){
            System.out.println(Thread.currentThread().getName()+"卖出了第"+number--+"张票，剩余"+number+"张票");
        }
    }
}

Lock接口

公平锁：十分公平，可以先来后到

非公平锁：十分不公平，可以插队(默认)

package com.lin.demo01;

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class SaleTicketDemo02 {
    public static void main(String[] args) {
        //并发：多线程操作同一个资源类,把资源类丢入线程
        Ticket2 ticket = new Ticket2();

        //@FunctionalInterface 函数式接口 lambda表达式(参数)->{代码}
        new Thread( ()->{for (int i = 0; i < 40; i++) ticket.sale();} ,"A").start();

        new Thread( ()->{for (int i = 0; i < 40; i++) ticket.sale();} ,"B").start();

        new Thread( ()->{for (int i = 0; i < 40; i++) ticket.sale();} ,"C").start();
    }


}

//Lock三部曲
//1.new Reentrantlock();
//2.lock.lock();
//3.finally{lock.unlock;}解锁
class Ticket2{
    private int number = 50;

    Lock lock = new ReentrantLock();
    //买票的方式
    //synchronized本质：队列，锁
    public void sale(){
        lock.lock();//加锁


        try {
            //业务代码
            if(number > 0){
                System.out.println(Thread.currentThread().getName()+"卖出了第"+number--+"张票，剩余"+number+"张票");
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            //解锁
            lock.unlock();
        }
    }
}

Synchronized 和 Lock区别

Synchronized是Java内置关键字，Lock是一个Java类
Synchronized无法判断获取锁的东西，Lock可以判断是否获取到了锁
Synchronized会自动释放锁，Lock必须要手动释放锁！如果不释放锁，死锁
Synchronized线程1(获得锁、阻塞)、线程2(等待，傻傻一直等)；Lock锁就不一定会等待下去(tryLock)
Synchronized可重入锁，不可以中断的，非公平；Lock可重入锁，可以判断锁，可以自己设置
Synchronized适合锁少量的代码同步问题，Lock锁适合锁大量的同步代码！

生产者和消费者问题

生产者和消费者问题Synshronized版

package com.lin.pc;


/**
 * 线程之间的通信问题：生产者和消费者问题 等待唤醒，通知唤醒
 * 线程交替执行  A    B 操作同一个变量 num = 0
 * A num+1
 * B num-1
 */
public class A {
    public static void main(String[] args) {
        Data data = new Data();

        new Thread( ()->{
            for (int i = 0; i < 10; i++) {
                try {
                    data.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        } ,"A").start();
        new Thread( ()->{
            for (int i = 0; i < 10; i++) {
                try {
                    data.decrement();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        } ,"B").start();

    }
}

//判断等待、业务、通知
class Data{//数字 资源类
    private int number = 0;
     //+1
    public synchronized void increment() throws InterruptedException {
        if(number != 0){
            //等待
            this.wait();
        }
        number++;
        System.out.println(Thread.currentThread().getName()+"===>"+number);
        //通知其他线程+1完毕
        this.notifyAll();
    }
    //-1
    public synchronized void decrement() throws InterruptedException {
        if(number == 0){
            //等待
            this.wait();
        }
        number--;
        System.out.println(Thread.currentThread().getName()+"===>"+number);
        //通知其他线程-1完毕
        this.notifyAll();
    }

问题存在：多个线程A B C D四个线程！虚假唤醒问题

if改为while判断

package com.lin.pc;


/**
 * 线程之间的通信问题：生产者和消费者问题 等待唤醒，通知唤醒
 * 线程交替执行  A    B 操作同一个变量 num = 0
 * A num+1
 * B num-1
 */
public class A {
    public static void main(String[] args) {
        Data data = new Data();

        new Thread( ()->{
            for (int i = 0; i < 10; i++) {
                try {
                    data.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        } ,"A").start();
        new Thread( ()->{
            for (int i = 0; i < 10; i++) {
                try {
                    data.decrement();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        } ,"B").start();

        new Thread( ()->{
            for (int i = 0; i < 10; i++) {
                try {
                    data.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        } ,"C").start();

        new Thread( ()->{
            for (int i = 0; i < 10; i++) {
                try {
                    data.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        } ,"D").start();

    }
}

//判断等待、业务、通知
class Data{//数字 资源类
    private int number = 0;
     //+1
    public synchronized void increment() throws InterruptedException {
        while(number != 0){
            //等待
            this.wait();
        }
        number++;
        System.out.println(Thread.currentThread().getName()+"===>"+number);
        //通知其他线程+1完毕
        this.notifyAll();
    }
    //-1
    public synchronized void decrement() throws InterruptedException {
        while(number == 0){
            //等待
            this.wait();
        }
        number--;
        System.out.println(Thread.currentThread().getName()+"===>"+number);
        //通知其他线程-1完毕
        this.notifyAll();
    }
}

JUC版生产者消费者问题

通过lock找到Condition

代码实现：

package com.lin.pc;

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class B {
    public static void main(String[] args) {
        Data2 data = new Data2();


        new Thread( ()->{
            for (int i = 0; i < 10; i++) {
                try {
                    data.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        } ,"A").start();
        new Thread( ()->{
            for (int i = 0; i < 10; i++) {
                try {
                    data.decrement();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        } ,"B").start();

        new Thread( ()->{
            for (int i = 0; i < 10; i++) {
                try {
                    data.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        } ,"C").start();

        new Thread( ()->{
            for (int i = 0; i < 10; i++) {
                try {
                    data.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        } ,"D").start();

    }
}

//判断等待、业务、通知
class Data2{//数字 资源类
    private int number = 0;

    Lock lock = new ReentrantLock();
    Condition condition = lock.newCondition();

    //condition.await();   等待
    //condition.signalAll();    唤醒全部
    //+1
    public void increment() throws InterruptedException {
        try {
            lock.lock();
            //业务代码
            while(number != 0){
                //等待
                condition.await();
            }
            number++;
            System.out.println(Thread.currentThread().getName()+"===>"+number);
            //通知其他线程+1完毕
            condition.signalAll();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }

    }
    //-1
    public  void decrement() throws InterruptedException {
        try {
            lock.lock();
            //业务代码
            while(number == 0){
                //等待
                condition.await();
            }
            number--;
            System.out.println(Thread.currentThread().getName()+"===>"+number);
            //通知其他线程-1完毕
            condition.signalAll();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }



    }
}

任何一个新的技术绝对不是仅仅覆盖原来的技术，一定会有优势和补充

Condition 精准通知和唤醒线程

代码测试：

package com.lin.pc;

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 *A执行完调用B，B执行完调用C，C执行完调用A
 */
public class C {
    public static void main(String[] args) {
        Data3 data3 = new Data3();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                data3.printA();
            }
        },"A").start();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                data3.printB();
            }
        },"B").start();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                data3.printC();
            }
        },"C").start();
    }
}

class Data3{//资源类 Lock

    private Lock lock = new ReentrantLock();
    private Condition condition1 = lock.newCondition();
    private Condition condition2 = lock.newCondition();
    private Condition condition3 = lock.newCondition();
    private int number = 1;//1A  2B 3C

    public void printA(){
        try {
            lock.lock();
            //业务代码,判断->执行->通知
            while(number != 1){
                //等待
                condition1.await();
            }
            System.out.println(Thread.currentThread().getName() +"--->AAA");
            //唤醒指定的人:B
            number = 2;
            condition2.signal();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }

    }

    public void printB(){
        try {
            lock.lock();
            //业务代码,判断->执行->通知
            while(number != 2){
                //等待
                condition2.await();
            }
            System.out.println(Thread.currentThread().getName() +"--->BBB");
            //唤醒指定的人:B
            number = 3;
            condition3.signal();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
    public void printC(){
        try {
            lock.lock();
            //业务代码,判断->执行->通知
            while(number != 3){
                //等待
                condition3.await();
            }
            System.out.println(Thread.currentThread().getName() +"--->CCC");
            //唤醒指定的人:B
            number = 1;
            condition1.signal();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }



}

八锁现象彻底理解锁

锁是什么，如何判断锁的是谁

package com.lin.lock8;

import java.util.concurrent.TimeUnit;

/**
 * 8锁，就是关于锁的8个问题
 * 1.标准情况下，两个线程先打印 发短信 还是打电话？ 1.发短信 2.打电话
 * 2.sendSms延迟4秒，两个线程先打印 发短信 还是打电话？ 1.发短信 2.打电话
 */
public class Test1 {
    public static void main(String[] args) {
        Phone phone = new Phone();

        //锁的存在
        new Thread(()->{
            phone.sendSms();
        },"A").start();

        //捕获异常
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        new Thread(()->{
            phone.call();
        },"B").start();

    }
}

class Phone{
    //synchronized锁的对象是方法的调用者！
    //两个对象用的是同一个锁，谁先拿到谁执行！
    public synchronized void sendSms(){
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("发短信");
    }
    public synchronized void call(){
        System.out.println("打电话");
    }
}

package com.lin.lock8;

import java.util.concurrent.TimeUnit;

/**
 * 3.增加了一个普通方法，先执行发短信还是hello？  普通方法
 * 4.两个对象，两个同步方法，先发短信还是打电话   1.打电话  2.发短信
 */
public class Test2 {
    public static void main(String[] args) {
        //两个对象，两个调用者，两把锁
        Phone2 phone1 = new Phone2();
        Phone2 phone2 = new Phone2();

        //锁的存在
        new Thread(()->{
            phone1.sendSms();
        },"A").start();

        //捕获异常
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        new Thread(()->{
            phone2.call();
        },"B").start();

    }
}

class Phone2{
    //synchronized锁的对象是方法的调用者！
    //两个对象用的是同一个锁，谁先拿到谁执行！
    public synchronized void sendSms(){
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("发短信");
    }
    public synchronized void call(){
        System.out.println("打电话");
    }

    //这里没有锁！不是同步方法，不受锁的影响
    public void hello(){
        System.out.println("hello");
    }
}

package com.lin.lock8;

import java.util.concurrent.TimeUnit;

/**
 * 5.增加两个静态同步方法，只有一个对象，先打印发短信还是打电话？发短信
 * 6.两个对象，两个静态同步方法，先打印发短信还是打电话？ 发短信
 */
public class Test3 {
    public static void main(String[] args) {
        //两个对象，两个调用者，两把锁
        Phone3 phone1 = new Phone3();
        Phone3 phone2 = new Phone3();

        //锁的存在
        new Thread(()->{
            phone1.sendSms();
        },"A").start();

        //捕获异常
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        new Thread(()->{
            phone2.call();
        },"B").start();

    }
}

//Phone只有唯一的class对象
class Phone3{
    //synchronized锁的对象是方法的调用者！
    //static静态方法
    //类一加载就有了！锁的是Class
    public static synchronized void sendSms(){
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("发短信");
    }
    public static synchronized void call(){
        System.out.println("打电话");
    }

}

package com.lin.lock8;

import java.util.concurrent.TimeUnit;

/**
 * 7.一个静态同步方法，一个普通同步方法，只有一个对象，先发短信还是打电话？ 打电话
 * 8.一个静态同步方法，一个普通同步方法，两个对象，先发短信还是打电话？ 打电话
 */
public class Test4 {
    public static void main(String[] args) {
        //两个对象，两个调用者，两把锁
        Phone4 phone1 = new Phone4();
        Phone4 phone2 = new Phone4();

        //锁的存在
        new Thread(()->{
            phone1.sendSms();
        },"A").start();

        //捕获异常
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        new Thread(()->{
            phone2.call();
        },"B").start();

    }
}

//Phone只有唯一的class对象
class Phone4{
    //静态同步方法，锁的是class类模板
    public static synchronized void sendSms(){
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("发短信");
    }

    //普通同步方法，锁的是调用者
    public synchronized void call(){
        System.out.println("打电话");
    }

}

总结：

new：this 具体的一个手机

static：Class唯一的一个模板

sychronized作用在普通方法上锁的是对象，作用在静态方法上锁的类

CopyOnWriteArrayList

List不安全

单线程的情况下，线程安全

package com.lin.unsafe;

import java.util.Arrays;
import java.util.List;

public class ListTest {
    public static void main(String[] args) {
        List<String> list = Arrays.asList("1","2","3");
        list.forEach(System.out::println);
    }
}

并发情况下报错

package com.lin.unsafe;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.UUID;
//java.util.ConcurrentModificationException 并发修改异常
public class ListTest {
    public static void main(String[] args) {
        //并发下ArrayList不安全
        List<String> list = new ArrayList<>();
        for (int i = 0; i < 10; i++) {
            new Thread(()->{
                list.add(UUID.randomUUID().toString().substring(0,5));
                System.out.println(list);
            },String.valueOf(i)).start();

        }
    }
}

解决方法：

package com.lin.unsafe;

import java.util.*;
import java.util.concurrent.CopyOnWriteArrayList;

//java.util.ConcurrentModificationException 并发修改异常
public class ListTest {
    public static void main(String[] args) {
        //并发下ArrayList不安全
        List<String> list = new CopyOnWriteArrayList<>();

        /**
         * 解决方案：
         * 1.List<String> list = new Vector<>();
         * 2.List<String> list = Collections.synchronizedList(new ArrayList<>());使用集合工具类
         * 3.List<String> list = new CopyOnWriteArrayList<>();
         */

        //CopyOnWrite写入时复制  COW   计算机程序设计领域的一种优化策略
        //多个线程调用的时候，list读取的时候是固定的，写入的时候可能会覆盖
        //写入的时候避免覆盖，造成数据问题

        //读写分离MyCat
        //CopyOnWriteArrayList比Vector 好在哪里？
        //Vector用的是synchronized，效率低
        for(int i = 1;i <= 10;i++){
            new Thread(()->{
                list.add(UUID.randomUUID().toString().substring(0,5));
                System.out.println(list);
            },String.valueOf(i)).start();

        }
    }
}

CopyOnWriteArraySet

Set set = new HashSet<>();

package com.lin.unsafe;


import java.util.Set;
import java.util.UUID;
import java.util.concurrent.CopyOnWriteArraySet;

//java.util.ConcurrentModificationException
public class SetTest {
    public static void main(String[] args) {
        Set<String> set = new CopyOnWriteArraySet<>();
        /**
         * 解决方法：
         * 1.Set<String> set = Collections.synchronizedSet(new HashSet<>());
         * 2.Set<String> set = new CopyOnWriteArraySet<>();
         */
        for (int i = 1; i <= 30; i++) {
            new Thread(()->{
                set.add(UUID.randomUUID().toString().substring(0,5));
                System.out.println(set);
            },String.valueOf(i)).start();
        }
    }
}

HashSet底层就是HashMap

public HashSet() {
    map = new HashMap<>();
}
//add  set的本质就是map的 key，是无法重复的！
public boolean add(E e) {
    return map.put(e, PRESENT)==null;
}

private static final Object PRESENT = new Object();//不变的值

ConcurrentHashMap

HashMap不安全

HashMap的基本操作

Map<String, String> map = new HashMap<>();

package com.lin.unsafe;

import java.util.Map;
import java.util.UUID;
import java.util.concurrent.ConcurrentHashMap;

//java.util.ConcurrentModificationException
public class MapTest {
    public static void main(String[] args) {
        //map是这样用的吗？不是，工作中不用
        // 默认等价于什么？new HashMap<>(16,0.75)//初始容量、加载因子
        Map<String, String> map = new ConcurrentHashMap<>();
        //

        for (int i = 1; i <= 30; i++) {
            new Thread(()->{
                map.put(Thread.currentThread().getName(), UUID.randomUUID().toString().substring(0,5));
                System.out.println(map);
            },String.valueOf(i)).start();
        }
    }
}

Callable

1.可以有返回值

2.可以抛出异常

3.方法不同，run()/call()

代码测试：

package com.lin.callabletest;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

public class CallableTest {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //new Thread(new Runnable()).start();
        //new Thread(new FutureTask<V>( Callable )).start();
        //new Thread().start();//怎么启动callable
        MyThread thread = new MyThread();
        FutureTask futureTask = new FutureTask(thread);
        //适配类
        new Thread(futureTask,"A").start();
         new Thread(futureTask,"B").start();//结果会被缓存,效率高

        Integer o  = (Integer)futureTask.get();//获取Callable的返回结果
        //get方法可能会产生阻塞！把他放到最后或者使用异步通信
        System.out.println(o);
    }
}

class MyThread implements Callable<Integer>{
    @Override
    public Integer call() {
        System.out.println("call()");
        return 1234;
    }
}

常用的辅助类

CountDownLatch

package com.lin.add;

import java.util.concurrent.CountDownLatch;

//减法计数器
public class CountDownLatchDemo {
    public static void main(String[] args) throws InterruptedException {
        //总数是6,必须要执行任务的时候再使用
        CountDownLatch countDownLatch = new CountDownLatch(6);

        for (int i = 1; i <= 6; i++) {
            new Thread(()->{
                System.out.println(Thread.currentThread().getName()+"GO");
                countDownLatch.countDown();//数量-1
            },String.valueOf(i)).start();
        }

        countDownLatch.await();//等待计数器归0后，然后再向下执行
        System.out.println("Close Door");
    }
}

原理：

countDownLatch.countDown();//数量-1
countDownLatch.await();//等待计数器归0

每次有线程调用countDown数量-1，假设计数器变为0，countDownLatch.await()就会被唤醒，继续执行

CyclicBarrier

加法计数器

package com.lin.add;

import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;

public class CyclicBarrierDemo {
    public static void main(String[] args) {
        /**
         * 集齐七颗龙珠召唤神龙
         *
         */
        //召唤龙珠的线程
        CyclicBarrier cyclicBarrier = new CyclicBarrier(7,()->{
            System.out.println("召唤神龙成功！");
        });


        for (int i = 1; i <= 7; i++) {
            final int temp = i;
            //lambda能操作到变量i吗
            new Thread(()->{
                System.out.println(Thread.currentThread().getName()+"收集了"+temp+"颗龙珠");

                try {
                    cyclicBarrier.await();//等待
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } catch (BrokenBarrierException e) {
                    e.printStackTrace();
                }
            }).start();
        }
    }
}

Semaphore

一个计数信号量。在概念上，信号量维持一组许可证。如果有必要，每个acquire()都会阻塞，直到许可证可用，然后才能使用它。每个release()添加许可证，潜在地释放阻塞获取方。但是，没有使用实际的许可证对象; Semaphore只保留可用数量的计数，并相应地执行。

抢车位！

6车--3个停车位置

package com.lin.add;

import java.util.concurrent.Semaphore;
import java.util.concurrent.TimeUnit;
//6车--3个停车位置
public class SemaphoreDemo {
    public static void main(String[] args) {
        //线程数量：停车位!限流
        Semaphore semaphore = new Semaphore(3);

        for (int i = 1; i <= 6; i++) {
            new Thread(()->{
                //acquire()得到
                try {
                    semaphore.acquire();
                    System.out.println(Thread.currentThread().getName()+"抢到车位");
                    TimeUnit.SECONDS.sleep(2);
                    System.out.println(Thread.currentThread().getName()+"离开车位");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }finally{
                    semaphore.release();
                }
                //release()释放
            },String.valueOf(i)).start();
        }
    }
}

原理：

semaphore.acquire();获得，假设已经满了，等待，等待被释放为止！

semaphore.release();释放，会将当前信号量释放+1，唤醒等待的线程

作用：多个共享资源互斥的使用、并发限流，控制最大的线程数

读写锁ReadWriteLock

package com.lin.rw;

import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

public class ReadWriteLockDemo {
    public static void main(String[] args) {
        MyCacheLock myCache = new MyCacheLock();

        //写入
        for (int i = 1; i <= 5; i++) {
            final int temp = i;
            new Thread(()->{
                myCache.put(temp+"",temp+"");
            },String.valueOf(i)).start();
        }

        //读取
        for (int i = 1; i <= 5; i++) {
            final int temp = i;
            new Thread(()->{
                myCache.get(temp+"");
            },String.valueOf(i)).start();
        }

    }
}

//加锁
class MyCacheLock{
    private volatile Map<String,Object> map = new HashMap<>();
    //读写锁：更加细粒度的控制
    private ReadWriteLock readWriteLock= new ReentrantReadWriteLock();

    //存，一个写的过程，写入时候希望同时只有一个线程
    public void put(String key,Object value){
        readWriteLock.writeLock().lock();

        try {
            System.out.println(Thread.currentThread().getName()+"写入"+key);
            map.put(key,value);
            System.out.println(Thread.currentThread().getName()+"写入成功"+key);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            readWriteLock.writeLock().unlock();
        }

    }
    //取，读的过程，所有人都可以读
    public void get(String key){
        readWriteLock.readLock().lock();

        try {
            System.out.println(Thread.currentThread().getName()+"读取"+key);
            Object o = map.get(key);
            System.out.println(Thread.currentThread().getName()+"读取成功"+key);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            readWriteLock.readLock().unlock();
        }
    }
}
/**
 * 自定义缓存
 */
class MyCache{
    private volatile Map<String,Object> map = new HashMap<>();

    //存，一个写的过程
    public void put(String key,Object value){
        System.out.println(Thread.currentThread().getName()+"写入"+key);
        map.put(key,value);
        System.out.println(Thread.currentThread().getName()+"写入成功"+key);
    }
    //取，读的过程
    public void get(String key){
        System.out.println(Thread.currentThread().getName()+"读取"+key);
        Object o = map.get(key);
        System.out.println(Thread.currentThread().getName()+"读取成功"+key);
    }
}

ReadWriteLock

读-读可以共存！

读-写不能共存！

写-写不能共存！

独占锁：写锁，一次只能被一个线程占有

共享锁：读锁，多个线程可以同时占有

阻塞队列BlockingQueue

什么情况下我们会使用阻塞队列：多线程并发处理，线程池！

学会使用队列

添加、移除

四组API

方式	抛出异常	有返回值，不抛出异常	阻塞等待	超时等待
添加	add	offeer	put	offer(参数)
移除	remove	poll	take	poll(参数)
判断队列首	element	peek	-	-

抛出异常

/**
 * 抛出异常
 */
public static void test1(){
    //队列的大小
    ArrayBlockingQueue blockingQueue = new ArrayBlockingQueue<>(3);

    System.out.println(blockingQueue.add("a"));
    System.out.println(blockingQueue.add("b"));
    System.out.println(blockingQueue.add("c"));

    //java.lang.IllegalStateException:Queue full抛出异常！
    //System.out.println(blockingQueue.add("d"));
    
    System.out.println(blockingQueue.element());//查看队首元素是谁  a

    System.out.println(blockingQueue.remove());
    System.out.println(blockingQueue.remove());
    System.out.println(blockingQueue.remove());
    
    //java.util.NoSuchElementException:
    System.out.println(blockingQueue.remove());
}

有返回值，不抛出异常

public static void test2(){
    //队列的大小
    ArrayBlockingQueue blockingQueue = new ArrayBlockingQueue<>(3);

    System.out.println(blockingQueue.offer("a"));
    System.out.println(blockingQueue.offer("b"));
    System.out.println(blockingQueue.offer("c"));

    //System.out.println(blockingQueue.offer("d"));//false 不抛出异常！

    System.out.println(blockingQueue.peek());//检测队首元素
    System.out.println(blockingQueue.poll());
    System.out.println(blockingQueue.poll());
    System.out.println(blockingQueue.poll());
    System.out.println(blockingQueue.poll());//null
}

阻塞等待

public static void test3() throws InterruptedException {
    //队列的大小
    ArrayBlockingQueue blockingQueue = new ArrayBlockingQueue<>(3);

    //一直阻塞
    blockingQueue.put("a");
    blockingQueue.put("b");
    blockingQueue.put("c");
    //blockingQueue.put("d");//队列没有位置，一直等待

    System.out.println(blockingQueue.take());
    System.out.println(blockingQueue.take());
    System.out.println(blockingQueue.take());
    System.out.println(blockingQueue.take());//没有这个元素，一直阻塞
}

超时等待

public static void test4() throws InterruptedException {
    //队列的大小
    ArrayBlockingQueue blockingQueue = new ArrayBlockingQueue<>(3);

    blockingQueue.offer("a");
    blockingQueue.offer("b");
    blockingQueue.offer("c");
    //blockingQueue.offer("d",2,TimeUnit.SECONDS);//等待超时2秒就退出

    System.out.println(blockingQueue.poll());
    System.out.println(blockingQueue.poll());
    System.out.println(blockingQueue.poll());
    blockingQueue.poll(2,TimeUnit.SECONDS);
}

同步队列SynchronousQueue

没有容量

进去一个元素，必须等待取出来之后才能再往里面放一个元素！put，take

package com.lin.bq;

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.SynchronousQueue;
import java.util.concurrent.TimeUnit;

/**
 * 同步队列
 * 和其他的BlockingQueue不一样，SynchronousQueue不存储元素
 * put了一个元素，必须从里面先take取出来，否则不能再put进去
 */
public class SynchronizedQueueDemo {
    public static void main(String[] args) {
        BlockingQueue<String> blockingQueue = new SynchronousQueue<>();//同步队列

        new Thread(()->{
            try {
                System.out.println(Thread.currentThread().getName()+"put 1");
                blockingQueue.put("1");
                System.out.println(Thread.currentThread().getName()+"put 2");
                blockingQueue.put("2");
                System.out.println(Thread.currentThread().getName()+"put 3");
                blockingQueue.put("3");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"t1").start();


        new Thread(()->{
            try {
                TimeUnit.SECONDS.sleep(3);
                System.out.println(Thread.currentThread().getName()+"--->"+blockingQueue.take());
                TimeUnit.SECONDS.sleep(3);
                System.out.println(Thread.currentThread().getName()+"--->"+blockingQueue.take());
                TimeUnit.SECONDS.sleep(3);
                System.out.println(Thread.currentThread().getName()+"--->"+blockingQueue.take());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"t2").start();
    }
}

线程池

线程池：3大方法、7大参数、4种拒绝策略

池化技术

程序的运行本质是：占用系统资源！优化资源的使用！==> 池化技术

线程池、连接池、内存池、对象池....创建，销毁十分浪费资源

池化技术：事先准备好一些资源，有人要用就来我这里拿，用完之后还给我

线程池的好处：降低资源消耗；提高响应速度；方便管理

线程复用、可以控制最大并发数、管理线程

3大方法

package com.lin.pool;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

//Executors工具类、3大方法
//使用了线程池之后，要使用线程池来创建线程
public class Demo01 {
    public static void main(String[] args) {
        //ExecutorService threadPool = Executors.newSingleThreadExecutor();//单个线程
        //ExecutorService threadPool =Executors.newFixedThreadPool(5);//创建一个固定的线程池的大小  5
        ExecutorService threadPool =Executors.newCachedThreadPool();//可伸缩的，遇强则强，遇弱则弱

        try {
            for (int i = 0; i < 10; i++) {
                threadPool.execute(()->{
                    System.out.println(Thread.currentThread().getName()+"线程使用");
                });
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            //线程池用完，程序结束，关闭线程池
            threadPool.shutdown();
        }

    }
}

7大参数

源码分析

public static ExecutorService newSingleThreadExecutor() {
    return new FinalizableDelegatedExecutorService
        (new ThreadPoolExecutor(1, 1,
                                0L, TimeUnit.MILLISECONDS,
                                new LinkedBlockingQueue<Runnable>()));
}

public static ExecutorService newFixedThreadPool(int nThreads) {
    return new ThreadPoolExecutor(nThreads, nThreads,
                                  0L, TimeUnit.MILLISECONDS,
                                  new LinkedBlockingQueue<Runnable>());
}

public static ExecutorService newCachedThreadPool() {
    return new ThreadPoolExecutor(0, Integer.MAX_VALUE,//21亿
                                  60L, TimeUnit.SECONDS,
                                  new SynchronousQueue<Runnable>());
}

本质ThreadPoolExecutor

public ThreadPoolExecutor(int corePoolSize,//核心线程池大小
                          int maximumPoolSize,//最大线程池大小
                          long keepAliveTime,//超时没人调用就会释放
                          TimeUnit unit,//超时单位
                          BlockingQueue<Runnable> workQueue,//阻塞队列
                          ThreadFactory threadFactory,//线程工厂，创建线程，一般不用动
                          RejectedExecutionHandler handler//拒绝策) {
    if (corePoolSize < 0 ||
        maximumPoolSize <= 0 ||
        maximumPoolSize < corePoolSize ||
        keepAliveTime < 0)
        throw new IllegalArgumentException();
    if (workQueue == null || threadFactory == null || handler == null)
        throw new NullPointerException();
    this.acc = System.getSecurityManager() == null ?
            null :
            AccessController.getContext();
    this.corePoolSize = corePoolSize;
    this.maximumPoolSize = maximumPoolSize;
    this.workQueue = workQueue;
    this.keepAliveTime = unit.toNanos(keepAliveTime);
    this.threadFactory = threadFactory;
    this.handler = handler;
}

关闭Max窗口的时间

手动创建线程池：

四种拒绝策略

package com.lin.pool;

import java.util.concurrent.*;

public class Demo02 {
    public static void main(String[] args) {
        //自定义线程池
        ExecutorService threadPool = new ThreadPoolExecutor(
                2,
                5,
                3,
                TimeUnit.SECONDS,
                new LinkedBlockingQueue<>(3),//候客区
                Executors.defaultThreadFactory(),
                
                /*new ThreadPoolExecutor.AbortPolicy());//拒绝策列的一种，服务口和等待队列都满了的时候，还有人进来，抛出异常*/
                /*new ThreadPoolExecutor.CallerRunsPolicy());//哪来的回哪去（main处理）*/
                /*new ThreadPoolExecutor.DiscardPolicy());//拒绝策列的一种，会丢掉多余的任务，不会抛出异常*/
                new ThreadPoolExecutor.DiscardOldestPolicy()//拒绝策列的一种，服务口和等待队列都满了的时候，后面进来的人会尝试去和第一个竞争
        );

        try {
            //最大承载 Deque + max
            for (int i = 1; i <= 5; i++) {
                threadPool.execute(()->{
                    System.out.println(Thread.currentThread().getName()+"线程使用");
                });
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            //线程池用完，程序结束，关闭线程池
            threadPool.shutdown();
        }

    }
}

了解IO密集型、CPU密集型(调优)

最大线程到底该如何定义？

1.CPU密集型：CPU几核，就定义为几，可以保证CPU的效率最高

Runtime.getRuntime().availableProcessors();//获取cpu核数

2.IO密集型：判断程序中十分消耗IO的线程有多少个，大于这个数(一般设置两倍)

程序中有15个大型任务，IO十分占用资源！至少留15个线程处理

四大函数式接口

新时代的程序员：lambda表达式、链式编程、函数式接口、Stream流式计算

函数式接口：只有一个方法的接口

@FunctionalInterface
public interface Runnable {
    public abstract void run();
}

//超级多
//简化编程模型，在新版本的框架中大量应用！
//forEach(消费者类型的函数式接口)

Function函数式接口

package com.lin.function;

import java.util.function.Function;

/**
 * Function函数型接口,有一个输入和输出参数
 * 只要是函数式接口，就可以用lambda表达式简化
 */
public class Demo01 {
    public static void main(String[] args) {
        //工具类：输出输入的值
//        Function<String,String> function = new Function<String,String>(){
//            @Override
//            public String apply(String str) {
//                return str;
//            }
//        };

        Function<String,String> function = (str)->{return str;};

        System.out.println(function.apply("asd"));
    }
}

Predicate断定型接口

package com.lin.function;

import java.util.function.Predicate;

/**
 * 断定型接口：有一个输入参数，返回值只能是 布尔值！
 */
public class Demo02 {
    public static void main(String[] args) {
        //判断字符串是否为空
//        Predicate<String> predicate = new Predicate<String>(){
//            @Override
//            public boolean test(String s) {
//                return s.isEmpty();
//            }
//        };
        Predicate<String> predicate =(s)->{return s.isEmpty();};

        System.out.println(predicate.test(""));
    }
}

Consumer消费型接口

package com.lin.function;

import java.util.function.Consumer;

/**
 * Consumer消费型接口：只有输入，没有返回值
 */
public class Demo03 {
    public static void main(String[] args) {
//        Consumer<String> consumer = new Consumer<String>(){
//            @Override
//            public void accept(String s) {
//                System.out.println(s);
//            }
//        };

        Consumer<String> consumer = (s)->{System.out.println(s);};
        consumer.accept("asd");
    }

}

Supplier供给型接口

package com.lin.function;

import java.util.function.Supplier;

/**
 * Supplier,供给型接口，没有参数，只有返回值
 */
public class Demo04 {
    public static void main(String[] args) {
//        Supplier<Integer> supplier = new Supplier<Integer>(){
//            @Override
//            public Integer get() {
//                System.out.println("get()");
//                return 1024;
//            }
//        };
        Supplier<Integer> supplier =()->{return 1024;};
        System.out.println(supplier.get());
    }

}

Stream流式计算

什么是Stream流式计算

存储+计算

存储：集合、MySQL(本质就是存储东西)

计算都应该交给流来操作！

package com.lin.stream;


import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

//有参，无惨构造，get、set、toString方法！
@Data
@NoArgsConstructor
@AllArgsConstructor
public class User {
    private int id;
    private String name;
    private int age;
}

package com.lin.stream;

import java.util.Arrays;
import java.util.List;
import java.util.Locale;

/**
 * 题目要求:一分钟内完成此题，只能用一行代码实现!
 * 现在有5个用户!筛选：
 * 1、ID 必须是偶数
 * 2、年龄必须大于23岁
 * 3、用户名转为大写字母
 * 4、用户名字母倒着排序
 * 5、只输出一个用户!
 */
public class Test {
    public static void main(String[] args) {
        User u1 = new User(1, "a", 21);
        User u2 = new User(2, "b", 22);
        User u3 = new User(3, "c", 23);
        User u4 = new User(4, "d", 24);
        User u5 = new User(6, "e", 25);
        //集合就是存储
        List<User> list = Arrays.asList(u1, u2, u3, u4, u5);

        //计算交给Stream流
        list.stream()
                .filter(u->{return u.getId()%2==0;})
                .filter(u->{return u.getAge()>23;})
                .map(u->{return u.getName().toUpperCase();})
                .sorted((x,y)->{return y.compareTo(x);})
                .limit(1)
                .forEach(System.out::println);
    }
}

ForkJoin

什么是ForkJoin

ForkJoin在JDK1.7，并行执行任务！提高效率，大数据量！

大数据：Map Reduce(把大任务拆分为小任务)

Fork Join特点：工作窃取

这个里面维护的都是双端队列

代码示例：

package com.lin.forkjoin;

import java.util.concurrent.ExecutionException;
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.ForkJoinTask;
import java.util.concurrent.RecursiveTask;
import java.util.stream.LongStream;

/**
 * 求和计算的任务
 * ForkJoin Stream并行流
 * 如何使用ForkJoin
 * 1.forkJoinPool通过它来执行
 * 2.计算任务forkJoinPool.execute(ForkJoinTask<?> task)
 * 3.类要继承RecursiveTask
 */
public class ForkJoinDemo {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        test1();//6129
        test2();//5425
        test3();//132
    }
    //普通求和
    public static void test1(){
        Long sum = 0L;
        long start = System.currentTimeMillis();

        for (Long i = 1L; i < 10_0000_0000; i++) {
            sum += i ;
        }

        long end = System.currentTimeMillis();
        System.out.println("sum = "+sum+"时间："+(end-start));
    }
    //使用ForkJoin
    public static void test2() throws ExecutionException, InterruptedException {
        long start = System.currentTimeMillis();
        ForkJoinPool forkJoinPool = new ForkJoinPool();
        ForkJoinTask<Long> submit = forkJoinPool.submit(new SumForkJoinTask(0L, 10_0000_0000L));//forkJoinPool.execute执行任务没有结果；submit提提交任务有结果
        Long sum = submit.get();
        long end = System.currentTimeMillis();
        System.out.println("sum = "+sum+"时间："+(end-start));
    }
    //使用Stream并行流
    public static void test3(){
        long start = System.currentTimeMillis();

        //range()左开右开  rangeClosed()左开右闭
        long sum = LongStream.rangeClosed(0L, 10_0000_0000L).parallel().reduce(0, Long::sum);

        long end = System.currentTimeMillis();
        System.out.println("sum = "+sum+"时间："+(end-start));
    }
}

class SumForkJoinTask extends RecursiveTask<Long>{
    private Long start;
    private Long end;

    //临界值
    private Long temp = 10000L;

    public SumForkJoinTask(Long start, Long end) {
        this.start = start;
        this.end = end;
    }


    //计算方法
    @Override
    protected Long compute() {
        if((end - start) < temp) {
            Long sum = 0L;
            for (Long i = start; i < end; i++) {
                sum += i ;
            }
            return sum;
        }else{//forkJoin
            //分支合并计算
            long middle = (start + end)/2;//中间值
            SumForkJoinTask task1 = new SumForkJoinTask(start,middle);
            task1.fork();//拆分任务，把任务压入线程队列
            SumForkJoinTask task2 = new SumForkJoinTask(middle+1,end);
            task2.fork();//拆分任务，把任务压入线程队列

            return task1.join() + task2.join();

        }
    }
}

异步回调

Future 设计的初衷：对将来的某个事件的结果进行建模

package com.lin.future;

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;


/**
 * 异步调用：CompletableFuture//Ajax
 * 异步执行
 * 成功回调
 * 失败回调
 */
public class Demo01 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //没有返回值的runAsync异步回调
        CompletableFuture<Void> completableFuture = CompletableFuture.runAsync(()->{

            System.out.println(Thread.currentThread().getName()+"runAsync===>Void");
        });

        System.out.println("1111");
        completableFuture.get();//获取阻塞执行结果
    }
}

package com.lin.future;

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;

public class Demo02 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //有返回值的异步回调
        CompletableFuture<Integer> completableFuture = CompletableFuture.supplyAsync(() -> {
            System.out.println(Thread.currentThread().getName()+"supplyAsync=>Integer");
            int i = 10/0;
            return 1024;
        });

        System.out.println(completableFuture.whenComplete((t, u) -> {
            System.out.println("t===>" + t);//正常的返回结果
            System.out.println("u===>" + u);//u为错误信息
        }).exceptionally((e) -> {
            System.out.println(e.getMessage());
            return 404;
        }).get());

    }
}

JMM

请你谈谈你对Volatile的理解

Volatile是Java虚拟机提供的轻量级的同步机制

保证可见性
不保证原子性
禁止指令重排

什么是JMM

JMM：是Java内存模型，不存在的东西，概念！是一种约定

关于JMM的一些同步的约定：

线程在解锁前，必须把共享变量(线程当前独享的工作内存)立刻刷新回主存
线程加锁前，必须读取主存中的最新值到工作内存中！
加锁和解锁是同一把锁

线程工作内存、主内存

八种操作：

问题是：线程B修改了值，但是线程A不能及时看见

内存交互操作有8种，虚拟机实现必须保证每一个操作都是原子的，不可在分的（对于double和long类型的变量来说，load、store、read和write操作在某些平台上允许例外）

lock （锁定）：作用于主内存的变量，把一个变量标识为线程独占状态
unlock （解锁）：作用于主内存的变量，它把一个处于锁定状态的变量释放出来，释放后的变量才可以被其他线程锁定
read （读取）：作用于主内存变量，它把一个变量的值从主内存传输到线程的工作内存中，以便随后的load动作使用
load （载入）：作用于工作内存的变量，它把read操作从主存中变量放入工作内存中
use （使用）：作用于工作内存中的变量，它把工作内存中的变量传输给执行引擎，每当虚拟机遇到一个需要使用到变量的值，就会使用到这个指令
assign （赋值）：作用于工作内存中的变量，它把一个从执行引擎中接受到的值放入工作内存的变量副本中
store （存储）：作用于主内存中的变量，它把一个从工作内存中一个变量的值传送到主内存中，以便后续的write使用
write （写入）：作用于主内存中的变量，它把store操作从工作内存中得到的变量的值放入主内存的变量中

JMM对这八种指令的使用，制定了如下规则：

不允许read和load、store和write操作之一单独出现。即使用了read必须load，使用了store必须write
不允许线程丢弃它最近的assign操作，即工作变量的数据改变了之后，必须告知主存
不允许一个线程将没有assign的数据从工作内存同步回主内存
一个新的变量必须在主内存中诞生，不允许工作内存直接使用一个未被初始化的变量。就是对变量实施use、store操作之前，必须经过assign和load操作
一个变量同一时间只有一个线程能对其进行lock。多次lock后，必须执行相同次数的unlock才能解锁
如果对一个变量进行lock操作，会清空所有工作内存中此变量的值，在执行引擎使用这个变量前，必须重新load或assign操作初始化变量的值
如果一个变量没有被lock，就不能对其进行unlock操作。也不能unlock一个被其他线程锁住的变量
对一个变量进行unlock操作之前，必须把此变量同步回主内存

问题：程序不知道主内存的值已经被修改过了

Volatile

1.保证可见性

package com.lin.volatiletest;

import java.util.concurrent.TimeUnit;

public class JMMDemo {
    //不加volatile，程序就会死循环！
    //加volatile可以保证可见性
    private volatile static int num = 0;
    public static void main(String[] args) {//main

        new Thread(()->{//线程1 对主内存的变化不知道
            while(num == 0){

            }
        },"1").start();

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

        num = 1;
        System.out.println(num);
    }
}

2.不保证原子性

原子性：不可分割

线程A在执行任务的时候，不能被打扰的，也不能被分割，要么同时成功，要么同时失败

package com.lin.volatiletest;

/**
 * 不保证原子性
 */
public class VolatileDemo02 {
    private volatile static int num = 0 ;
    public static void add(){
        num++;
    }

    public static void main(String[] args) {
        //理论上num结果为20000
        for (int i = 1; i <= 20; i++) {
            new Thread(()->{
                for (int j = 0; j < 1000; j++) {
                    add();
                }
            }).start();
        }

        while(Thread.activeCount()>2){//main GC
            Thread.yield();
        }
        System.out.println(Thread.currentThread().getName()+"===>"+num);//main===>17926
    }
}

输出结果是不确定的，因为不保证原子性

如果不加 lock 和 synchronized ，怎么样保证原子性

使用原子类，解决原子性问题

package com.lin.volatiletest;

import java.util.concurrent.atomic.AtomicInteger;

/**
 * 不保证原子性
 */
public class VolatileDemo02 {
    private volatile static AtomicInteger num = new AtomicInteger(0) ;
    public static void add(){
        //num++;//不是一个原子性操作
        num.getAndIncrement();//AtomicInteger + 1 方法，底层用CAS
    }

    public static void main(String[] args) {
        //理论上num结果为20000
        for (int i = 1; i <= 20; i++) {
            new Thread(()->{
                for (int j = 0; j < 1000; j++) {
                    add();
                }
            }).start();
        }

        while(Thread.activeCount()>2){//main GC
            Thread.yield();
        }
        System.out.println(Thread.currentThread().getName()+"===>"+num);//main===>17926
    }
}

原子类的底层直接和操作系统挂钩！在内存中修改值！Unsafe类是一个很特殊的存在！

3.禁止指令重排

什么是指令重排：计算机并不是按照程序写的那样去执行的

源代码->编译器优化的重排->指令并行也可能会重拍->内存系统也会重排->执行

处理器在进行指令重排的时候，考虑数据之间的依赖性

int x = 1;//1
int y = 2;//2
x = x + 5;//3
y = x * x;//4

我们所期望的：1234 但是可能执行的时候会变成 2134 1324
不可能是 4123！

可能造成影响的结果：a b x y 这四个值默认都是 0；

线程A	线程B
x = a	y = b
b = 1	a = 2

正常的结果： x = 0；y = 0；但是可能由于指令重排

线程A	线程B
b = 1	a = 2
x = a	y = b

指令重排导致的异常结果： x = 2；y = 1；

volatile可以避免指令重排：

内存屏障，理解为CPU指令。作用：

保证特定操作的执行顺序
可以保证某些变量的内存可见性(利用这些特性volatile实现了可见性)

Volatile是可以保持可见性。不能保证原子性，由于内存屏障，可以保证避免指令重排的现象产生!
内存屏障使用最多的地方是单例模式（DCL懒汉式）

彻底玩转单例模式

饿汉式 DCL懒汉式，深究！

饿汉式：没有问题

package com.lin.single;

//饿汉式
public class Hungry {

    //可能会浪费空间
    private byte[] data1 = new byte[1024*1024];
    private byte[] data2 = new byte[1024*1024];
    private byte[] data3 = new byte[1024*1024];
    private byte[] data4 = new byte[1024*1024];
    private Hungry(){

    }
    private final static Hungry HUNGRY = new Hungry();

    public static Hungry getInstance(){
        return HUNGRY;
    }
}

懒汉式：多线程模式下出现问题，不止创建一次

package com.lin.single;
//懒汉式单例
public class Lazy {
    private Lazy(){
        System.out.println(Thread.currentThread().getName()+"ok");
    }
    private static Lazy lazy;

    public static Lazy getInstance(){
        if(lazy == null){
            lazy = new Lazy();
        }
        return lazy;
    }

    //单线程下可以
    //多线程并发
    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            new Thread(()->{
                Lazy.getInstance();
            }).start();
        }
    }
}

DCL懒汉式：用反射获取对象，出现问题

package com.lin.single;
//懒汉式单例
public class Lazy {
    private Lazy(){
        System.out.println(Thread.currentThread().getName()+"ok");
    }
    private volatile static Lazy lazy;

    //双重检测锁模式的 懒汉式单例 DCL懒汉式
    public static Lazy getInstance(){
        if(lazy == null){
            synchronized (Lazy.class){
                if(lazy == null){
                    lazy = new Lazy();//不是原子性操作
                    /**
                     * 1.分配内存空间
                     * 2.执行构造方法，初始化对象
                     * 3.对象指向空间
                     *
                     * 期望123
                     * 真实执行132 线程A
                     * 线程B lazy没有完成构造
                     * 
                     */

                }
            }
        }
        return lazy;
    }

    //单线程下可以
    //多线程并发
    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            new Thread(()->{
                Lazy.getInstance();
            }).start();
        }
    }
}

静态内部类

package com.lin.single;

//静态内部类
public class Holder {
    private Holder(){

    }
    public static Holder getInstance(){
        return InnerClass.HOLDER;
    }
    public static class InnerClass{
        private static final Holder HOLDER = new Holder();
    }
}

单例模式都不安全，因为有反射

1.空参构造器加锁添加异常，但是两个对象实例都使用反射创建又会破坏单例

2.添加一个标志位来防止反射创建两次对象实例，但是反射可以修改标志位的值，仍会破坏单例

package com.lin.single;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;

//懒汉式单例
//道高一尺魔高一丈
public class LazyMan {
    private static boolean qinjiang = false;

    private LazyMan(){
        if(qinjiang == false){
            qinjiang = true;
        }else{
            throw new RuntimeException("不要试图使用反射破坏");
        }
        synchronized (LazyMan.class){
            if(lazyMan!=null){
                throw new RuntimeException("不要试图使用反射破坏");
            }
        }
    }
    private volatile static LazyMan lazyMan;

    //双重检测锁模式的 懒汉式单例 DCL懒汉式
    public static LazyMan getInstance(){
        if(lazyMan == null){
            synchronized (LazyMan.class){
                if(lazyMan == null){
                    lazyMan = new LazyMan();//不是原子性操作
                }
            }
        }
        return lazyMan;
    }

    //反射！
    public static void main(String[] args) throws Exception {
        //LazyMan instance = LazyMan.getInstance();
        Field qinjiang = LazyMan.class.getDeclaredField("qinjiang");
        qinjiang.setAccessible(true);

        Constructor<LazyMan> declaredConstructor = LazyMan.class.getDeclaredConstructor(null);
        declaredConstructor.setAccessible(true);
        LazyMan instance = declaredConstructor.newInstance();

        qinjiang.set(instance,false);

        LazyMan instance2 = declaredConstructor.newInstance();

        System.out.println(instance.hashCode());
        System.out.println(instance2.hashCode());
    }
}

使用枚举实现

package com.lin.single;

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;

//enum是一个什么？本身也是一个Class类
public enum EnumSingle {
    INSTANCE;
    public EnumSingle getInstance(){
        return INSTANCE;
    }
}

class Test{
    public static void main(String[] args) throws NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {
        EnumSingle instance1 = EnumSingle.INSTANCE;
        EnumSingle instance2 = EnumSingle.INSTANCE;

        System.out.println(instance1);//INSTASNCE
        System.out.println(instance2);//INSTASNCE
    }
}
输出结果是两个相同的实例

反射不能破坏枚举的单例

package com.lin.single;

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;

//enum是一个什么？本身也是一个Class类
public enum EnumSingle {
    INSTANCE;
    public EnumSingle getInstance(){
        return INSTANCE;
    }
}

class Test{
    public static void main(String[] args) throws NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {
        EnumSingle instance1 = EnumSingle.INSTANCE;
        //EnumSingle instance2 = EnumSingle.INSTANCE;

        Constructor<EnumSingle> declaredConstructor = EnumSingle.class.getDeclaredConstructor(null);
        declaredConstructor.setAccessible(true);
        EnumSingle instance2 = declaredConstructor.newInstance();

        //NoSuchMethodException: com.lin.single.EnumSingle.<init>()
        System.out.println(instance1);
        System.out.println(instance2);

    }
}

这里报的错误是java.lang.NoSuchMethodException: com.lin.single.EnumSingle.()，没有空参idea骗了我们

如果正确的报错应该是 "Cannot reflectively create enum objects"

反编译显示也是空参：说明反编译也在骗我们

所以为我们需要使用更专业的工具

在控制台输入jad -sjava EnumSingle.class，生成一个java文件

打开枚举类型的最终反编译源码-->java文件发现：有参构造

// Decompiled by Jad v1.5.8g. Copyright 2001 Pavel Kouznetsov.
// Jad home page: http://www.kpdus.com/jad.html
// Decompiler options: packimports(3) 
// Source File Name:   EnumSingle.java

package com.lin.single;


public final class EnumSingle extends Enum
{

    public static EnumSingle[] values()
    {
        return (EnumSingle[])$VALUES.clone();
    }

    public static EnumSingle valueOf(String name)
    {
        return (EnumSingle)Enum.valueOf(com/lin/single/EnumSingle, name);
    }

    //注意有参构造
    private EnumSingle(String s, int i)
    {
        super(s, i);
    }

    public EnumSingle getInstance()
    {
        return INSTANCE;
    }

    public static final EnumSingle INSTANCE;
    private static final EnumSingle $VALUES[];

    static 
    {
        INSTANCE = new EnumSingle("INSTANCE", 0);
        $VALUES = (new EnumSingle[] {
            INSTANCE
        });
    }
}

这边枚举就是一个类只是继承了枚举，这个工具表达了这个参数并不是空参而是String，int的所以我们在Class类加上参数

class Test{
    public static void main(String[] args) throws NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {
        EnumSingle instance1 = EnumSingle.INSTANCE;
        //EnumSingle instance2 = EnumSingle.INSTANCE;

        Constructor<EnumSingle> declaredConstructor = EnumSingle.class.getDeclaredConstructor(String.class,int.class);
        declaredConstructor.setAccessible(true);
        EnumSingle instance2 = declaredConstructor.newInstance();

        //java.lang.IllegalArgumentException: Cannot reflectively create enum objects
        System.out.println(instance1);
        System.out.println(instance2);

    }

这个输出来的异常才是正确的，最后成功解决了这个问题

深入理解CAS

什么是CAS

深入研究底层！有所突破！修内功，操作系统、计算机网络、计算机组成原理、数据库

package com.lin.cas;

import java.util.concurrent.atomic.AtomicInteger;

public class CASDemo {
    //CAS compareAndSet 比较并交换
    public static void main(String[] args) {
        AtomicInteger atomicInteger = new AtomicInteger(2023);

        //public final boolean compareAndSet(int expect, int update)期望 更新
        //如果期望的值达到了，就更新;否则就不更新
        //CAS是CPU 的并发原语
        System.out.println(atomicInteger.compareAndSet(2023, 2024));//true
        System.out.println(atomicInteger.get());
        //atomicInteger.getAndIncrement();

        System.out.println(atomicInteger.compareAndSet(2023, 2024));//false
        System.out.println(atomicInteger.get());
    }
}

Unsafe类

AtomicInteger源码

var1 Atomiclntegler对象本身

var2该对象值得引用地址

var4 需要变动的数量

unsafe.getAndAddInt具体实现是循环不停的compare主存中取到的值var5(this.getIntVolatile)和当前的线程的工作内存中的值(通过对象实例var1和偏移量var2获得)，直到两者equal(保证原子性)则更新为新值var5+var4(delta)

CAS ：比较当前工作内存中的值和主内存中的值，如果这个值是期望的，那么则执行操作！如果不是就一直循环！

缺点：1.循环会耗时 2.一次性只能保证一个共享变量的原子性 3.存在ABA问题

CAS:ABA问题(狸猫换太子)

package com.lin.cas;

import java.util.concurrent.atomic.AtomicInteger;

public class CASDemo {
    //CAS compareAndSwap 比较并交换
    public static void main(String[] args) {
        AtomicInteger atomicInteger = new AtomicInteger(2023);

        //对于我们平时写的SQL:乐观锁!
        //捣乱的线程
        System.out.println(atomicInteger.compareAndSet(2023, 2024));//true
        System.out.println(atomicInteger.get());//2024

        System.out.println(atomicInteger.compareAndSet(2024, 2023));//true
        System.out.println(atomicInteger.get());//2023

        //期望的线程
        System.out.println(atomicInteger.compareAndSet(2023, 6666));//true
        System.out.println(atomicInteger.get());//6666
    }
}

虽然最终期望确实完成可但是我们不希望数据被人动过了还不知道

原子引用（解决CAS的ABA问题）

解决ABA 问题，引入原子引用！对应的思想：乐观锁！

带版本号的原子操作

package com.lin.cas;

import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicStampedReference;

public class CASDemo {

    //AtomicStampedReference 注意：如果泛型是一个包装类，注意对象的引用问题
    //正常在业务操作，这里比较的都是一个个对象
    static AtomicStampedReference<Integer> atomicStampedReference = new AtomicStampedReference<>(1,1);

    public static void main(String[] args) {


        new Thread(()->{
            int stamp = atomicStampedReference.getStamp();//获得版本号
            System.out.println("a1===>"+stamp);

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

            atomicStampedReference.compareAndSet(1,2,atomicStampedReference.getStamp(),atomicStampedReference.getStamp()+1);
            System.out.println("a2===>"+atomicStampedReference.getStamp());

            atomicStampedReference.compareAndSet(2,1,atomicStampedReference.getStamp(),atomicStampedReference.getStamp()+1);
            System.out.println("a3===>"+atomicStampedReference.getStamp());
        },"a").start();

        //乐观锁的原理相同
        new Thread(()->{
            int stamp = atomicStampedReference.getStamp();//获得版本号
            System.out.println("b1===>"+stamp);

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

            System.out.println(atomicStampedReference.compareAndSet(1, 6, stamp, stamp + 1));
            System.out.println("b2===>"+atomicStampedReference.getStamp());
        },"b").start();
    }
}

Integer 使用了对象缓存机制，默认范围是 -128 ~ 127 ，推荐使用静态工厂方法 valueOf 获取对象实例，而不是 new，因为 valueOf 使用缓存，而 new 一定会创建新的对象分配新的内存空间；

原子类AtomicStampedReference的compareAndSet方法的源码源码

各种锁的理解

公平锁、非公平锁

公平锁：非常公平，不能够插队，必须先来后到！
非公平锁：非常不公平，可以插队（默认都是非公平）

public ReentrantLock() {
    sync = new NonfairSync();
}
public ReentrantLock(boolean fair) {
    sync = fair ? new FairSync() : new NonfairSync();
}

可重入锁

可重入锁（递归锁）

可重入锁synchronized 版本

package com.lin.lock;

//Synchronized
public class Demo01 {
    public static void main(String[] args) {
        Phone phone = new Phone();
        new Thread(()->{
            phone.sms();
        },"A").start();

        new Thread(()->{
            phone.sms();
        },"B").start();

    }
}

class Phone{
    public synchronized void sms(){
        System.out.println(Thread.currentThread().getName()+"sms");
        call();//这里也有锁
    }
    public synchronized void call(){
        System.out.println(Thread.currentThread().getName()+"call");
    }
}

可重入锁Lock版本(递归锁)

package com.lin.lock;

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class Demo02 {
    public static void main(String[] args) {
        Phone2 phone = new Phone2();
        new Thread(()->{
            phone.sms();
        },"A").start();

        new Thread(()->{
            phone.sms();
        },"B").start();

    }
}

class Phone2{
    Lock lock = new ReentrantLock();
    public void sms(){
        lock.lock();
        //lock锁必须配对，否则就会死在里面
        try {
            System.out.println(Thread.currentThread().getName()+"sms");
            call();//这里也有锁
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
    public void call(){
        lock.lock();
        try {
            System.out.println(Thread.currentThread().getName()+"call");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}

自旋锁

spin lock

自定义锁测试

package com.lin.lock;

import java.util.concurrent.atomic.AtomicReference;

//自旋锁
public class spinlockDemo {
    AtomicReference<Thread> atomicReference = new AtomicReference<>();
    //加锁
    public void myLock(){
        Thread thread = Thread.currentThread();
        System.out.println(Thread.currentThread().getName()+"===>myLock");

        //自旋锁
        while(!atomicReference.compareAndSet(null,thread)){

        }
    }


    //解锁
    public void myUnLock(){
        Thread thread = Thread.currentThread();
        System.out.println(Thread.currentThread().getName()+"===>myUnLock");
        atomicReference.compareAndSet(thread,null);
    }
}

package com.lin.lock;

import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.ReentrantLock;

public class TestSpinLock {
    public static void main(String[] args) throws InterruptedException {
        ReentrantLock reentrantLock = new ReentrantLock();
        reentrantLock.lock();
        reentrantLock.unlock();

        spinlockDemo spinlock = new spinlockDemo();
        new Thread(()->{
            spinlock.myLock();
            try {
                TimeUnit.SECONDS.sleep(3);
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                spinlock.myUnLock();
            }
        },"T1").start();

        TimeUnit.SECONDS.sleep(1);
        new Thread(()->{
            spinlock.myLock();
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                spinlock.myUnLock();
            }
        },"T2").start();



    }
}

死锁

A持有A锁，B持有B锁，它们试图获取对方的锁

死锁测试，怎么排除死锁

package com.lin.lock;

import java.util.concurrent.TimeUnit;

public class DeadLockDemo {
    public static void main(String[] args) {
        String lock1 = "lock1";
        String lock2 = "lock2";
        new Thread(new MyThread(lock1,lock2),"T1").start();
        new Thread(new MyThread(lock2,lock1),"T2").start();
    }
}

class MyThread implements Runnable{
    private String lockA;
    private String lockB;

    public MyThread(String lockA, String lockB) {
        this.lockA = lockA;
        this.lockB = lockB;
    }

    @Override
    public void run() {
        synchronized (lockA){
            System.out.println(Thread.currentThread().getName()+"lock:"+lockA+"==>get"+lockB);
            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized (lockB){
                System.out.println(Thread.currentThread().getName()+"lock:"+lockB+"==>get"+lockA);
            }
        }
    }
}

解决问题

1.使用jps -l定位进程号

2.使用 jstac 进程号查看进程信息

面试工作中：

1.日志

2.堆栈

posted on 2023-04-05 12:59 ·草莓味的可爱多阅读(8) 评论(0) 收藏举报

刷新页面返回顶部