java多线程JUC学习笔记

最新推荐文章于 2024-09-24 14:05:35 发布

ahoges

最新推荐文章于 2024-09-24 14:05:35 发布

阅读量324

点赞数

文章标签： java 多线程

本文链接：https://blog.csdn.net/ahoges/article/details/106796666

版权

JUC（java.util.concurrent）

1.1 进程/线程

1.2并发/并行

并发编程：并发、并行

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

CPI一核，模拟出来多条线程，天下武功，唯快不破，快速交替

并行（多个人一起行走）

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

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

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

三个包

java.util.concurrent

java.util.concurrent.atomic

java.util.concurrent.locks

lock

公平锁

十分公平：可以先来后到

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

package com.atguigu.juc;

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
/*
    *真正的多线程开发，公司中的开发，降低耦合性
 */
//资源类=实例变量+实例方法
class Ticket{
    private int num = 30;
    //List list = new ArrayList();
    Lock lock = new ReentrantLock();
    public  void sale(){
        lock.lock();
        try {
            //业务代码
            if (num>0){
                System.out.println(Thread.currentThread().getName()+"------->卖出第:"+(num--)+"票\t还剩下:"+num+"张票");
            }
        }catch (Exception e){

        }finally {
            lock.unlock();  //解锁
        }

    }

}
/**
 * @Author:daMao
 * @Date: Created in 17:33 2020/5/27
 *
 * 题目：三个售票员 卖出  30长票
 * 笔记：如何编写企业级的多线程代码
 *  固定的变成套路+模板是什么？
 *  1、在高内聚低耦合的前提下，线程        操作      资源类
 *      1.1、一言不合，先创建一个资源类
 *
 *
 */
public class SaleTicketDemo01 {
    public static void main(String[] args) {
        //并发：多线程操作同一个资源类,把资源类丢入线程
        //资源类
        Ticket ticket = new Ticket();

        //@FunctionalInterface 函数式接口
        new Thread(()->{
            for (int i = 0; i < 60; i++) {
                ticket.sale();
            }
        },"A").start();
        new Thread(()->{
            for (int i = 0; i < 60; i++) {
                ticket.sale();
            }
        },"B").start();
        new Thread(()->{
            for (int i = 0; i < 60; i++) {
                ticket.sale();
            }
        },"C").start();


    }
}

Synchronized和lock锁的区别

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

2、Synchronized无法判断获取锁的状态，Lock可以判断是否获取到了锁

3、Synchronized会自动释放锁(a–b),lock必须要手动释放锁!如果不释放锁，会发生死锁

4、Synchronized线程1（获得锁）、线程2（等待）,如果线程1堵塞了，Lock锁就不一定会等待

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

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

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

4、生产者消费者

面试的：单例模式、排序算法、生产者和消费者、死锁

Synchronized版 wait，notify

juc lock

生产者和消费者问题Synchronized版本

package com.atguigu.pc;

/**
 * 线程之间的通信问题：生产者和消费者问题！ 等待唤醒，通知唤醒
 * 线程交替执行A  B操作同一个变量， num=0
 *
 * A    num+1
 * B    num-1
 * @Author:daMao
 * @Date: Created in 20:01 2020/5/27
 */

public class A {
    public static void main(String[] args) {
        Data data = new Data();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    data.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"A").start();

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

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

        //通知其他线程，我-1完毕了
        this.notifyAll();
    }

}

虚假唤醒

问题存在，ABCD4个线程，虚假唤醒

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-hE1xLPks-1592316907591)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20200529215039268.png)]

将if改为while判断

package com.atguigu.pc;

/**
 * 线程之间的通信问题：生产者和消费者问题！ 等待唤醒，通知唤醒
 * 线程交替执行A  B操作同一个变量， num=0
 *
 * A    num+1
 * B    num-1
 * @Author:daMao
 * @Date: Created in 20:01 2020/5/27
 */

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.notifyAll();
    }
    //-1
    public synchronized void decrement() throws InterruptedException {
        while (number==0){
            //等待
            this.wait();
        }
        number--;
        System.out.println(Thread.currentThread().getName()+"------>"+number);

        //通知其他线程，我-1完毕了
        this.notifyAll();
    }

}

JUC版本的生产者和消费者

通过Lock找到Condition

JUC版本的生产者和消费者

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-fcDA3Mzs-1592316907599)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20200529215950570.png)]

  class BoundedBuffer {
   final Lock lock = new ReentrantLock();
   final Condition notFull  = lock.newCondition(); 
   final Condition notEmpty = lock.newCondition(); 

   final Object[] items = new Object[100];
   int putptr, takeptr, count;

   public void put(Object x) throws InterruptedException {
     lock.lock(); try {
       while (count == items.length)
         notFull.await();
       items[putptr] = x;
       if (++putptr == items.length) putptr = 0;
       ++count;
       notEmpty.signal();
     } finally { lock.unlock(); }
   }

   public Object take() throws InterruptedException {
     lock.lock(); try {
       while (count == 0)
         notEmpty.await();
       Object x = items[takeptr];
       if (++takeptr == items.length) takeptr = 0;
       --count;
       notFull.signal();
       return x;
     } finally { lock.unlock(); }
   }
 }

代码实现

5、8锁现象

如何判断锁的对象

对象，class

深刻理解我们的锁

package com.atguigu.lock8;

import java.util.concurrent.TimeUnit;

/**
 *  3、增加了一个普通方法！先执行发短信还是hello
 * @Author:daMao
 * @Date: Created in 22:42 2020/5/29
 */
public class Test2 {
    public static void main(String[] args) {
        Phone2 phone1 = new Phone2();
        Phone2 phone2 = new Phone2();
        //phone.sendSms()
        //锁的存在
        new Thread(()->{
            phone1.sendSms();
        },"A").start();
        //捕获
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        new Thread(()->{
            phone2.call();
        },"B").start();
    }
}
class Phone2{
    //synchronized所的对象是方法的调用者
    //两个方法用的是同一个锁，谁先拿到谁执行
    public static synchronized void sendSms(){
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }
    public static synchronized void call(){
        System.out.println("打电话");

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

小节：

new 出来的 this 具体的一个手机

static Class 唯一的类对象（类加载机制）

List线程不安全

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 计算机程序设计领域的一种优化策略
        //多个线程调用的时候。List，读取的时候，固定的，写入（覆盖）
        //在写入的时候避免覆盖，造成数据问题
        //读写分离      MyCat
        //CopyOnWriteArrayList  比Vector强在那里
        List<String> list = new CopyOnWriteArrayList<>();

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


    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-nBrvTLnV-1592316907603)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20200529234256789.png)]

Set线程不安全

public class SetTest {
    public static void main(String[] args) {
//        HashSet<String> set = new HashSet<>();
        Set<String> set = new CopyOnWriteArraySet<>();
        for (int i = 1; i <= 30; i++) {
            new Thread(()->{
                set.add(UUID.randomUUID().toString().substring(0,5));
                System.out.println(set);
            },String.valueOf(i)).start();
        }
    }
}

hashSet底层就是HashMap

HashMap线程不安全

    public static void main(String[] args) {
        //map是这样用的吗，不是，工作中不用HashMap
        // 默认等价于什么？
//        HashMap<String, String> map = new HashMap<>(16,0.75f);

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

6、Callable

package com.atguigu.callable;

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

/**
 * @Author:daMao
 * @Date: Created in 10:00 2020/5/30
 */
public class CallableTest {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
//        new Thread(new Runnable()).start();
//        new Thread(new FutureTask<V>()).start();
//        new Thread(new FutureTask<V>(Callable)).start();

        new Thread().start();   //怎么启动callable?
        MyThread myThread = new MyThread();
        FutureTask<String> futureTask = new FutureTask<>(myThread); //适配类
        new Thread(futureTask,"A").start();
        String result = futureTask.get();	//这个get方法可能会产生阻塞，把他放到最后
        //或者使用异步通信来处理
        System.out.println(result);
    }
}

/*class MyThread implements Runnable{


    @Override
    public void run() {

    }
}*/
class MyThread implements Callable<String> {



    @Override
    public String call() throws Exception {
        System.out.println("call()");
        return "123";
    }
}

细节：

1、结果有缓存

2、结果可能需要等待，会阻塞

7、常用的辅助类（必会）

1、CountDownLatch

减法计数器，每个线程执行完毕后，计数器减一，当计数器为0时，进行后续操作

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-p9ac3yzH-1592316907606)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20200530102124164.png)]

    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() + " Go out");
                countDownLatch.countDown(); //数量-1
            }, String.valueOf(i)).start();
        }

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

2、CyclicBarrier

加法计数器

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-MbcYxOda-1592316907610)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20200530124659023.png)]


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

/**
 * @Author:daMao
 * @Date: Created in 12:49 2020/5/30
 */
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++) {
            final int temp = i;
            //lambda能操作到i吗
            new Thread(()->{
                System.out.println(Thread.currentThread().getName()+"收集"+temp+"个龙珠");
                try {
                    cyclicBarrier.await();//等待
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } catch (BrokenBarrierException e) {
                    e.printStackTrace();
                }
            }).start();
        }
    }
}

3、Semaphore

Semaphore：信号量

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-zRg42ZM6-1592316907613)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20200530125707847.png)]

抢车位

6个车，有3个停车位

原理:

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

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

8、读写锁

读可以多个线程读，但是写只能是一个线程写

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-hucgKRl4-1592316907621)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20200530140840094.png)]

package com.atguigu.rw;

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

/**
 * 独占锁（写锁）一次只能被一个线程占有
 * 共享锁（读锁）多个线程可以同时占有
 *
 * @Author:daMao
 * @Date: Created in 14:09 2020/5/30
 */
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 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() + "读取成功" + o);
    }
}

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

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

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

    }

    //取，读
    public void get(String key) {
        readWriteLock.readLock().lock();

        try {
            System.out.println(Thread.currentThread().getName() + "读取" + key);
            Object o = map.get(key);
            System.out.println(Thread.currentThread().getName() + "读取成功" + o);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            readWriteLock.readLock().unlock();
        }
    }
}

10、阻塞队列

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-JhBQfmSK-1592316907622)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20200530172711904.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-FPnMzLkm-1592316907625)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20200530172823041.png)]

阻塞队列：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-OzPDajTF-1592316907627)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20200530173018109.png)]

BlockingQueue

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-XIjZTxyD-1592316907632)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20200530173440024.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-5N0J3La5-1592316907641)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20200530174225850.png)]

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

学会使用队列

添加、移除

1、抛出异常

2、不会抛出异常

3、阻塞等待

4、超时等待

四组API

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

package com.atguigu.bq;

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

/**
 * @Author:daMao
 * @Date: Created in 17:30 2020/5/30
 */
public class Test {
    public static void main(String[] args) throws InterruptedException {

//        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"));
//        java.lang.IllegalStateException: Queue full
//        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("------------------------");
        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("-----------------");
        System.out.println(blockingQueue.take());
        System.out.println(blockingQueue.take());
        System.out.println(blockingQueue.take());
//        System.out.println(blockingQueue.take());

//        blockingQueue.take();
    }

    /*
        等待，阻塞(等待超时)
     */
    public static void test4() throws InterruptedException {
        ArrayBlockingQueue blockingQueue = new ArrayBlockingQueue<>(3);

        blockingQueue.offer("a");
        blockingQueue.offer("b");
        blockingQueue.offer("c");
        blockingQueue.offer("d", 2, TimeUnit.SECONDS);  //等待两秒，超时退出
        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));
    }
}

SynchronousQueue 同步队列

同步队列
和其他的BlockingQUeue不一样，SynchronousQueue不存储元素
put了一个元素，必须从里面先take

package com.atguigu.bq;

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

/**
 * 同步队列
 * 和其他的BlockingQUeue不一样，SynchronousQueue不存储元素
 * put了一个元素，必须从里面先take
 * @Author:daMao
 * @Date: Created in 18:38 2020/5/30
 */
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();
            }
        }).start();
        new Thread(() -> {
            try {
                TimeUnit.SECONDS.sleep(3);
                System.out.println(Thread.currentThread().getName() + "=>" + blockingQueue.take());
                TimeUnit.SECONDS.sleep(3);
                System.out.println(Thread.currentThread().getName() + "=>" + blockingQueue.take());
                TimeUnit.SECONDS.sleep(3);
                System.out.println(Thread.currentThread().getName() + "=>" + blockingQueue.take());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();

    }
}

11、线程池（重点）

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

池化技术

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

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

池化技术：

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

线程池的好处：

1、降低资源的消耗

2、提高响应的速度

3、方便管理

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

三大方法

package com.atguigu.pool;

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

/**
 * @Author:daMao
 * @Date: Created in 22:08 2020/5/30
 */

//Executors 工具类、3大方法
    //使用线程池之后，要使用线程池来创建线程
public class Demo1 {
    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 < 100; 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,
                                      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;
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-dA3xbBEy-1592316907644)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20200530231036256.png)]

手动创建一个线程池

        //自定义线程池！ThreadPoolExecutor
        ExecutorService threadPool = new ThreadPoolExecutor(2,
                5,
                3,
                TimeUnit.SECONDS,
                new LinkedBlockingDeque<>(3),
                Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.DiscardOldestPolicy());  //队列满了，尝试去和最早的竞争，也不会抛出异常

        try {
            //最大能承载：Deque+max
            //超出最大承载java.util.concurrent.RejectedExecutionException
            for (int i = 0; i < 9; i++) {
                threadPool.execute(() -> {
                    System.out.println(Thread.currentThread().getName() + "=>OK");
                });
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            //程序结束需要关闭线程池
            threadPool.shutdown();
        }

4种拒绝策略

//拒绝策略
//ThreadPoolExecutor.AbortPolicy());  //银行满了，还有人进来，不处理这个人，抛出异常
// new ThreadPoolExecutor.CallerRunsPolicy());  //哪来的去哪里！
// new ThreadPoolExecutor.DiscardPolicy());  //队列满了，抛弃线程
//  new ThreadPoolExecutor.DiscardOldestPolicy());  //队列满了，尝试去和最早的竞争，也不会抛出异常

小结与扩展

池的大小设置：了解IO密集型和CPU密集型（调优）！

//最大线程到底该如何定义
//1、CPU 密集型     几核就是几，可以保持性能最高    Runtime.getRuntime().availableProcessors(),
//2、IO  密集型   >  密集型、判断你的程序中十分耗IO的线程。
// 程序 15个大型任务，io十分占用资源！

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

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

只有一个方法的接口

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

//超级多FunctionalInterface
//简化编程模型、在新版本的框架底层大量应用
//foreach（消费者类的函数式接口）

代码测试

Function接口 //函数式接口：
Predicate接口 //断定型接口：有一个输入参数，返回值只能是布尔值
Consumer接口 //消费性接口：只有输入没有，返回值
Supplire 接口 //供给型接口: 有返回值

13、Stream流式计算

什么是Stream流式计算

大数据：存储+计算

集合、MySQL本质就是存储东西的；

计算都应该交给流来操作

public class Test {
    public static void main(String[] args) {
        User u1 = new User(1, "a", 21);
        User u2 = new User(2, "b", 22);
        User u3 = new User(3, "c", 23);
        User u4 = new User(4, "d", 24);
        User u5 = new User(6, "e", 25);

        //集合就是存储
        List<User> users = Arrays.asList(u1, u2, u3, u4, u5);
        //计算交给流
        users.stream()
                .filter(u->{return u.getId()%2==0;})
                .filter(user -> {return user.getAge()>23;})
                .map(user -> {return user.getName().toUpperCase();})
                .sorted((uu1,uu2)->{return uu2.compareTo(uu1); })
                .limit(1)
                .forEach(System.out::println);
    }
}

14、ForkJoin

什么是ForkJoin

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

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

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-vxz4Hcs6-1592316907646)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20200531211055137.png)]

ForkJoin特点：工作窃取

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

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-on1UYkTE-1592316907649)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20200531211330203.png)]

ForkJoin

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-OUYmelHc-1592316907655)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20200531213221244.png)]

15、异步回调

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

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-i0SI2VO0-1592316907657)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20200531224434207.png)]

16、JMM

请你谈谈你对volatile的理解

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

1、保证可见性

2、不保证原子性

3、禁止指令重排

什么是JMM？

JVM是java虚拟机，JMM是java内存模型，是一种概念

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

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

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

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

线程：做工内存、主内存

8种操作：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-L9DYfdW1-1592316907661)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20200601005523322.png)]

问题：线程B修改了值，但是线程A是不能即时可见的

关于主内存与工作内存之间的具体交互协议，即一个变量如何从主内存拷贝到工作内存、如何从工作内存同步到主内存之间的实现细节，Java内存模型定义了以下八种操作来完成：

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

Java内存模型还规定了在执行上述八种基本操作时，必须满足如下规则：

如果要把一个变量从主内存中复制到工作内存，就需要按顺寻地执行read和load操作，如果把变量从工作内存中同步回主内存中，就要按顺序地执行store和write操作。但Java内存模型只要求上述操作必须按顺序执行，而没有保证必须是连续执行。
不允许read和load、store和write操作之一单独出现
不允许一个线程丢弃它的最近assign的操作，即变量在工作内存中改变了之后必须同步到主内存中。
不允许一个线程无原因地（没有发生过任何assign操作）把数据从工作内存同步回主内存中。
一个新的变量只能在主内存中诞生，不允许在工作内存中直接使用一个未被初始化（load或assign）的变量。即就是对一个变量实施use和store操作之前，必须先执行过了assign和load操作。
一个变量在同一时刻只允许一条线程对其进行lock操作，但lock操作可以被同一条线程重复执行多次，多次执行lock后，只有执行相同次数的unlock操作，变量才会被解锁。lock和unlock必须成对出现
如果对一个变量执行lock操作，将会清空工作内存中此变量的值，在执行引擎使用这个变量前需要重新执行load或assign操作初始化变量的值
如果一个变量事先没有被lock操作锁定，则不允许对它执行unlock操作；也不允许去unlock一个被其他线程锁定的变量。
对一个变量执行unlock操作之前，必须先把此变量同步到主内存中（执行store和write操作）。

问题：程序不知道主存已发生改变

17、volatile

Java语言提供了一种稍弱的同步机制，即volatile变量，用来确保将变量的更新操作通知到其他线程。当把变量声明为volatile类型后，编译器与运行时都会注意到这个变量是共享的，因此不会将该变量上的操作与其他内存操作一起重排序。volatile变量不会被缓存在寄存器或者对其他处理器不可见的地方，因此在读取volatile类型的变量时总会返回最新写入的值。

保证可见性

public class JMMDemo {
    private volatile static int num = 0;

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

            }
        }).start();
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        num =1;
        System.out.println(num);
    }

}

不保证原子性

原子性：ACID（不可分割）

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

public class VDemo02 {

    private static int num = 0;

    private static void add(){
        num++;
    }
    public static void main(String[] args) {
        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怎么保证原子性?

AtomicInteger

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

禁止指令重排

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

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

int x=1;	//1
int y=2;	//2
x = x+6;	//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指令。作用：

1、保证特定的操作的执行顺序！

2、可以保证某些变量的内存可见性（利用这些特性就可以保证volatile实现了可见性）

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-0m6Vda8C-1592316907662)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20200601013813762.png)]

Volatile是可以保持可见性。不能保证原子性，由于内存屏障，可以保证避免指令重排的现象产生！

18、彻底玩转单例模式

饿汉式，DCL懒汉式，深究！

//饿汉式单例
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(){
        synchronized (LazyMan.class){
            if (lazyMan!=null){
                throw new RuntimeException("不要试图使用反射破坏异常");
            }
        }
        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、把这个对象指向这个空间
                     */
                }
            }
        }

        return lazyMan;
    }

    //反射
    public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
        LazyMan instance = LazyMan.getInstance();
        Constructor<LazyMan> declaredConstructor = LazyMan.class.getDeclaredConstructor(null);
        declaredConstructor.setAccessible(true);
        LazyMan instance2 = declaredConstructor.newInstance();
        System.out.println(instance.hashCode());
        System.out.println(instance2.hashCode());
    }
}

19、深入理解CAS

什么是CAS

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

Unsafe类

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

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

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-fhGgfeNX-1592316907666)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20200601124201997.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-4hkColDx-1592316907669)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20200601124302202.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-wjfE4EAq-1592316907672)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20200601124233117.png)]

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

缺点：

1、循环会耗时

2、一次性只能保证一个共享变量的原子性

3、ABA问题

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

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-2M7MPKeL-1592316907674)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20200601125009033.png)]

package com.atguigu.cas;

import java.util.concurrent.atomic.AtomicInteger;

/**
 * @Author:daMao
 * @Date: Created in 12:32 2020/6/1
 */
public class CASDemo {

    //CAS       compareAndSet：比较并交换！
    public static void main(String[] args) {
        AtomicInteger atomicInteger = new AtomicInteger(2020);
        //对于我们平时写的sql：乐观锁
        //期望、更新
        //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(2021, 2020));
        System.out.println(atomicInteger.get());
        //=============期望的线程=============
        System.out.println(atomicInteger.compareAndSet(2020, 6666));
        System.out.println(atomicInteger.get());
    }
}

20、原子引用

解决ABA问题，引入原子引用

带版本号的原子操作

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

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-PrwIeiiK-1592316907677)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20200601131035584.png)]

21、各种锁的理解

1、公平锁、非公平锁

十分公平：可以先来后到

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

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

2、可重入锁

可重入锁（递归锁）

拿到了外面的锁之后，就可以拿到里面的锁，自动获得

synchronized

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

        new Thread(()->{
            phone.sms();
        },"B").start();
    }
}
class Phone{
    public synchronized void sms(){
        System.out.println(Thread.currentThread().getName()+"sms");
        call();     //这里也有锁
    }
    public synchronized void call(){
        System.out.println(Thread.currentThread().getName()+"call");
    }
}

Lock

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

    }
    public synchronized void call(){
        lock.lock();
        try {
            System.out.println(Thread.currentThread().getName()+"call");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}

3、自旋锁

4、死锁

5、悲观锁

总是假设最坏的情况，每次去拿数据的时候都认为别人会修改，所以每次在拿数据的时候都会上锁，这样别人想拿这个数据就会阻塞直到它拿到锁（共享资源每次只给一个线程使用，其它线程阻塞，用完后再把资源转让给其它线程）。传统的关系型数据库里边就用到了很多这种锁机制，比如行锁，表锁等，读锁，写锁等，都是在做操作之前先上锁。Java中synchronized和ReentrantLock等独占锁就是悲观锁思想的实现。

6、乐观锁

总是假设最好的情况，每次去拿数据的时候都认为别人不会修改，所以不会上锁，但是在更新的时候会判断一下在此期间别人有没有去更新这个数据，可以使用版本号机制和CAS算法实现。乐观锁适用于多读的应用类型，这样可以提高吞吐量，像数据库提供的类似于write_condition机制，其实都是提供的乐观锁。在Java中java.util.concurrent.atomic包下面的原子变量类就是使用了乐观锁的一种实现方式CAS实现的。
= 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

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

    }
    public synchronized void call(){
        lock.lock();
        try {
            System.out.println(Thread.currentThread().getName()+"call");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}