JUC

最新推荐文章于 2024-09-03 20:17:53 发布

nitin_

最新推荐文章于 2024-09-03 20:17:53 发布

阅读量69

点赞数

文章标签： java 并发编程

本文链接：https://blog.csdn.net/nitin_/article/details/115311770

版权

JUC

1. 什么是JUC

java.util工具包、包、分类

2. 线程和进程

线程和进程

进程：一个程序，程序的集合；

一个进程往往可以包含多个线程，至少包含一个！

Java默认有两个线程： main，GC

线程：开了一个进程，写字，自动保存（线程负责）

Java真的可以开启线程吗？

不能，java只能调用本地方法（底层的c++）开启线程，java无法直接操作硬件

并发、并行

并发编程：并发、并行

并发（多线程操作同一个资源）

CPU一核，模拟出来多条线程，快速交替

并行（多个人一起行走）

CPU多核，多个线程可以同时执行；线程池

public class Test1 {
    public static void main(String[] args) {
        //获取CPU的核数
        //CPU密集型，IO密集型 System.out.println(Runtime.getRuntime().availableProcessors());
    }
}

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

线程有几个状态

6个新生，运行，阻塞，等待，超时等待，终止

wait和sleep的区别

1.来自不同的类

wait=> Object

sleep=> Thread

2.关于锁的释放

wait会释放锁，sleep不会释放锁

3.使用范围不同

wait必须在同步代码块中

sleep可以在任何地方使用

4.是否需要捕获异常

wait不需要捕获异常，sleep必须要捕获异常

3. Lock锁

传统的Synchronized

//基本的卖票例子
/*降低耦合性
  线程就是一个单独的资源类，没有任何附属的操作！
  1. 属性，方法
 */
public class SaleTicketDemo01 {
    public static void main(String[] args) {
        //并发：多线程操作同一个资源类
        Ticket ticket = new Ticket();

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

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

非公平锁：十分不公平，可以插队（默认）

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 < 20; i++) ticket.sale();},"A").start();
        new Thread(()->{ for (int i = 0; i < 20; i++) ticket.sale();},"B").start();
        new Thread(()->{ for (int i = 0; i < 20; 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();

    public synchronized 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锁就不一定会等待下去（lock.trylock();）
Synchronized 可重入锁，不可以中断，非公平；Lock可重入锁，可以判断锁，非公平（可自己设置）
Synchronized 适合锁少量的代码同步问题，Lock适合锁大量的同步代码

4. 生产者和消费者问题

面试：单例模式，排序算法，生产者和消费者，死锁问题

/*
线程之间的通信问题：生产者和消费者问题！  等待唤醒，通知唤醒
线程交替执行    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.notify();
    }

    //-1
    public  synchronized  void decrement() throws InterruptedException {
        if(number==0){
            //等待
            this.wait();
        }
        number--;
        System.out.println(Thread.currentThread().getName()+"=>"+number);
        //通知其他线程，我-1完毕了
        this.notify();
    }
}

问题存在， A,B,C,D四个线程

if 改为 while，防止虚假唤醒

/*
线程之间的通信问题：生产者和消费者问题！  等待唤醒，通知唤醒
线程交替执行    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.decrement();
                } 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.notify();
    }

    //-1
    public  synchronized  void decrement() throws InterruptedException {
        while(number==0){
            //等待
            this.wait();
        }
        number--;
        System.out.println(Thread.currentThread().getName()+"=>"+number);
        //通知其他线程，我-1完毕了
        this.notify();
    }
}

JUC版的生产者和消费者问题

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

/*
线程之间的通信问题：生产者和消费者问题！  等待唤醒，通知唤醒
线程交替执行    A    B    操作同一个变量    num==0
A   num+1
B   num-1
 */
public class L {
    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.decrement();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"D").start();

}

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

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

    //+1
    public void increment() throws InterruptedException {
        lock.lock();
        try {
            //业务代码
            while (number != 0) {  //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 {
        lock.lock();
        try {
            while(number==0){  //1
                //等待
                condition.await();
            }
            number--;
            System.out.println(Thread.currentThread().getName() + "=>" + number);
            //通知其他线程，我-1完毕了
            condition.signalAll();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}
}

Condition 精准的通知和唤醒线程

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

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{
    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(){
        lock.lock();
        try {
            //业务，判断-> 执行-> 通知
            while(number!=1){
                //等待
                condition1.await();
            }
            System.out.println(Thread.currentThread().getName()+"=>  AAAAA");
            //唤醒指定的人 B
            number = 2;
            condition2.signal();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public void printB(){
        lock.lock();
        try {
            //业务，判断-> 执行-> 通知
            while (number!=2){
                condition2.await();
            }
            System.out.println(Thread.currentThread().getName()+"=>  BBBBB");
            number = 3;
            condition3.signal();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public void printC(){
        lock.lock();
        try {
            //业务，判断-> 执行-> 通知
            while (number!=3){
                condition3.await();
            }
            System.out.println(Thread.currentThread().getName()+"=>  CCCCC");
            number = 1;
            condition1.signal();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
    //生产线： 下单->支付->交易->物流
}

5. 8锁现象

如何判断锁的是谁！永远知道什么锁，锁到底锁的是谁！

深刻理解锁

import java.util.concurrent.TimeUnit;

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

        new Thread(()->{
            try {
                phone.sendMsg();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"A").start();

        TimeUnit.SECONDS.sleep(1);

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

class Phone{
    //synchronized 锁的对象是方法的调用者
    //两个方法用的是同一把锁，谁先拿到谁执行
    public synchronized void sendMsg() throws InterruptedException {
        TimeUnit.SECONDS.sleep(4);
        System.out.println("发短信");
    }

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

}

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

        new Thread(()->{
            try {
                phone1.sendMsg();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"A").start();

        TimeUnit.SECONDS.sleep(1);

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

class Phone2{
    //synchronized 锁的对象是方法的调用者
    //两个方法用的是同一把锁，谁先拿到谁执行
    public synchronized void sendMsg() throws InterruptedException {
        TimeUnit.SECONDS.sleep(4);
        System.out.println("发短信");
    }

    public synchronized void call(){

        System.out.println("打电话");
    }

    //没有锁，不收锁的影响
    public void hello(){
        System.out.println("hello");
    }

}

import java.util.concurrent.TimeUnit;

/**
 * 5. 两个静态的同步方法，只有一个对象  先打印发短信还是打电话   1/发短信    2/打电话
 * 6. 两个对象，两个静态的同步方法  先打印发短信还是打电话      1/发短信    2/打电话
 */
public class Test3 {
    public static void main(String[] args) throws InterruptedException {
        //两个对象的Class模板只有一个，static，锁的是Class
        Phone3 phone3 = new Phone3();
        Phone3 phone = new Phone3();

        new Thread(()->{
            try {
                phone3.sendMsg();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"A").start();

        TimeUnit.SECONDS.sleep(1);

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

//Phone3唯一的一个Class对象
class Phone3{
    //synchronized 锁的对象是方法的调用者
    //static 静态方法
    //类一加载就有了，锁的是Class
    public static synchronized void sendMsg() throws InterruptedException {
        TimeUnit.SECONDS.sleep(4);
        System.out.println("发短信");
    }

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

}

import java.util.concurrent.TimeUnit;

/**
 * 7. 一个静态的同步方法，一个普通的同步方法，一个对象  先打印发短信还是打电话？  1/打电话    2/发短信
 * 8. 一个静态的同步方法，一个普通的同步方法，两个对象  先打印发短信还是打电话？  1/打电话    2/发短信
 */
public class Test4 {
    public static void main(String[] args) throws InterruptedException {
        Phone4 phone = new Phone4();
        Phone4 phone2 = new Phone4();

        new Thread(()->{
            try {
                phone.sendMsg();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"A").start();

        TimeUnit.SECONDS.sleep(1);

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

//Phone3唯一的一个Class对象
class Phone4{
    //静态的同步方法，锁的是Class类模板
    public static synchronized void sendMsg() throws InterruptedException {
        TimeUnit.SECONDS.sleep(4);
        System.out.println("发短信");
    }

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

小结

new this 具体的一个对象

static Class 唯一的一个模板

6. 集合类不安全

List

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

// java.util.ConcurrentModificationException 并发修改异常
public class ListTest {
    public static void main(String[] args) {
        //并发下 ArrayList 不安全
        /**
         * 解决方案：
         * 1. List<String> list = new Vector<>();
         * 2. List<String> list = Collections.synchronizedList(new ArrayList<>());
         * 3. List<String> list =new CopyOnWriteArrayList<>();
         */
        //CopyOnWrite  写入时复制  COW  计算机程序设计领域的一种优化策略
        //在写入时避免覆盖，造成数据问题
        //CopyOnWriteArrayList相对于Vector优点：效率高，vector本质是synchronized锁，效率低下
        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();
        }
    }
}

set

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) {
        /**
         * 解决方法：
         *  1. Set<String> set = Collections.synchronizedSet(new HashSet<>());
         *  2. Set<String> set = new CopyOnWriteArraySet<>();
         */
        Set<String> set = new HashSet<>();

        for (int i = 0; i < 10; i++) {
            new Thread(()->{
                set.add(UUID.randomUUID().toString().substring(0,5));
                System.out.println(set);
            },String.valueOf(i)).start();
        }
    }
}

hashset的底层

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();//不变的值

Map


import java.util.Collections;
import java.util.HashMap;
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) {
        // 默认等价于什么？  new HashMap<>(16, 0.75);

        /**
         * 解决方法：
         *  1. Map<String,String> map = Collections.synchronizedMap(new HashMap<>());
         *  2. Map<String,String> map = new ConcurrentHashMap<>();
         */
        Map<String,String> map = new HashMap<>();
        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();
        }
    }
}

ConcurrentHashMap实现原理

HashTable容器在竞争激烈的并发环境下表现出效率低下的原因是所有访问HashTable的线程都必须竞争同一把锁。假如容器里有多把锁，每一把锁用于锁容器其中一部分数据，那么当多线程访问容器里不同数据段的数据时，线程间就不会存在锁竞争，从而可以有效提高并发访问效率，这就是ConcurrentHashMap所使用的锁分段技术。首先将数据分成一段一段地存储，然后给每一段数据配一把锁，当一个线程占用锁访问其中一个段数据的时候，其他段的数据也能被其他线程访问。

7. Callable

相对于Runnable有是三个区别：

可以有返回值
可以抛出异常
方法不同，run()/call()

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 {
        MyThread thread = new MyThread();
        FutureTask futureTask = new FutureTask(thread);//适配类
        new Thread(futureTask,"A").start();
        new Thread(futureTask,"B").start();//有缓存


        //获取Callable返回结果
        String str = (String) futureTask.get();//这个get 方法可能会发生阻塞！把它放到最后，或者使用异步通信来处理！
        System.out.println(str);
    }
}


class MyThread implements Callable<String>{
    @Override
    public String call() throws Exception {
        System.out.println("call");
        return "2430";
    }
}

8. 常用辅助类

CountDownLatch

允许一个或多个线程等待直到在其他线程中执行的一组操作完成的同步辅助。

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 = 0; i < 6; i++) {
            new Thread(()->{
                System.out.println(Thread.currentThread().getName()+" Get out");
                countDownLatch.countDown();//数量-1
            },String.valueOf(i)).start();
        }
        countDownLatch.await();//等待计数器归零，然后向下执行
        System.out.println("Close door");
    }
}

原理：

countDownLatch.countDown(); //数量-1

countDownLatch.await(); //等待计数器归零，然后向下执行

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

CyclicBarrier

允许一组线程全部等待彼此达到共同屏障点的同步辅助。

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

//加法计数器j
public class CyclicBarrierDemo {
    public static void main(String[] args) {
        /**
         * 集齐7颗龙珠召唤神龙
         */
        //召唤龙珠的线程
        CyclicBarrier cyclicBarrier = new CyclicBarrier(7,()->{
            System.out.println("召唤神龙成功！");
        });
        for (int i = 0; i < 7; i++) {
            //Lambda能操作到i吗？  不能
            final int temp = i+1;
            new Thread(()->{
                System.out.println(Thread.currentThread().getName()+"收集了第"+temp+"颗龙珠");
                try {
                    cyclicBarrier.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } catch (BrokenBarrierException e) {
                    e.printStackTrace();
                }
            }).start();
        }
    }
}

Semaphore

信号量

import java.util.concurrent.Semaphore;
import java.util.concurrent.TimeUnit;
//抢车位   限流
public class SemaphoreDemo {
    public static void main(String[] args) {
        //线程数量，停车位
        Semaphore semaphore = new Semaphore(3);
        for (int i = 0; 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 {
                    //release() 释放
                    semaphore.release();
                }
            },String.valueOf(i+1)).start();
        }
    }
}

原理：

semaphore.acquire(); // 获取。如果已经满了，等待，到被释放为止。

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

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

9. 读写锁

ReadWriteLock 读可以被多线程同时读，写的时候只能有一个线程去写。

import sun.font.FontRunIterator;
import java.sql.SQLOutput;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

/**
 * ReadWriteLock
 * 读-读  可以共存
 * 读-写  不能共存
 * 写-写  不能共存
 * 独占锁（写锁）  一次只能被一个线程占有
 * 共享锁（读锁）  多个线程可以同时占有
 */
public class ReadWriteLockDemo {
    public static void main(String[] args) {
        MyCacheLock myCache = new MyCacheLock();

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

        //读取
        for (int i = 0; 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()+"写入完成");
        } 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);
            map.get(key);
            System.out.println(Thread.currentThread().getName()+"读取完成");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            readWritelock.readLock().unlock();
        }
    }
}

10. 阻塞队列

阻塞

写入：如果队列满了，就必须阻塞等待

取：如果队列是空的，必须阻塞等待生产

阻塞队列BlockingQueue

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

四组API

方式	抛出异常	有返回值,不抛出异常	阻塞等待	超时等待
添加	add	offer()	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 抛出异常！
    //System.out.println(blockingQueue.add("d"));

    System.out.println(blockingQueue.element());
    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);
    System.out.println(blockingQueue.offer("a"));
    System.out.println(blockingQueue.offer("b"));
    System.out.println(blockingQueue.offer("c"));
    //System.out.println(blockingQueue.offer("d",2, TimeUnit.SECONDS));//等待超过2s就退出

    System.out.println(blockingQueue.poll());
    System.out.println(blockingQueue.poll());
    System.out.println(blockingQueue.poll());
    System.out.println(blockingQueue.poll(2, TimeUnit.SECONDS));//等待超过2s就退出
}

SynchronizedQueue同步队列

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

/**
 * 同步队列
 * 和其他的BlockingQueue不一样，SynchronizedQueue不存储元素
 * 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()+ " take "+blockingQueue.take());
                TimeUnit.SECONDS.sleep(3);
                System.out.println(Thread.currentThread().getName()+ " take "+blockingQueue.take());
                TimeUnit.SECONDS.sleep(3);
                System.out.println(Thread.currentThread().getName()+ " take "+blockingQueue.take());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"T2").start();
    }
}

11. 线程池

池化技术：3大方法，7大参数，4种拒绝策略

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

线程池、连接池、内存池、对象池……

池化技术：实现准备好一些资源，有人要用，就来这里拿，用完之后还回来。

线程池的好处

降低资源的消耗
提高响应的速度
方便管理

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

线程池：3大方法

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);//创建一个固定的线程池的大小
        ExecutorService threadPool = Executors.newCachedThreadPool();//创建一个可伸缩的线程池
        try {
            //使用了线程池之后，使用线程池来创建线程
            for (int i = 0; i < 10; i++) {
                threadPool.execute(()->{
                    System.out.println(Thread.currentThread().getName()+" ok");
                });
            }
        } 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,
                                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;
    }

在这里插入图片描述

手动创建线程池，四大拒绝策略

import java.util.concurrent.*;

// Executors 工具类、3大方法
public class Demo01 {
    public static void main(String[] args) {
        //自定义线程池 ThreadPoolExecutor
        ExecutorService threadPool = new ThreadPoolExecutor(
                2,
                5,
                3,
                TimeUnit.SECONDS,
                new LinkedBlockingDeque<>(3),
                Executors.defaultThreadFactory(),
                //new ThreadPoolExecutor.AbortPolicy());//队列满了，还有线程要进来，不处理线程并抛出异常
                //new ThreadPoolExecutor.CallerRunsPolicy());//哪来的去哪里
                //new ThreadPoolExecutor.DiscardPolicy());//队列满了，丢掉任务，但不会抛出异常
                new ThreadPoolExecutor.DiscardOldestPolicy());//线程池满了，尝试去和最早的竞争，也不会抛出异常
        try {
            //最大承载：Deque+max
            //超出最大承载：RejectedExecutionException
            for (int i = 0; i < 10; i++) {
                //使用了线程池之后，使用线程池来创建线程
                threadPool.execute(()->{
                    System.out.println(Thread.currentThread().getName()+" ok");
                });
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            //线程池用完后，程序结束，关闭线程池
            threadPool.shutdown();
        }
    }
}

池的最大大小如何设置

CPU密集型和IO密集型（调优）

//最大线程如何定义
//1. CPU密集型， CPU的线程数，可以保持CPU的效率最高！
//获取CPU的线程数
System.out.println(Runtime.getRuntime().availableProcessors());
//2. IO密集型  判断程序中十分耗IO的线程数 定义最大线程大于此数
ExecutorService threadPool = new ThreadPoolExecutor(
        2,
        Runtime.getRuntime().availableProcessors(),
        3,
        TimeUnit.SECONDS,
        new LinkedBlockingDeque<>(3),
        Executors.defaultThreadFactory(),
        new ThreadPoolExecutor.AbortPolicy());

try {
    //最大承载：Deque+max
    //超出最大承载：RejectedExecutionException
    for (int i = 0; i < 10; i++) {
        //使用了线程池之后，使用线程池来创建线程
        threadPool.execute(()->{
            System.out.println(Thread.currentThread().getName()+" ok");
        });
    }
} catch (Exception e) {
    e.printStackTrace();
} finally {
    //线程池用完后，程序结束，关闭线程池
    threadPool.shutdown();

12. 四大函数式接口

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

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

//简化编程模型，在新版本的框架底层大量应用
//foreach(消费者类的函数式接口)

Function 函数式接口

import java.util.function.Function;

/**
 * Function 函数型接口，有一个输入参数，有一个输出
 * 只要是函数型接口，可以用lambda表达式
 */
public class Demo01 {
    public static void main(String[] args) {
//      Function function = new Function<String,String>(){
//          @Override
//          public String apply(String s) {
//              return s;
//          }
//      };
        Function function = (s)->{return s;};

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

Predicate 断定型接口

import java.util.function.Predicate;

/**
 * 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("asd"));
    }
}

Consumer 消费型接口

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 供给型接口

import java.util.function.Supplier;

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

        System.out.println(supplier.get());
    }
}

13. Stream流式计算

什么是Stream流式计算

/**
 * 要求：现有5个用户！筛选：
 * 1. ID必须是偶数
 * 2. 年龄必须大于23岁
 * 3. 用户名转为大写字母
 * 4. 用户名字母倒着排序
 * 5. 只输出一个用户！
 */
public class Demo01 {
    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流
        //lambda表达式，链式编程，函数式接口，Stream流式计算
        list.stream().filter(u->{return u.getId()%2==0;})
                .filter(u->{return u.getAge()>23;})
                .map(u->{return u.getName().toUpperCase();})
                .sorted((uu1,uu2)->{return uu2.compareTo(uu1);})
                .limit(1)
                .forEach(System.out::println);
    }
}

class User {
    int id;
    String name;
    int age;

    public User(int id, String name, int age) {
        this.id = id;
        this.name = name;
        this.age = age;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

14. ForkJoin

什么是ForkJoin

ForkJoin在JDK 1.7,并行执行任务！提高效率，大数据量。

大数据：Map Reduce（把大任务拆分为小任务）

在这里插入图片描述

ForkJoin特点：工作窃取

维护的都是双端队列

在这里插入图片描述

ForkJoin操作

import java.util.concurrent.RecursiveTask;

/**
 * 求和计算的任务
 *
 * 如何使用ForkJoin：
 * 1. ForkJoinPool 通过它来执行
 * 2. 计算任务 ForkJoinPool.execute(ForkJoinTask task)
 * 3. 计算类要继承ForkJoinTask
 */
public class ForkJoinDemo extends RecursiveTask<Long> {
    private Long start;
    private Long end;

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

    public  ForkJoinDemo(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 mid = (start+end)/2;//中间值
            ForkJoinDemo task1 = new ForkJoinDemo(start,mid);
            task1.fork();//拆分任务，把任务压入线程队列
            ForkJoinDemo task2 = new ForkJoinDemo(mid+1, end);
            task2.fork();//拆分任务，把任务压入线程队列

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

测试：

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

public class Test {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        test1();
        test2();
        test3();
    }

    public static void test1(){
        Long sum = 0L;
        long start = System.currentTimeMillis();
        for(Long i=1L;i<=1000_000_000;i++){
            sum +=i;
        }
        long end = System.currentTimeMillis();
        System.out.println("sum="+sum+" 时间："+(end-start));
    }

    public static void test2() throws ExecutionException, InterruptedException {
        long start = System.currentTimeMillis();
        ForkJoinPool forkJoinPool = new ForkJoinPool();
        ForkJoinTask<Long> task = new ForkJoinDemo(0L,1000_000_000L);
        ForkJoinTask<Long> submit = forkJoinPool.submit(task);//提交任务
        Long sum = submit.get();

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

    public static void test3(){
        long start = System.currentTimeMillis();
        //Stream并行流

        long sum = LongStream.rangeClosed(0L, 1000_000_000L).parallel().reduce(0,Long::sum);
        long end = System.currentTimeMillis();
        System.out.println("sum="+sum+" 时间："+(end-start));
    }

}

测试结果：

在这里插入图片描述

15. 异步回调

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

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

/**
 * 异步调用：Ajax
 * 异步执行
 * 成功回调
 * 失败回调
 */
public class Demo01 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //没有返回值的runAsync异步回调
//        CompletableFuture<Void> completableFuture = CompletableFuture.runAsync(()->{
//            try {
//                TimeUnit.SECONDS.sleep(2);
//            } catch (InterruptedException e) {
//                e.printStackTrace();
//            }
//            System.out.println(Thread.currentThread().getName()+"runAsync=>void");
//        });
//
//        System.out.println("1111");
//
//        completableFuture.get();//获取阻塞执行结果

        //有返回值的supplyAsync异步回调
        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);//错误信息 java.util.concurrent.CompletionException: java.lang.ArithmeticException: / by zero
        }).exceptionally((e)->{
            System.out.println(e.getMessage());
            return 233;//可以获得到错误的返回结果
        }).get());
    }
}

16. 理解JMM

请你谈谈对Volatile 的理解

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

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

什么是JMM

JMM：java内存模型，不存在的东西，概念！约定！

关于JMM的一些同步的约定

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

线程 工作内存、主存

在这里插入图片描述

内存交互操作有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操作之前，必须把此变量同步回主内存

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

17. Volatile

保证可见性

import java.util.concurrent.TimeUnit;

public class Demo01 {
    //不加volatile 程序就会死循环！
    //加volatile 可以保证可见性
    private volatile static  int num = 0;

    public static void main(String[] args) {
        new Thread(()->{ //线程1 对主内存的变化不知道
            while(num==0){

            }
        }).start();

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

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

不保证原子性

原子性：不可分割

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

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

    public static void main(String[] args) {
        //理论上num结果应该为2万
        for (int i = 0; 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);
    }
}

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

import java.util.concurrent.atomic.AtomicInteger;

//原子类的Integer  AtomicInteger
public class Demo02 {
    private volatile static AtomicInteger num = new AtomicInteger();
    public static void add(){
        num.getAndIncrement();// AtomicInteger+1 方法
    }

    public static void main(String[] args) {
        //理论上num结果应该为2万
        for (int i = 0; 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);
    }
}

指令重排

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

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

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

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实现了可见性）

18. 单例模式

//饿汉式单例
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;
    }

}

//懒汉式单例
public class LazyMan {
    private LazyMan(){
        System.out.println(Thread.currentThread().getName()+"ok");
    }

    private volatile static LazyMan lazyman;

    //双重检测锁模式的懒汉式单例  DCL懒汉式
    public static LazyMan getInstance(){
        if( lazyman ==null){
            synchronized (LazyMan.class){
                if(lazyman==null){
                    lazyman = new LazyMan();
                    /**
                     * 1. 分配内存空间
                     * 2. 执行构造方法，初始化对象
                     * 3. 把这个对象指向这个空间
                     *
                     * 不安全，可能发生指令重排，所以要加volatile关键词
                     */
                }
            }
        }
        return lazyman;
    }

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

}

反射可以破坏单例模式，但不能破坏枚举的单例模式

19. 深入理解CAS

什么是CAS

import java.util.concurrent.atomic.AtomicInteger;

public class CASDemo {

    //CAS：compareAndSet 比较并交换！
    public static void main(String[] args) {
        AtomicInteger atomicInteger = new AtomicInteger(2020);
        //期望、更新
        //public final boolean compareAndSet(int expect, int update)
        //如果我期望的值达到了，那么久更新，否则，就不更新   CAS是CPU的并发原语！
        System.out.println(atomicInteger.compareAndSet(2020,2021));
        System.out.println(atomicInteger.get());

        System.out.println(atomicInteger.compareAndSet(2020,2021));
        System.out.println(atomicInteger.get());
    }
}

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

缺点：

循环会耗时
一次性只能保证一个共享变量的原子性
ABA问题

CAS：ABA问题（狸猫换太子）

在这里插入图片描述

import java.util.concurrent.atomic.AtomicInteger;

public class CASDemo {

    //CAS：compareAndSet 比较并交换！
    public static void main(String[] args) {
        AtomicInteger atomicInteger = new AtomicInteger(2020);
        //====================== 捣乱的线程 ======================
        System.out.println(atomicInteger.compareAndSet(2020,2021));
        System.out.println(atomicInteger.get());
        System.out.println(atomicInteger.compareAndSet(2021,2020));
        System.out.println(atomicInteger.get());

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

20. 原子引用

带版本号的原子操作

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

public class CASDemo {

    //AtomicStampedReference 注意，如果泛型是一个包装类，注意对象的引用问题
    static AtomicStampedReference<Integer> atomicStampedReference = new AtomicStampedReference<>(1,1);

    //CAS：compareAndSet 比较并交换！
    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=>" + atomicStampedReference.getStamp());

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

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

    }
}

21. 各种锁的理解

1. 公平锁、非公平锁

公平锁：非常公平，不能插队

非公平锁：非常不公平，可以插队

（默认都是非公平的）

public ReentrantLock(){
    sunc = new NonfairSync();
}

public ReentrantLock(){
    sunc = fair ? new fairSync() : NonfairSync();
}

2. 可重入锁

可重入锁（递归锁）

在这里插入图片描述

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

public class test {
    public static void main(String[] args) {
        Phone phone = new Phone();

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

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

class Phone{
    Lock lock = new ReentrantLock();
    public void sms(){
        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();
        }
    }
}

3. 自旋锁

import java.util.concurrent.atomic.AtomicReference;

/**
 * 自旋锁
 */
public class spinlock {

    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);
    }
}

测试：

import java.util.concurrent.TimeUnit;

public class test {
    public static void main(String[] args) throws InterruptedException {
        spinlock lock = new spinlock();

        new Thread(()->{
            lock.myLock();
            try {
                TimeUnit.SECONDS.sleep(10);
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                lock.myUnlock();
            }
        },"T1").start();

        TimeUnit.SECONDS.sleep(1);

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

T2自旋，只有当T1解锁后T2才能解锁

4. 死锁

死锁是什么

在这里插入图片描述

死锁测试，怎么排除死锁

import java.util.concurrent.TimeUnit;

public class Demo {
    public static void main(String[] args) {
        String lockA = "lockA";
        String lockB = "lockB";
        new Thread(new MyThread(lockA,lockB),"T1").start();
        new Thread(new MyThread(lockB,lockA),"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);
        }
    }
}

解决问题

使用jps -1定义进程号
使用jstack进程号找到死锁问题

工作中如何排查问题：日志，堆栈信息

nitin_

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
JUC

JUC1. 什么是JUCjava.util工具包、包、分类2. 线程和进程线程和进程进程：一个程序，程序的集合；一个进程往往可以包含多个线程，至少包含一个！Java默认有两个线程： main，GC线程：开了一个进程，写字，自动保存（线程负责）Java真的可以开启线程吗？不能，java只能调用本地方法（底层的c++）开启线程，java无法直接操作硬件并发、并行并发编程：并发、并行并发（多线程操作同一个资源）CPU一核，模拟出来多条线程，快速交替并行（多个人一起行走）
复制链接

扫一扫