java多线程

1、什么是JUC

官方文档+源码

面试高频问

java.util

java.util.concurrent

java.util.concurrent.atomic

java.util.concurrent.locks

java,util 工具包、包、分类

业务：普通的线程代码 Thread

Runnable 没有返回值

2、线程和进程

线程和进程如果不能用一句话说出来的技术就是不扎实

进程：就是一个程序一个程序的集合

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

java 默认高就有两个线程 main 、GC:垃圾回收

线程：开了一个java 有main线程 GC线程

对应java而言：： Thread、Runnable、Callable

java真的可以开线程吗？？不可以

    public synchronized void start() {
        /**
         * This method is not invoked for the main method thread or "system"
         * group threads created/set up by the VM. Any new functionality added
         * to this method in the future may have to also be added to the VM.
         *
         * A zero status value corresponds to state "NEW".
         */
        if (threadStatus != 0)
            throw new IllegalThreadStateException();

        /* Notify the group that this thread is about to be started
         * so that it can be added to the group's list of threads
         * and the group's unstarted count can be decremented. */
        group.add(this);

        boolean started = false;
        try {
            start0();
            started = true;
        } finally {
            try {
                if (!started) {
                    group.threadStartFailed(this);
                }
            } catch (Throwable ignore) {
                /* do nothing. If start0 threw a Throwable then
                  it will be passed up the call stack */
            }
        }
    }
	// 本地方法，底层的C++,  java无法操作硬件
    private native void start0();

并发、并行

并发编程：并发、并行

并发（多线程操作同一个资源） 充分利用cpu的资源

CPU 一核模拟出来多条线程，天下武功为快不破快速交替模拟并行（宏观上并行微观上窜行）

并行（多个人一起走）

CPU多核多个线程可以同时进行;线程池

package com.lmq;

/**
 * @author 羡鱼
 * @version 1.0
 * @date 2023/7/29 17:05
 */
public class JucTest {
    public static void main(String[] args) {
        // 获取cpu的核数
        System.out.println(Runtime.getRuntime().availableProcessors());    }
}

所有公司都看中

线程有几个状态

public enum State {

         // 新生
        NEW,
         // 运行
        RUNNABLE,
		// 阻塞
        BLOCKED,
		// 等待  一直等
        WAITING,
		// 超时等待
        TIMED_WAITING,

    	//	终止
        TERMINATED;
    }

wait/sleep 区别

1、来自不同的类

wait =>Object

sleep => Thread

2、关于锁的释放

wait 会释放锁 sleep睡觉了，抱着锁睡觉了，不会释放！

3、使用范围是不同的

wait：必须在同步代码块中使用

sleep 可以任何地方睡觉

4、是否要捕获异常

wait 要捕获异常

sleep 必须捕获异常

3、Lock锁（重点）

传统Synchronized 和 Lock 区别

1、 Synchronized 内置的JAVA关键字 Lock 是一个java类

2、 Synchronized 无法判断获取锁的状态Lock可以

3、 Synchronized 会自动释放锁Lock 必须手动释放锁，不释放锁就死锁

4、 Synchronized 线程1（获得锁，阻塞了）线程2（一直等待）；Lock 锁就不一定等下去

5、 Synchronized 可重入锁不可中断，非公平；Lock 可以重锁，可以判断锁, 非公平（可以自己设置）；

6、 Synchronized 适合锁少量的同步代码， Lock 适合锁大量的同步代码

// synchronized 本质 ： 队列  锁

Synchronized wait

公平锁先来后到

非公平锁可以插队（默认）

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

4、生产者和消费者的问题

面试常问

单例模式排序算法生产者消费者死锁

生产者消费者

package com.lmq.pc;

/**
 * @author 羡鱼
 * @version 1.0
 * @date 2023/7/29 18:12
 * <p>
 * 线程之间的通讯  生产者 消费者  等待幻想  通知唤醒
 * 线程交替执行  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) {
                    throw new RuntimeException(e);
                }
            }
        }, "A").start();
        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                try {
                    data.decrement();
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        }, "B").start();
    }
}


// 判断  等待   业务   通知
class Data {
    private int number = 0;

    public synchronized void increment() throws InterruptedException {
        if (number != 0) {
            this.wait();
        }
        number++;
        // 通知其他线程
        this.notify();
        System.out.println(Thread.currentThread().getName() + "=>" + number);
    }

    public synchronized void decrement() throws InterruptedException {
        if (number == 0) {
            this.wait();
        }
        number--;
        this.notify();
        System.out.println(Thread.currentThread().getName() + "=>" + number);
    }
}

使用if判断会出现虚假唤醒使用while

package com.lmq.pc;

/**
 * @author 羡鱼
 * @version 1.0
 * @date 2023/7/29 18:12
 * <p>
 * 线程之间的通讯  生产者 消费者  等待幻想  通知唤醒
 * 线程交替执行  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 < 20; i++) {
                try {
                    data.increment();
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        }, "A").start();
        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                try {
                    data.decrement();
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        }, "B").start();
        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                try {
                    data.decrement();
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        }, "C").start();
    }
}


// 判断  等待   业务   通知
class Data {
    private int number = 0;

    public synchronized void increment() throws InterruptedException {
        while (number != 0) {
            this.wait();
        }
        number++;
        // 通知其他线程
        this.notify();
        System.out.println(Thread.currentThread().getName() + "=>" + number);
    }

    public synchronized void decrement() throws InterruptedException {
        while (number == 0) {
            this.wait();
        }
        number--;
        this.notify();
        System.out.println(Thread.currentThread().getName() + "=>" + number);
    }
}

原来的 synchronized wait notify

juc的 (Lock)Lock ()await signal

juc 版本生产者消费者

Lock 找到 Condi

上锁等待通知解锁

package com.lmq.pc;

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

/**
 * @author 羡鱼
 * @version 1.0
 * @date 2023/7/29 18:48
 */
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) {
                    throw new RuntimeException(e);
                }
            }
        }, "A").start();


        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                try {
                    data.decrement();
                } catch (Exception e) {
                    throw new RuntimeException(e);
                }
            }
        }, "B").start();

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


        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                try {
                    data.decrement();
                } catch (Exception e) {
                    throw new RuntimeException(e);
                }
            }
        }, "D").start();
    }
}

class Data2 {
    private int number = 0;

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

    public  void increment() throws InterruptedException {

        lock.lock();
        try {
            while (number != 0) {
                condition.await();
            }

            number++;
            // 通知其他线程
            condition.signalAll();
            System.out.println(Thread.currentThread().getName() + "=>" + number);

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }

    }

    public  void decrement()   {
        lock.lock();
        try {
            while (number == 0) {
                condition.await();
            }
            number--;
            condition.signalAll();
            System.out.println(Thread.currentThread().getName() + "=>" + number);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}

Lock 可以精准唤醒进程

可以设置多个监视器

5、8锁现象

如何判断锁的是谁！

s锁就是关于锁的8个问题
1. 标准情况下连个线程先打印发短信还是打电话 1、发短信 2、打电话都是phone 调用所以先发短信后打电话
1. 发短信方法延迟四秒两个线程先打印？发短信还是先
1. 加入普通方法后先发短信还是普通方法？执行普通方法
1. 两个对象两个同步方法先发短信还是先打电话？先打电话对象不同 phone2 和phone1 各有一把锁
1. 增加两个静态方法，只有一个对象，先打印发短信还是打电话？发短信static 锁的是类全局唯一
1. 两个对象！增加两个静态的同步方法先打印发短信还是打电话？发短信 static 锁的是class class只有一个
1. 一个是静态同步方法一个是普通同步方法，一个一下先发育发短信还是打电话？打电话
1. 一个是静态同步方法一个是普通同步方法

package com.lmq.lock8;

import java.util.concurrent.TimeUnit;

/**
 * @author 羡鱼
 * @version 1.0
 * @date 2023/7/29 20:28
 *
 *
 *
 * s锁就是关于锁的8个问题
 * 1. 标准情况下 连个线程先打印 发短信还是打电话  1、发短信 2、打电话  都是phone 调用所以先发短信 后 打电话
 * 2. 发短信方法延迟四秒两个线程先打印？ 发短信还是先
 * 3. 加入普通方法后先发短信还是普通方法？     执行普通方法
 * 4. 两个对象 两个同步方法  先发短信还是先打电话？   先打电话 对象不同 phone2 和phone1 各有一把锁
 * 5. 增加两个静态方法，只有一个对象，先打印 发短信 还是打电话？  发短信static 锁的是类 全局唯一
 * 6. 两个对象！增加两个静态的同步方法 先打印发短信还是打电话？    发短信 static 锁的是class class只有一个
 * 7. 一个是静态同步方法一个是普通同步方法， 一个一下先发育发短信还是打电话？  打电话
 * 8. 一个是静态同步方法一个是普通同步方法
 *
 */
public class Text1 {

    public static void main(String[] args) throws InterruptedException {
        Phone phone1 = new Phone();
        Phone phone2 = new Phone();
        new Thread(phone1::sendSms,"A").start();
        TimeUnit.SECONDS.sleep(1);
        new Thread(phone2::call,"B").start();

    }
}


class Phone{

    // synchronized  锁的对象是方法的调用者（在上面可以看到锁的phone phone调用的方法）！  两个方法用的同一个锁 谁先拿到谁先执行
    public synchronized void sendSms(){
        try {
            TimeUnit.SECONDS.sleep(5);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        System.out.println("sendSms");
    }
    public synchronized void call(){
        System.out.println("call");
    }

    public void hello() {
        System.out.println("hello");
    }
}

小结

new this 具体的一个手机

static Class 唯一的一个模版

6、集合类不安全

并发下集合就不安全

package com.lmq.unsafe;

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

/**
 * @author 羡鱼
 * @version 1.0
 * @date 2023/7/29 21:13
 */

// java.util.ConcurrentModificationException
public class ListTest1 {
    public  static void main(String[] args) {

        // 并发下 ArrayList 不安全
        // 解决方案
        // 1.  在ArrayList 前面就已经有 Vector（）  在java 1.0 就有了
        // 2.  Collections.synchronizedList(new ArrayList<>())
        // 3.  new CopyOnWriteArrayList<>();  JUC方案
        //   CopyOnWrite 写入时复制  COW 计算机程序设计领域的一种优化策略
        //   多线程调用的时候 List 读取的时候 固定的写入（覆盖）
        //  在写入的时候避免覆盖  造成数据问题
        //  在写入的时候避免覆盖 造成数据问题
        // 读写分离


        // CopyOnWriteArrayList<>() 比 Vector()  强在哪里  只要用synchronized效率就比lock锁底

//        ArrayList<String> list = new ArrayList<>();
//        List<String> list = Collections.synchronizedList(new ArrayList<>()) ;
        List<String> list = new CopyOnWriteArrayList<>();

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

学习方法推荐 1.先学会用 2.货比三家寻找解决方案 3.分析源码

Set 方法不安全

package com.lmq.unsafe;

import java.util.*;
import java.util.concurrent.CopyOnWriteArraySet;

/**
 * @author 羡鱼
 * @version 1.0
 * @date 2023/7/30 10:14
 */
public class SetTest {
    public static void main(String[] args) {
//        HashSet<String> set = new HashSet<>();
        //  java.util.ConcurrentModificationException
//       方案一 Set<Object> set = Collections.synchronizedSet(new HashSet<>());
//      方案二  Set<String> set = new CopyOnWriteArraySet<>();
        Set<String> set = new CopyOnWriteArraySet<>();


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

hashSet 底层是什么？

就是HashMap

7、Map 不安全

package com.lmq.unsafe;

import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import java.util.UUID;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;

/**
 * @author 羡鱼
 * @version 1.0
 * @date 2023/7/30 10:50
 */
public class MapTest {
    public static void main(String[] args) {
        // 什么是map  是怎么用的  等价于什么
        // 不用  工作中不用HashMap
        // 默认等价于什么  new HashMap<>(16,0.75)
//        Map<String, String> map = new HashMap<>();
//        Map map = Collections.synchronizedMap(new HashMap<String,String>());
        Map<String, String> map = new ConcurrentHashMap<>();
        // 加载因子  初始化容量

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

    }
}

7、 Callable （简单）

Thread 只能接受 Runable

new thread(new Runnable()).start();
new Thread(new FutureTask()).start();
两个对等 FutureTask是Runnable的实现类
new Thread(new FutureTask()).start();

package com.lmq.callable;

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

/**
 * @author 羡鱼
 * @version 1.0
 * @date 2023/7/30 11:38
 */
public class CallableTest {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        // new thread(new Runnable()).start();
        // new Thread(new FutureTask<V>()).start();
        // 两个对等 FutureTask是Runnable的实现类
//        new Thread(new FutureTask<V>()).start();


        new Thread().start();
        MyThread thread = new MyThread();

        FutureTask futureTask = new FutureTask(thread);

        new Thread(futureTask,"A").start();
        new Thread(futureTask,"B").start(); // 细节 结果有缓存 只打印一个hello   结果可能需要等待 会阻塞
        Object o = futureTask.get(); // 获取Callable 返回值
        System.out.println(o);
    }
}

class MyThread implements Callable<Integer> {

    @Override
    public Integer call() throws Exception {
        System.out.println("hello");
        return 1024;
    }
}

8、常用辅助类

8.1、 CounDownLatch (减法器)

package com.lmq.add;

import java.util.concurrent.CountDownLatch;

/**
 * @author 羡鱼
 * @version 1.0
 * @date 2023/7/30 13:50
 */
public class CountDownLatchDemo {
    public static void main(String[] args) throws InterruptedException {
        CountDownLatch countDownLatch = new CountDownLatch(6);

        for (int i = 1; i <= 6; i++) {
            new Thread(()->{
                System.out.println(Thread.currentThread().getName()+"Go out");
                countDownLatch.countDown(); //-1
            },String.valueOf(i)).start();
        }
        countDownLatch.await(); // 等待计数器归零，然后再向下执行

        System.out.println("close Door");

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

    }
}

原理：

countDiwnLatch.countDown() // 数量-1

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

每次线程调用countDown() 数量-1 假设计数器变量为 0 countFownLacth.await()就会被唤醒

8.2、 CyclicBarrier （加法器）

package com.lmq.add;

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

/**
 * @author 羡鱼
 * @version 1.0
 * @date 2023/7/30 14:51
 */
public class CylicbarrierDemo {
    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;
            new Thread(()->{
                System.out.println(Thread.currentThread().getName()+"收集"+temp+"个龙珠");
                try {
                    cyclicBarrier.await();
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                } catch (BrokenBarrierException e) {
                    throw new RuntimeException(e);
                }

            }).start();
        }
    }
}

8.3、Semaphore 信号量 [限流资源数量限制]

package com.lmq.add;

import java.util.concurrent.Semaphore;
import java.util.concurrent.TimeUnit;

/**
 * @author 羡鱼
 * @version 1.0
 * @date 2023/8/1 19:37
 */
public class SemaphoreDemo {
    public static void main(String[] args) {
        // 线程数量；  例子 停车位   限流使用
        Semaphore semaphore = new Semaphore(3);

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

            },String.valueOf(i)).start();
        }
    }
}

原理：

semaphore.acquire() 获得，假设如果已经满了，等待，等待被释放为止 -1 操作

semaphore.r elease()释放,将会将当前的信号量释放 +1

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

9、 ReadwriteLock 读写锁

关联了一堆licks 一个只用来读【可以多个线程同时读】一个只用来写【写是独家的】

package com.lmq.rw;

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

/**
 * @author 羡鱼
 * @version 1.0
 * @date 2023/8/1 19:52
 *
 * 独占锁（写锁） 一次只能被一个线程占有
 * 共享锁（读锁）多个线程可以同时占有
 * ReadWriteLock
 * 读-读 可以共存
 * 读-写 不可以共享
 * 写-写 不可以共存
 *
 * 自定义缓存
 */
public class ReadWriteLockDome {
    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();
        }
    }
}

/**
 * * 自定义缓存
 * 一般常使用 get put
 */

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 + "读取完成");
    }
}

/**
 * * 自定义缓存
 * 一般常使用 get put
 * 枷锁
 */

class MyCacheLock {
    private volatile Map<String, Object> map = new HashMap<>();
//    private Lock lock = new ReentrantReadWriteLock().readLock();
    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) {
            throw new RuntimeException(e);
        } 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) {
            throw new RuntimeException(e);
        } finally {
            readWriteLock.readLock().unlock();
        }
    }
}

10、阻塞队列

不得不阻塞

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

读取如果队列是空的就必须阻塞等待

BlockingQueue 不是新东西

什么情况下我们会使用阻塞队列：

多线程： A->b

线程池：

学会使用队列

添加移除

四组API

1、抛出异常

2、不会抛出异常

3、阻塞等待

4、超时等待

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

package com.lmq.bq;

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.TimeUnit;

/**
 * @author 羡鱼
 * @version 1.0
 * @date 2023/8/1 21:09
 */
public class Test {
    public static void main(String[] args) throws InterruptedException {
        // collection  数组 结合的父类
        // List
        // Set
        //  Queue 下有
        //  blockingQueue 阻塞队列 不是新东西
        //  ArrayDeque 双端队列
        //  AbstractQueue 非阻塞队列

//        test1();
//        test2();
//        test3();
        test4();
    }

    /*
     * 抛出异常
     * */
    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"));

        System.out.println(blockingQueue.element()); // 查看队首元素

        System.out.println("========");
        // 队列满了  Queue full  抛出异常
//        System.out.println(blockingQueue.add("d"));
        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<Object> blockingQueue = new ArrayBlockingQueue<>(3);

        System.out.println(blockingQueue.offer("a"));
        System.out.println(blockingQueue.offer("b"));
        System.out.println(blockingQueue.offer("c"));
        // 返回false
        System.out.println(blockingQueue.offer("d"));

        System.out.println("======");
        System.out.println(blockingQueue.peek());

        System.out.println(blockingQueue.poll());
        System.out.println(blockingQueue.poll());
        System.out.println(blockingQueue.poll());
        // 返回  null
        System.out.println(blockingQueue.poll());
    }

    /*
     *
     * 等待  阻塞 （一直阻塞）
     *
     * */
    public static void test3() throws InterruptedException {
        ArrayBlockingQueue<Object> blockingQueue = new ArrayBlockingQueue<>(3);

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

        blockingQueue.put("d");


        System.out.println(blockingQueue.take());
        System.out.println(blockingQueue.take());
        System.out.println(blockingQueue.take());
    }

    public static void test4() throws InterruptedException {
        ArrayBlockingQueue<Object> blockingQueue = new ArrayBlockingQueue<>(3);

        blockingQueue.offer("a");
        blockingQueue.offer("b");
        blockingQueue.offer("c");
        blockingQueue.offer("d",2, TimeUnit.SECONDS);
        System.out.println("=======");
        System.out.println(blockingQueue.poll());
        System.out.println(blockingQueue.poll());
        System.out.println(blockingQueue.poll());
        System.out.println(blockingQueue.poll(2, TimeUnit.SECONDS));
    }
}

异步队列

package com.lmq.bq;

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

/**
 * @author 羡鱼
 * @version 1.0
 * @date 2023/8/2 13:45
 */
public class SynchronousQueueDemo {
    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) {
                throw new RuntimeException(e);
            }
        }, "T2").start();
    }
}

学了技术不会用

11、线程池(重点)

线程池：三大方法、七大参数、四种拒绝

池化技术

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

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

池化技术: 事先准备一些资源，有人要用，就来这里拿，用完后还回来

线程池的好处：

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

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

线程池：三大方法

强制不允许使用Executors去创建通过ThreadPoolExecutor的方式，这样的处理方式让写的同学更加明确线程池的运行规则，规避资源殆尽的风险

package com.lmq.pool

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

/**
 * @author 羡鱼
 * @version 1.0
 * @date 2023/8/2 16:39
 */

// Excutors 工具类 三大方法
// 使用线程池之后，使用线程池来创建线程
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();
        }


    }
}

七大参数

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

本质

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

手动创建线程池

package com.lmq.pool;

import java.util.concurrent.*;

/**
 * @author 羡鱼
 * @version 1.0
 * @date 2023/8/2 16:39
 */

// Excutors 工具类 三大方法
// 使用线程池之后，使用线程池来创建线程
    /*
    *
    * new ThreadPoolExecutor.AbortPolicy()); // 队列满了 不处理这个人的 抛出异常
    *
    * */
public class Demo01 {
    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()  // 哪里来的回哪里去
//        ,new ThreadPoolExecutor.DiscardPolicy()  // 队列满了 丢掉任务  不会抛出异常
        ,new ThreadPoolExecutor.DiscardOldestPolicy()  // 队列满了 尝试去和最早的竞争  也不会抛异常
        );
//       ExecutorService threadPool = Executors.newSingleThreadExecutor();// 单个线程
//       ExecutorService threadPool = Executors.newFixedThreadPool(5); // 创建一个固定的线程池的大小
//       ExecutorService threadPool = Executors.newCachedThreadPool(); // 可伸缩的，遇强则强，遇弱则弱

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


    }
}

四种拒绝策略

//        ,new ThreadPoolExecutor.AbortPolicy()  // 队列满了 不处理这个任务 抛出异常
//        ,new ThreadPoolExecutor.CallerRunsPolicy()  // 哪里来的回哪里去
//        ,new ThreadPoolExecutor.DiscardPolicy()  // 队列满了 丢掉任务  不会抛出异常
        ,new ThreadPoolExecutor.DiscardOldestPolicy()  // 队列满了 尝试去和最早的竞争  也不会抛异常

package com.lmq.pool;

import java.util.concurrent.*;

/**
 * @author 羡鱼
 * @version 1.0
 * @date 2023/8/2 16:39
 */

// Excutors 工具类 三大方法
// 使用线程池之后，使用线程池来创建线程
    /*
    *
    * new ThreadPoolExecutor.AbortPolicy()); // 队列满了 不处理这个人的 抛出异常
    *
    * */
public class Demo01 {
    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()  // 哪里来的回哪里去
//        ,new ThreadPoolExecutor.DiscardPolicy()  // 队列满了 丢掉任务  不会抛出异常
        ,new ThreadPoolExecutor.DiscardOldestPolicy()  // 队列满了 尝试去和最早的竞争  也不会抛异常
        );
//       ExecutorService threadPool = Executors.newSingleThreadExecutor();// 单个线程
//       ExecutorService threadPool = Executors.newFixedThreadPool(5); // 创建一个固定的线程池的大小
//       ExecutorService threadPool = Executors.newCachedThreadPool(); // 可伸缩的，遇强则强，遇弱则弱

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


    }
}

小结

了解 IO密集型 CPU密集型（调优）

// 最大线程如何定义

// 最大线程到底如何定义
// 1. cpu密集型
System.out.println(Runtime.getRuntime().availableProcessors());
// 2. IO 密集型   判断在程序中十分占用IO的线程 > 2倍数


    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()  // 哪里来的回哪里去
//        ,new ThreadPoolExecutor.DiscardPolicy()  // 队列满了 丢掉任务  不会抛出异常
        ,new ThreadPoolExecutor.DiscardOldestPolicy()  // 队列满了 尝试去和最早的竞争  也不会抛异常
        );

12、四大函数式接口（必须掌握）

新时代的程序员

lambda表达式
链式编程

函数式接口

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

// 超级多 FunctionalInterface
// 简化编程模型，在新版本的框架底层大量运用
// doreach(消费者类型的函数式接口)

Stream流式计算

代码测试

函数式接口

package com.lmq.function;

import java.util.function.Function;

/**
 * @author 羡鱼
 * @version 1.0
 * @date 2023/8/2 18:21
 */



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

        };
        System.out.println(funktion.apply("666"));

    }
}

断定型接口

package com.lmq.function;

import java.util.function.Predicate;

/**
 * @author 羡鱼
 * @version 1.0
 * @date 2023/8/2 18:31
 */

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

        Predicate<String> predicate = (str) -> {
            return str.isEmpty();
        };
        System.out.println(predicate.test(""));
    }
}

消费型接口

package com.lmq.function;

import java.util.function.Consumer;

/**
 * @author 羡鱼
 * @version 1.0
 * @date 2023/8/2 19:05
 */

/*
*
* 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 = str->{
            return;
        };
        consumer.accept("t");
    }
}

供给型接口

package com.lmq.function;

import java.util.function.Supplier;

/**
 * @author 羡鱼
 * @version 1.0
 * @date 2023/8/2 19:19
 */

/*
* Supplier 供给型接口  没有参数  只有返回值
*
* */
public class Demo04 {
    public static void main(String[] args) {

//        Supplier supplier = new Supplier() {
//            @Override
//            public Object get() {
//                System.out.println("get()");
//                return 1024;
//            }
//        };

        Supplier supplier = ()->{
            System.out.println("get()");
            return 1024;
        };
        System.out.println(supplier.get());

    }
}

13、 Strean 流式计算

什么是Stream 流式计算

大数据：存储 + 计算

集合、Mysql本质就是存储东西

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

package com.lmq.stream;

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

/**
 * @author 羡鱼
 * @version 1.0
 * @date 2023/8/2 20:32
 */

/*
 * 题目要求 一分钟内完成此题，只能用一行代码实现！
 * 现在有5个用户！ 筛选
 * 1. ID 必须是偶数
 * 2. 年龄必须大于23岁
 * 3. 用户名转化为大写字母
 * 4. 用户名字字母倒着排序
 * 5. 只输入一个用户！
 *
 * */
public class Test {
    public static void main(String[] args) {
        User a = new User(1, "a", 21);
        User b = new User(2, "b", 22);
        User c = new User(3, "c", 23);
        User d = new User(4, "d", 24);
        User e = new User(5, "e", 25);
        User f = new User(6, "f", 26);
        // 集合就是存储
        List<User> list = Arrays.asList(a, b, c, d, e, f);
//        list.forEach(System.out::println);
        // 计算交给Stream流   链式编程
        list.stream()
                .filter(u -> {return u.getId() % 2 == 0;})
                .filter(u->{return u.getAge()>23;})
                .map(u->{return u.getName().toUpperCase();})
                .sorted((u1,u2)->{return u2.compareTo(u1);})
                .limit(1)
//                .collect(Collectors.toList());
                .forEach(System.out::println);
//        System.out.println(list);
    }
}

14、 ForkJoin

什么是forkjoin 在1.7 出来的并行执行！提高效率大数据量

大数据： mapreduce (把大任务才分为小任务)

ForkJoin特点：工作窃取双端队列

当一个线程的任务执行完毕后会去执行其他线程的工作

ForkJoin

package com.lmq.forkjoin;

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

/**
 * @author 羡鱼
 * @version 1.0
 * @date 2023/8/3 9:10
 *
 * 同一个任务别人高你几十倍
 */
public class Test {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
//        test1(); // 6866  6638
//        test2(); // 3458   3211
        test3();  //173  // 183
    }

    // 普通程序员
    public static void test1() {
        long start = System.currentTimeMillis();
        Long sum = 0L;
        for (Long i = 01L; i < 10_0000_0000L; i++) {
            sum += i;
        }
        System.out.println(sum);

        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, 10_0000_0000L);
//        forkJoinPool.execute(task); // 执行任务
        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, 10_0000_0000L).parallel().reduce(0, Long::sum);

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

}

package com.lmq.forkjoin;

import java.util.concurrent.RecursiveTask;

/**
 * @author 羡鱼
 * @version 1.0
 * @date 2023/8/3 8:47
 * <p>
 * 求和计算的任务   强一点的使用 ForkJoin   stream并行流
 * 如何使用ForkJoin
 * 1. forkjoinpool 通过这个来执行
 * forkjoinpool.execute(ForkJoinTask task)
 * 2. 计算仍无 ForkJoinTask<V> 递归事件  递归仍无
 * 3. 计算类 继承RecursiveTask
 */
public class ForkJoinDemo extends RecursiveTask<Long> {
    private Long start;
    private Long end;

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

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

//    public static void main(String[] args) {
//
//    }

//
//    public void ForkJoinTest() {
//        if ((end - start) > temp) {
//            // 合并分支计算
//        } else {
//            int sum = 0;
//            for (int i = 1; i < 10_0000_0000; i++) {
//                sum += i;
//            }
//            System.out.println(sum);
//        }
//    }

    @Override    //计算方法
    protected Long compute() {
        if ((end - start) < temp) {
            long sum = 0L;
            for (Long i = start; i <= end; i++) {
                sum += i;
            }
            return sum;
        } else {
            long middle = (start + end) / 2; // 中间值
            ForkJoinDemo test1 = new ForkJoinDemo(start, middle);
            test1.fork(); // 拆分任务 把对象压入线程队列
            ForkJoinDemo test2 = new ForkJoinDemo(middle + 1, end);
            test2.fork(); // 拆分任务 把任务压入线程队列
            return test1.join() + test2.join();
        }
    }
}

15、异步调回

package com.lmq.future;

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

/**
 * @author 羡鱼
 * @version 1.0
 * @date 2023/8/3 9:59
 */

/*
 * 异步调用： ajax
 *  异步执行
 *  成功回调
 *  失败回调
 * */
public class Demo01 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        // 发起一个请求
        // 没有返回值的异步回调

//        CompletableFuture<Void> completableFuture = CompletableFuture.runAsync(() -> {
//            try {
//                TimeUnit.SECONDS.sleep(5);
//            } catch (InterruptedException e) {
//                throw new RuntimeException(e);
//            }finally {
//                System.out.println(Thread.currentThread().getName() + "runAsync=>Void");
//            }
//
//        });
//        System.out.println("1111");
//        completableFuture.get(); // 获取阻塞执行结果


        // 有返回值的异步回调
        // 返回成功或者失败
        CompletableFuture<Integer> completableFuture = CompletableFuture.supplyAsync(() -> {

            System.out.println(Thread.currentThread().getName() + "supplyAsync=>Integer");
            int a = 10/0;
            return 1024;
        });

        System.out.println(completableFuture.whenComplete((u1, u2) -> {
            System.out.println("u1=>"+u1);   // 正常返回结果
            System.out.println("u2=>"+u2);  // 错误信息
        }).exceptionally((e) -> {
            System.out.println(e.getMessage());
            return 233; // 获取错误得分返回结果
        }).get());
    }
}

16、 JMM问题

请谈谈你对Volatile的理解

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

1、保证可见性

2、不保证原子性

3、禁止指令重排

什么是JMM

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

保持线程安全

关于jmm的一些同步机制：

1、线程解锁前，必须把共享变量立刻刷回主存

2、线程加锁前，必须读取主存中的新值到工作内存中！

3、枷锁和解锁是同一把锁

线程 工作内存、主内存

8种操作

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

17、 volatile

保证可见性

package com.lmq.tvolatitle;

import java.util.concurrent.TimeUnit;

/**
 * @author 羡鱼
 * @version 1.0
 * @date 2023/8/3 10:58
 */
public class JMMDemo {
    // 不加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(5);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        num = 1;
        System.out.println(num);

    }
}

不保证原子性

原子性：不可分割

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

package com.lmq.tvolatitle;

/**
 * @author 羡鱼
 * @version 1.0
 * @date 2023/8/3 11:01
 */

// 不保证原子性
public class VDemo02 {
    // volatile 不保证原子性
    private volatile static int num = 0;
    public static void add(){
        num++;
    }
    public static void main(String[] args) {
        // 理论上结果为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);
    }
}

如果不使用 lock和 synchronized 怎样保证原子性

javap -c xxx.class

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

原子类为什么这么高级

package com.lmq.tvolatitle;

import java.util.concurrent.atomic.AtomicInteger;

/**
 * @author 羡鱼
 * @version 1.0
 * @date 2023/8/3 11:01
 */

// 不保证原子性
public class VDemo02 {
    // volatile 不保证原子性
    private volatile static AtomicInteger num = new AtomicInteger();
    public static void add(){
        // num ++; 不是原子操作
        num.getAndIncrement();// atomicInteger + 1 的方法  CAS
    }
    public static void main(String[] args) {
        // 理论上结果为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);
    }
}

这些类的底层都和操作系统挂钩！在内存中修改值！ Unsafe类是一个很特殊的存在

指令重排

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

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

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

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

我们所期望的是：从上到下 1234  2134 1324
可不可能是4123！

可能造成影响的结果 abxy 在四个值默认都是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指令作用

保证特点的操作执行顺序！
保证某些变量的内存可见性！（利用这些特性，就可以保证bolatile的可见性）

volatile 是可以保持可见性，不能保证原子性，由于内存屏障可以避免指令重排的现象参数

18、单例模式

饿汉式

package com.lmq.sigle;

/**
 * @author 羡鱼
 * @version 1.0
 * @date 2023/8/3 11:36
 */



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

懒汉式

package com.lmq.sigle;

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

/**
 * @author 羡鱼
 * @version 1.0
 * @date 2023/8/3 11:38
 */

/*
*  懒汉模式
*
* */

public class LazyMan {
    // 添加
    private static boolean lmq = false;

    private LazyMan(){
        synchronized (LazyMan.class){
            if (lmq == false){
                lmq = true;
            }else {
                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(); // 不是一个原子操作
                    /*
                    * 1. 分配内存空间
                    * 2. 执行构造方法，初始化对象
                    * 3. 把这个对象指向这个空间
                    * */
                }
            }
        }

        return lazyMan;
    }
    // 多线程并发

    // 反射 只要有反射 所有的私有变量都可以破坏
    public static void main(String[] args) throws NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {
        LazyMan instance = LazyMan.getInstance();
        Constructor<LazyMan> declaredConstructor = LazyMan.class.getDeclaredConstructor(null);
        declaredConstructor.setAccessible(true); // 无视了私有构造器
        LazyMan instance2 = declaredConstructor.newInstance();

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

    }


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

}

内部类

package com.lmq.sigle;

/**
 * @author 羡鱼
 * @version 1.0
 * @date 2023/8/3 11:46
 */
public class Holder {
    private Holder(){

    }
    private static Holder getInstance(){
        return InnerClass.HOLDER;
    }

    public static class InnerClass{
        private static Holder HOLDER = new Holder();
    }
}

枚举最后反编译是有有构造参数的 string 和 int

package com.lmq.sigle;

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

/**
 * @author 羡鱼
 * @version 1.0
 * @date 2023/8/3 13:05
 */


/*
 * 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 instance = EnumSingle.INSTANCE;
        Constructor<EnumSingle> declaredConstructor = EnumSingle.class.getDeclaredConstructor(String.class,int.class);
        declaredConstructor.setAccessible(true);
        EnumSingle instance2 = declaredConstructor.newInstance();
        // java.lang.NoSuchMethodException
        System.out.println(instance);
        System.out.println(instance2);

    }



}

19、深入理解 CAS

什么是CAS

大厂必须深入研究底层！有所突破！ 修内功，操作系统，计算机网络原理

package com.lmq.cas;

import java.util.concurrent.atomic.AtomicInteger;

/**
 * @author 羡鱼
 * @version 1.0
 * @date 2023/8/3 13:51
 */
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的并发原语
        atomicInteger.compareAndSet(2020,2021);
        System.out.println(atomicInteger.get());

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

}

Unsafe 类

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

缺点：

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

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

package com.lmq.cas;

import java.util.concurrent.atomic.AtomicInteger;

/**
 * @author 羡鱼
 * @version 1.0
 * @date 2023/8/3 13:51
 */
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的并发原语
        //============捣乱线程===================
        atomicInteger.compareAndSet(2020,2021);
        System.out.println(atomicInteger.get());
        atomicInteger.compareAndSet(2021,2020);
        System.out.println(atomicInteger.get());
        //==============期望线程=================
        atomicInteger.compareAndSet(2020,2021);
        System.out.println(atomicInteger.get());
    }

}

20、原子引用

解决ABA问题解决方案类似于乐观锁

带版本

package com.lmq.cas;

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

/**
 * @author 羡鱼
 * @version 1.0
 * @date 2023/8/3 13:51
 */
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的并发原语
//        //============捣乱线程===================
//        atomicInteger.compareAndSet(2020,2021);
//        System.out.println(atomicInteger.get());
//        atomicInteger.compareAndSet(2021,2020);
//        System.out.println(atomicInteger.get());
//        //==============期望线程=================
//        atomicInteger.compareAndSet(2020,2021);
//        System.out.println(atomicInteger.get());

        // 注意 ，如果泛型是包装类，注意对象的引用问题

        // 正常业务这里一般引用的是一个对象
        AtomicStampedReference<Integer> atomicStampedReference = new AtomicStampedReference<>(1,1);
        new Thread(()-> {
            int stamp = atomicStampedReference.getStamp();// 获得版本号
            System.out.println("a1=>" + stamp);
            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            System.out.println(atomicStampedReference.compareAndSet(1, 2, atomicStampedReference.getStamp(), atomicStampedReference.getStamp() + 1));
            System.out.println("a2=>" + atomicStampedReference.getStamp());
            System.out.println(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(5);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            System.out.println(atomicStampedReference.compareAndSet(1, 66, stamp, stamp+1));
            System.out.println("b2=>"+atomicStampedReference.getStamp());
        },"b").start();

    }

}

21、各种锁的理解

1、公平锁

公平锁：非常公平不能插队，必须先来后到！

Lock lock = new ReentrantLock(true);

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

非公平锁：非常不公平可以插队（默认都是不公平）

Lock lock = new ReentrantLock();

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

2、可重入锁

可重入锁（递归锁）

synchronized锁

package com.lmq.lock;

/**
 * @author 羡鱼
 * @version 1.0
 * @date 2023/8/3 15:42
 */
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.lmq.lock;

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

/**
 * @author 羡鱼
 * @version 1.0
 * @date 2023/8/3 15:51
 */
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) {
            throw new RuntimeException(e);
        } finally {
            lock.unlock();
        }
    }
    public  void call(){
        lock.lock();
        try {
            System.out.println(Thread.currentThread().getName() + "call");
        } catch (Exception e) {
            throw new RuntimeException(e);
        } finally {
            lock.unlock();
        }
    }
}

3、自旋锁

Spinlock

package com.lmq.lock;

import java.util.concurrent.atomic.AtomicReference;

/**
 * @author 羡鱼
 * @version 1.0
 * @date 2023/8/3 15:58
 */
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.lmq.lock;

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

/**
 * @author 羡鱼
 * @version 1.0
 * @date 2023/8/3 16:04
 */
public class TestSpinLock {
    public static void main(String[] args) throws InterruptedException {
//        ReentrantLock reentrantLock = new ReentrantLock();
//        reentrantLock.lock();
//        reentrantLock.unlock();

        // 底层使用的自旋锁CAS
        SpinlockDemo lock = new SpinlockDemo();

        new Thread(() -> {
            lock.myLock();
            try {
                TimeUnit.SECONDS.sleep(3);
            } catch (Exception e) {
                throw new RuntimeException(e);
            } finally {
                lock.myUnLock();
            }
        }, "T1").start();

        TimeUnit.SECONDS.sleep(1);

        new Thread(() -> {
            lock.myLock();
            try {
                TimeUnit.SECONDS.sleep(3);
            } catch (Exception e) {
                throw new RuntimeException(e);
            } finally {
                lock.myUnLock();
            }
        }, "T2").start();

//        lock.myLock();
//        lock.myUnLock();

    }
}

4、死锁

死锁是什么

死锁测试怎么排除死锁

package com.lmq.lock;

import java.util.concurrent.TimeUnit;

/**
 * @author 羡鱼
 * @version 1.0
 * @date 2023/8/3 16:40
 */
public class DeadLockDemo {
    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(5);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            synchronized (lockB){
                System.out.println(Thread.currentThread().getName()+"lock:"+lockB+"=》get"+lockA);
            }
        }
    }
}

解决问题

jdk bin目录

使用 jps 定位进程号 jps -l
使用jstack进程号

面试，工作中！排除问题

1、日志

2、堆栈信息

posted @ 2023-07-30 13:58 吾执青剑向天涯阅读(17) 评论(0) 编辑收藏举报

刷新页面返回顶部

羡鱼

java多线程

1、什么是JUC

2、线程和进程

1、来自不同的类

2、关于锁的释放

3、使用范围是不同的

4、是否要捕获异常

3、Lock锁（重点）

4、生产者和消费者的问题

5、8锁现象

6、集合类不安全

Set 方法不安全

7、Map 不安全

7、 Callable （简单）

8、常用辅助类

8.1、 CounDownLatch (减法器)

8.2、 CyclicBarrier （加法器）

8.3、Semaphore 信号量 [限流资源数量限制]

9、 ReadwriteLock 读写锁

10、阻塞队列

学会使用队列

四组API

11、线程池(重点)

12、四大函数式接口（必须掌握）

13、 Strean 流式计算

14、 ForkJoin

17、 volatile

18、单例模式

20、原子引用

21、各种锁的理解

1、公平锁

2、可重入锁

3、自旋锁

4、死锁

公告

羡鱼

java多线程

1、什么是JUC

2、线程和进程

1、来自不同的类

2、关于锁的释放

3、使用范围是不同的

4、是否要捕获异常

3、Lock锁（重点）

4、生产者和消费者的问题

5、8锁现象

6、集合类不安全

Set 方法不安全

7、Map 不安全

7、 Callable （简单）

8、常用辅助类

8.1、 CounDownLatch (减法器)

8.2、 CyclicBarrier （加法器）

8.3、Semaphore 信号量 [限流 资源数量限制]

9、 ReadwriteLock 读写锁

10、 阻塞队列

学会使用队列

四组API

11、 线程池(重点)

12、 四大函数式接口（必须掌握）

13、 Strean 流式计算

14、 ForkJoin

17、 volatile

18、 单例模式

20、原子引用

21、 各种锁的理解

1、 公平锁

2、可重入锁

3、 自旋锁

4、死锁

公告

8.3、Semaphore 信号量 [限流资源数量限制]

10、阻塞队列

11、线程池(重点)

12、四大函数式接口（必须掌握）

18、单例模式

21、各种锁的理解

1、公平锁

3、自旋锁