入门到入土，Java学习 day20(多线程下)-优快云博客

本文链接：https://blog.youkuaiyun.com/qq_61993735/article/details/146299448

void wait() 当前线程等待，直到被其他线程唤醒

void notify() 随机唤醒单个线程

void notifyAll() 唤醒所有线程

阻塞队列

在测试方法中创建带锁队列，然后在对象类中也创建队列但是不赋值，用构造方法将测试方法中的对象赋值

然后用put和take方法实现，这两个方法中自动上锁不需要再上锁，直接使用即可

线程状态

新增，就绪，阻塞，等待，计时等待，结束

线程池

之前的多线程用的时候就创建，用完就消除，浪费资源

核心原理

创建一个池子，里面是空的

提交任务时，池子会创建新的线程对象，任务执行完毕，线程归还给池子下回再次提交任务时，不需要创建新的线程，直接复用已有的线程即可

如果提交任务时，池子中没有空闲线程，也无法创建新的线程，任务就会排队等待

代码实现

Executors：线程池的工具类通过调用方法返回不同类型的线程池对象

public static ExecutorService newCachedThreadPool()创建一个没有上限的线程池

public static ExecutorService newFixedThreadPool(int nThreads)创建有上限的线程池

自定义线程池（有7个参数，核心线程数，线程池中最大线程的数量，空闲时间值，空闲时间单位，阻塞队列，创建线程的方式，拒绝解决方案）

当核心线程满了的时候，再提交任务就会排队

当核心线程满了，队伍满了，会创建临时线程

都满了，出发任务拒绝策略

ThreadPoolExecutor pool = new ThreadPoolExecutor(

corePoolSize:3,/核心线程数量，能小于0

maximumPoolSize:6,/最大线程数，不能小于0，最大数量>=核心线程数量

keepAliveTime:60,/空闲线程最大存活时间

TimeUnit.SECONDS,/时间单位

new ArrayBlockingQueue<>( capacity: 3)，

Executors.defaultThreadFactory(),

new ThreadPoolExecutor. AbortPolicy()

）；

任务拒绝策略

ThreadPoolExecutor.AbortPolicy 默认策略：丢弃任务并抛出RejectedExecutionException异常

ThreadPoolExecutor. DiscardPolicy 丢弃任务，但是不抛出异常这是不推荐的做法

ThreadPoolExecutor.DiscardOldestPolicy 抛弃队列中等待最久的任务然后把当前任务加入队列中

ThreadPoolExecutor.CallerRunsPolicy 调用任务的run()方法绕过线程池直接执行

线程池多大合适呢

CPU密集型，最大并行数+1

I/O密集型，最大并行数*期望CPU利用率*（总时间（CPU计算时间+等待时间）/CPU计算机时间）里面的时间用thread dump记录获取

最大并行数，一般看电脑处理器时多少线程的，然后还是调用Runtime.getRuntime.availableProcessors获取

练习

抢红包

假设：100块，分成了3个包，现在有5个人去抢。

其中，红包是共享数据。

5个人是5条线程。

public class MyThread extends Thread{

    //共享数据
    //100块，分成了3个包
    static double money = 100;
    static int count = 3;

    //最小的中奖金额
    static final double MIN = 0.01;

    @Override
    public void run() {
        //同步代码块
        synchronized (MyThread.class){
            if(count == 0){
                //判断，共享数据是否到了末尾（已经到末尾）
                System.out.println(getName() + "没有抢到红包！");
            }else{
                //判断，共享数据是否到了末尾（没有到末尾）
                //定义一个变量，表示中奖的金额
                double prize = 0;
                if(count == 1){
                    //表示此时是最后一个红包
                    //就无需随机，剩余所有的钱都是中奖金额
                    prize = money;
                }else{
                    //表示第一次，第二次（随机）
                    Random r = new Random();
                    //100 元   3个包
                    //第一个红包：99.98
                    //100 - (3-1) * 0.01
                    double bounds = money - (count - 1) * MIN;
                    prize = r.nextDouble(bounds);
                    if(prize &lt; MIN){
                        prize = MIN;
                    }
                }
                //从money当中，去掉当前中奖的金额
                money = money - prize;
                //红包的个数-1
                count--;
                //本次红包的信息进行打印
                System.out.println(getName() + "抢到了" + prize + "元");
            }
        }
    }
}
public class Test {
    public static void main(String[] args) {

        //创建线程的对象
        MyThread t1 = new MyThread();
        MyThread t2 = new MyThread();
        MyThread t3 = new MyThread();
        MyThread t4 = new MyThread();
        MyThread t5 = new MyThread();

        //给线程设置名字
        t1.setName("a");
        t2.setName("b");
        t3.setName("c");
        t4.setName("d");
        t5.setName("e");

        //启动线程
        t1.start();
        t2.start();
        t3.start();
        t4.start();
        t5.start();
    }
}

volatile解决

当A线程修改了共享数据时，B线程没有及时获取到最新的值，如果还在使用原先的值，就会出现问题

1，堆内存是唯一的，每一个线程都有自己的线程栈。

2 ，每一个线程在使用堆里面变量的时候，都会先拷贝一份到变量的副本中。

3 ，在线程中，每一次使用是从变量的副本中获取的。

Volatile关键字 : 强制线程每次在使用的时候，都会看一下共享区域最新的值

synchronized解决

1 ，线程获得锁

2 ，清空变量副本

3 ，拷贝共享变量最新的值到变量副本中

4 ，执行代码

5 ，将修改后变量副本中的值赋值给共享数据

6 ，释放锁

原子性

所谓的原子性是指在一次操作或者多次操作中，要么所有的操作全部都得到了执行并且不会受到任何因素的干扰而中断，要么所有的操作都不执行，多个操作是一个不可以分割的整体。

volatile关键字不能保证原子性，要加锁

原子性_AtomicInteger

java从JDK1.5开始提供了java.util.concurrent.atomic包(简称Atomic包)，这个包中的原子操作类提供了一种用法简单，性能高效，线程安全地更新一个变量的方式。因为变量的类型有很多种，所以在Atomic包里一共提供了13个类，属于4种类型的原子更新方式，分别是原子更新基本类型、原子更新数组、原子更新引用和原子更新属性(字段)。

使用原子的方式更新基本类型：

AtomicBoolean：原子更新布尔类型

AtomicInteger：原子更新整型

AtomicLong：原子更新长整型

AtomicInteger原理 : 自旋锁 + CAS 算法

CAS算法：

有3个操作数（内存值V，旧的预期值A，要修改的值B）

当旧的预期值A == 内存值此时修改成功，将V改为B

当旧的预期值A！=内存值此时修改失败，不做任何操作

并重新获取现在的最新值（这个重新获取的动作就是自旋）

悲观锁和乐观锁

synchronized和CAS的区别 :