亲宝软件园·资讯

展开

关于多线程、线程池、线程安全问题

18236992212 人气:0

多线程

1、基础概念

1.1 多线程技术

  • 从软件或者硬件上实现同时执行多个任务
  • 具有多线程能拦的计算机因有硬件支持而能够在同一时间执行多个线程
  • 多线程编程常常也将其称之为并发编程

1.2 并发和并行

  • 并行
    • 在同一时刻，有多个指令在多个CPU上同时进行
  • 并发
    • 在同一时刻，有多个指令在单个CPU上交替进行

1.3 进程和线程

  • 进程：是正在运行的软件，且一个进程最少包括一个线程
    • 独立性：进程是一个可以独立运行的基本单位，也是操作系统调度的最小单元，同时也是系统分配资源和调度的独立单位
    • 动态性：进程的实质是程序的一次执行过程，进程是动态产生，动态消亡的
    • 并发性：任何进程都可以同其他进程一起并发执行
  • 线程：是进程中的单个顺序控制流，是一条执行路径
    • 单线程：一个进程如果只有一条执行路径，则称为单线程程序
    • 多线程：一个程序如果有多条执行路径，则称为多线程程序
  • 二者关系
    • 线程是进程中的单个顺序控制流，是依赖于进程的，而一个进程最少包括一个线程，进程可以存在很多任务，每一个任务就是一个线程，这些执行路径之间没有任何的关联关系

2、线程的实现

2.1 继承Thread类

  • Thread类
    • Thread类就是JDK给我们定义的一个线程类
  • 方法介绍
方法名说明
void run() 在线程开启后，此方法将被调用执行
void start() 使此线程开始执行，Java虚拟机会调用run方法()
  • 实现步骤
    • 定义一个类继承自Thread类，这里我们定义这个类为MyThread
    • 重写Thread类中的run方法（run方法中重写的就是要被线程所执行的代码）
    • 创建MyThread类的对象
    • 启动线程（调用start方法）
  • 注意：多线程的执行，具有随机性
  • 代码实现
public class MyThread extends Thread {
    @Override
    public void run() {
        for(int i=0; i<100; i++) {
            System.out.println(i);
        }
    }
}
public class MyThreadDemo {
    public static void main(String[] args) {
        MyThread my1 = new MyThread();
        MyThread my2 = new MyThread();

//        my1.run();
//        my2.run();

        //void start() 导致此线程开始执行; Java虚拟机调用此线程的run方法
        my1.start();
        my2.start();
    }
}
  • 两个问题
    • 为什么重写run方法
      • 因为run方法封装的就是要被线程执行的代码
    • run方法和start方法的区别
      • run()：封装线程执行的代码，直接调用，相当于普通方法的调用
      • start()：启动线程；然后由JVM调用此线程的run()方法
      • start方法只能调用一次，如果调用多次程序将报错

2.2 实现Runnable接口

  • Thread构造方法
方法名说明
Thread(Runnable target) 分配一个新的Thread对象
Thread(Runnable target, String name) 分配一个新的Thread对象
  • 实现步骤
    • 定义一个类实现Runnable接口，这里我们定义为MyRunnable
    • 在MyRunnable类中重写run()方法
    • 创建MyRunnable类的对象
    • 创建Thread类的对象，把MyRunnable类对象作为构造方法的参数
    • 启动线程
  • 代码实现
public class MyRunnable implements Runnable {
    @Override
    public void run() {
        for(int i=0; i<100; i++) {
            System.out.println(Thread.currentThread().getName()+":"+i);
        }
    }
}
public class MyRunnableDemo {
    public static void main(String[] args) {
        //创建MyRunnable类的对象
        MyRunnable my = new MyRunnable();

        //创建Thread类的对象，把MyRunnable对象作为构造方法的参数
        //Thread(Runnable target)
//        Thread t1 = new Thread(my);
//        Thread t2 = new Thread(my);
        //Thread(Runnable target, String name)
        Thread t1 = new Thread(my,"坦克");
        Thread t2 = new Thread(my,"飞机");

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

2.3 实现Callable类

  • 方法介绍
方法名说明
V call() 计算结果，如果无法计算结果，则抛出一个异常
FutureTask(Callable callable) 创建一个 FutureTask，一旦运行就执行给定的 Callable
V get() 如有必要，等待计算完成，然后获取其结果
  • 实现步骤
    • 定义一个类实现Callable接口，这里我们将这个类定义为MyCallable
    • 在MyCallable类中重写call（）方法
    • 创建MyCallable类的对象
    • 创建Future的实现类FutureTask对象，把MyCallable对象作为构造方法的参数
    • 创建Thread类的对象，把FutureTask对象作为构造方法的参数
    • 启动线程
    • 调用get方法，就可以获取线程结束之后的结果
  • 代码实现
public class MyCallable implements Callable<String> {
    @Override
    public String call() throws Exception {
        for (int i = 0; i < 100; i++) {
            System.out.println("跟女孩表白" + i);
        }
        //返回值就表示线程运行完毕之后的结果
        return "答应";
    }
}
public class Demo {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //线程开启之后需要执行里面的call方法
        MyCallable mc = new MyCallable();
        //Thread t1 = new Thread(mc);
        //可以获取线程执行完毕之后的结果.也可以作为参数传递给Thread对象
        FutureTask<String> ft = new FutureTask<>(mc);

        //创建线程对象
        Thread t1 = new Thread(ft);
        String s = ft.get();
        //开启线程
        t1.start();
        //String s = ft.get();
        System.out.println(s);
    }
}

2.4 三种实现方式的区别

  • 站在返回值的角度
    • 继承Thread类和实现Runnable接口的方式没有返回值，获取不到线程执行的结果
    • 实现Callable接口的方式有返回值，所以可以获取线程执行的结果
  • 站在继承方式的角度
    • 继承Thread类的方式，编程比较简单，可以直接使用Thread类的方法，但同时它的扩展性相对较弱
    • 实现Runnable或Callable接口，因为在Java中一个类可以实现多个接口，因此扩展性较高，但同时编程相对复杂，不能直接使用Thread类中的方法

3、Thread类的API

3.1 和线程名称相关

  • 方法介绍
方法名说明
void setName(String name) 设置线程名称
public final String getName( ) 获取线程名称
Thread currentThread() 返回对当前正在执行的线程对象的引用
  • 代码实现
public class MyThread extends Thread {
    public MyThread() {}
    public MyThread(String name) {
        super(name);
    }
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(getName()+":"+i);
        }
    }
}
public class MyThreadDemo {
    public static void main(String[] args) {
        MyThread my1 = new MyThread();
        MyThread my2 = new MyThread();

        //void setName(String name)：将此线程的名称更改为等于参数 name
        my1.setName("高铁");
        my2.setName("飞机");

        //Thread(String name)
        MyThread my1 = new MyThread("高铁");
        MyThread my2 = new MyThread("飞机");

        my1.start();
        my2.start();

        //static Thread currentThread() 返回对当前正在执行的线程对象的引用
        System.out.println(Thread.currentThread().getName());
    }
}

3.2 线程休眠

  • 相关方法
方法名说明
static native void sleep (long millis) 使当前正在执行的线程停留（暂停执行）指定的毫秒数
  • 代码实现
public class MyRunnable implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "---" + i);
        }
    }
}
public class Demo {
    public static void main(String[] args) throws InterruptedException {
        /*System.out.println("睡觉前");
        Thread.sleep(3000);
        System.out.println("睡醒了");*/

        MyRunnable mr = new MyRunnable();

        Thread t1 = new Thread(mr);
        Thread t2 = new Thread(mr);

        t1.start();
        t2.start();
    }
}

3.3 线程优先级

3.3.1 线程调度

  • 两种调度方式
    • 分时调度模型
      • 所有线程轮流使用CPU的使用权，平均分配每个线程占用CPU的时间片
    • 抢占式调度模型
      • 优先级高的线程优先使用CPU，如果优先级相同，那么随机选择一个，优先级高的线程获取的CPU时间片相对多一些
  • JAVA使用的是抢占式调度模型
  • 随机性
    • 假如计算机只有一个CPU ，那么某一时刻只能执行一条指令，线程只有得到CPU时间片，也就是使用权，才可以执行指令。所以说多线程程序的执行是随机性的，因为谁抢到CPU的使用权是不一定的

3.3.2 相关方法

方法名说明
final int getPriority() 返回此线程的优先级
final void setPriority(int newPriority) 更改此线程的优先级线程默认优先级是5；线程优先级的范围是：1-10
  • 代码实现
public class MyCallable implements Callable<String> {
    @Override
    public String call() throws Exception {
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName() + "---" + i);
        }
        return "线程执行完毕了";
    }
}
public class Demo {
    public static void main(String[] args) {
        //优先级: 1 - 10 默认值:5
        MyCallable mc = new MyCallable();

        FutureTask<String> ft = new FutureTask<>(mc);

        Thread t1 = new Thread(ft);
        t1.setName("飞机");
        t1.setPriority(10);
        //System.out.println(t1.getPriority());//5
        t1.start();

        MyCallable mc2 = new MyCallable();

        FutureTask<String> ft2 = new FutureTask<>(mc2);

        Thread t2 = new Thread(ft2);
        t2.setName("坦克");
        t2.setPriority(1);
        //System.out.println(t2.getPriority());//5
        t2.start();
    }
}

3.4 守护线程

  • Java语言中的线程可以分为普通线程和守护线程
  • 守护线程的作用
    • 为普通线程服务，如果普通线程结束，守护线程也会结束
    • JVM会检查线程的类型，如果当前的JVM进程中所有的线程都是守护线程，Jvm停止运行。
  • 相关方法
方法名说明
void setDaemon(boolean on) 将此线程标记为守护线程
  • 代码实现
public class MyThread1 extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(getName() + "---" + i);
        }
    }
}
public class MyThread2 extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(getName() + "---" + i);
        }
    }
}
public class Demo {
    public static void main(String[] args) {
        MyThread1 t1 = new MyThread1();
        MyThread2 t2 = new MyThread2();

        t1.setName("女神");
        t2.setName("备胎");

        //把第二个线程设置为守护线程
        //当普通线程执行完之后,那么守护线程也没有继续运行下去的必要了.
        t2.setDaemon(true);

        t1.start();
        t2.start();
    }
}

4、线程安全问题

4.1 数据安全问题

  • 安全问题出现的条件
    • 是多线程环境
    • 有共享数据
    • 有多条语句操作共享数据
  • 如何解决多线程安全问题
    • 基本思想
      • 让程序没有安全问题的环境
    • 如何实现
      • 把多条语句操作共享数据的代码锁起来，让任意时刻只能有一个线程执行即可
  • 锁在Java中存在两种
    • 内部锁
      • 就是通过synchronized进行实现
    • 显式锁
      • 是Jdk1.5之后提供的Lock对象进行实现
  • 内部锁的实现
    • 同步代码块
    • 同步方法
    • 静态同步方法
  • 显式锁
    • 创建Lock类的对象

4.2 同步代码块

  • 格式
    • synchronized(任意对象) { 多条语句操作共享数据的代码 }
  • synchronized(任意对象）
    • 就相当于给代码加锁，任意对象就能看成是一把锁
  • 同步的好处和弊端
    • 好处
      • 解决了多线程的数据安全问题
    • 弊端
      • 当线程很多时，因为每个线程都会判断同步上的锁，这会很耗费资源，降低程序运行效率
  • 代码实现
public class SellTicket implements Runnable {
    private int tickets = 100;
    private Object obj = new Object();

    @Override
    public void run() {
        while (true) {
            synchronized (obj) { // 对可能有安全问题的代码加锁,多个线程必须使用同一把锁
                //t1进来后，就会把这段代码给锁起来
                if (tickets > 0) {
                    try {
                        Thread.sleep(100);
                        //t1休息100毫秒
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    //窗口1正在出售第100张票
                    System.out.println(Thread.currentThread().getName() + "正在出售第" + tickets + "张票");
                    tickets--; //tickets = 99;
                }
            }
            //t1出来了，这段代码的锁就被释放了
        }
    }
}

public class SellTicketDemo {
    public static void main(String[] args) {
        SellTicket st = new SellTicket();

        Thread t1 = new Thread(st, "窗口1");
        Thread t2 = new Thread(st, "窗口2");
        Thread t3 = new Thread(st, "窗口3");

        t1.start();
        t2.start();
        t3.start();
    }
}
  • 注意
    • 多个线程一定要使用同一把锁

4.3 同步方法

  • 同步方法
    • 就是把synchronized关键字加到方法上
  • 格式
    • 修饰符 synchronized 返回值类型 方法名(方法参数) { 方法体；}
  • 同步方法的锁对象
    • 就是this
  • 同步静态方法
    • 修饰符 static synchronized 返回值类型 方法名(方法参数) { 方法体；}
  • 同步静态方法的锁对象
    • 就是类名.class
  • 代码实现
public class Demo {
      public static void main(String[] args) {
          MyRunnable mr = new MyRunnable();
          Thread t1 = new Thread(mr);
          Thread t2 = new Thread(mr);

          t1.setName("窗口一");
          t2.setName("窗口二");

          t1.start();
          t2.start(); 
      }  
}

class MyRunnable implements Runnable {
    private static int ticketCount = 100;

    @Override
    public void run() {
        while(true){
            if("窗口一".equals(Thread.currentThread().getName())){
                //同步方法
                boolean result = synchronizedMthod();
                if(result){
                    break;
                }
            }

            if("窗口二".equals(Thread.currentThread().getName())){
                //同步代码块
                synchronized (MyRunnable.class){
                    if(ticketCount == 0){
                       break;
                    }else{
                        try {
                            Thread.sleep(10);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        ticketCount--;
                        System.out.println(Thread.currentThread().getName() + "在卖票,还剩下" + ticketCount + "张票");
                    }
                }
            }

        }
    }

    private static synchronized boolean synchronizedMthod() {
        if(ticketCount == 0){
            return true;
        }else{
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            ticketCount--;
            System.out.println(Thread.currentThread().getName() + "在卖票,还剩下" + ticketCount + "张票");
            return false;
        }
    }
}

4.4 Lock锁

  • 虽然我们可以理解同步代码块和同步方法的锁对象问题，但是我们并没有直接看到在哪里加上了锁，在哪里释放了锁，为了更清晰的表达如何加锁和释放锁，JDK5以后提供了一个新的锁对象Lock
  • Lock是接口不能直接实例化，这里采用它的实现类ReentrantLock来实例化
  • 多个线程对象需要使用同一个ReentrantLock对象
  • ReentrantLock构造方法
方法名说明
ReentrantLock() 创建一个ReentrantLock的实例
  • 加锁解锁方法
方法名说明
void lock() 获得锁
void unlock() 释放锁
  • 代码实现
public class Ticket implements Runnable {
      //票的数量
      private int ticket = 100;
      private Object obj = new Object();
      private ReentrantLock lock = new ReentrantLock();

      @Override
      public void run() {
          while (true) {
              //synchronized (obj){//多个线程必须使用同一把锁.
              try {
                  lock.lock();
                  if (ticket <= 0) {
                      //卖完了
                      break;
                  } else {
                      Thread.sleep(100);
                      ticket--;
                      System.out.println(Thread.currentThread().getName() + "在卖票,还剩下" + ticket + "张票");
                  }
              } catch (InterruptedException e) {
                  e.printStackTrace();
              } finally {
                  lock.unlock();
              }
              // }
          }
      }
  }

  public class Demo {
      public static void main(String[] args) {
          Ticket ticket = new Ticket();

          Thread t1 = new Thread(ticket);
          Thread t2 = new Thread(ticket);
          Thread t3 = new Thread(ticket);

          t1.setName("窗口一");
          t2.setName("窗口二");
          t3.setName("窗口三");

          t1.start();
          t2.start();
          t3.start();
      }
  }

5、死锁

  • 概述
    • 线程死锁是指由于两个或多个线程互相持有对方所需要的资源，导致这些线程处于等待状态，无法前往执行
  • 什么情况下会产生死锁
    • 交叉式锁可能导致程序死锁
      • 线程A持有R1的锁等待获取R2锁，线程B持有R2的锁等待获取R1的锁。
    • 内存不足
      • 当并发请求系统可用内存时，如果此时系统内存不足，则可能会出现死锁的情况。举例：两个线程T1和T2，执行某个任务，其中T1已经获取到了10MB内存，T2获取到了20MB内存，如果每一个线程执行单元都需要30MB，但是剩余的可用内存刚好5MB，那么两个线程有可能都在等待彼此能够释放内存资源。
    • 死循环引起的死锁
      • 程序由于代码原因或者对某些异常处理不得当，进入了死循环。CPU的占有率居高不下，但是程序就是不工作。这种死锁一般称之为假死，是一种最为致命也是最难排查的死锁现象。
  • 交叉式锁代码实现
public class Demo {
    public static void main(String[] args) {
        Object objA = new Object();
        Object objB = new Object();

        new Thread(()->{
            while(true){
                synchronized (objA){
                    //线程一
                    synchronized (objB){
                        System.out.println("小康同学正在走路");
                    }
                }
            }
        }).start();

        new Thread(()->{
            while(true){
                synchronized (objB){
                    //线程二
                    synchronized (objA){
                        System.out.println("小薇同学正在走路");
                    }
                }
            }
        }).start();
    }
}

6、生产者消费者模式

6.1 概述

  • 生产者消费者模式是一个十分经典的多线程协作的模式
  • 所谓生产者消费者问题，实际上主要是包含了两类线程：
    • 一类是生产者线程用于生产数据
    • 一类是消费者线程用于消费数据
  • 为了解生产者和消费者的关系，通常会采用共享的数据区域，就像是一个仓库
  • 生产者生产数据之后直接放置在共享数据区中，并不需要关心消费者的行为
  • 消费者只需要从共享数据区中去获取数据，并不需要关心生产者的行为

6.2 Object类的等待和唤醒方法

方法名说明
void wait() 导致当前线程等待，直到另一个线程调用该对象的 notify()方法或 notifyAll()方法
void notify() 唤醒正在等待对象监视器的单个线程
void notifyAll() 唤醒正在等待对象监视器的所有线程

6.3 生产者和消费者案例

  • 案例需求
    • 桌子类(Desk)：定义表示包子数量的变量,定义锁对象变量,定义标记桌子上有无包子的变量
    • 生产者类(Cooker)：实现Runnable接口，重写run()方法，设置线程任务
      1. 判断是否有包子,决定当前线程是否执行
      2. 如果有包子,就进入等待状态,如果没有包子,继续执行,生产包子
      3. 生产包子之后,更新桌子上包子状态,唤醒消费者消费包子
    • 消费者类(Foodie)：实现Runnable接口，重写run()方法，设置线程任务
      1. 判断是否有包子,决定当前线程是否执行
      2. 如果没有包子,就进入等待状态,如果有包子,就消费包子
      3. 消费包子后,更新桌子上包子状态,唤醒生产者生产包子
    • 测试类(Demo)：里面有main方法，main方法中的代码步骤如下
      • 创建生产者线程和消费者线程对象
      • 分别开启两个线程
  • 代码实现
public class Desk {

    //定义一个标记
    //true 就表示桌子上有汉堡包的,此时允许吃货执行
    //false 就表示桌子上没有汉堡包的,此时允许厨师执行
    public static boolean flag = false;

    //汉堡包的总数量
    public static int count = 10;

    //锁对象
    public static final Object lock = new Object();
}

public class Cooker extends Thread {
//    生产者步骤：
//            1，判断桌子上是否有汉堡包
//    如果有就等待，如果没有才生产。
//            2，把汉堡包放在桌子上。
//            3，叫醒等待的消费者开吃。
    @Override
    public void run() {
        while(true){
            synchronized (Desk.lock){
                if(Desk.count == 0){
                    break;
                }else{
                    if(!Desk.flag){
                        //生产
                        System.out.println("厨师正在生产汉堡包");
                        Desk.flag = true;
                        Desk.lock.notifyAll();
                    }else{
                        try {
                            Desk.lock.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }
        }
    }
}

public class Foodie extends Thread {
    @Override
    public void run() {
//        1，判断桌子上是否有汉堡包。
//        2，如果没有就等待。
//        3，如果有就开吃
//        4，吃完之后，桌子上的汉堡包就没有了
//                叫醒等待的生产者继续生产
//        汉堡包的总数量减一

        //套路:
            //1. while(true)死循环
            //2. synchronized 锁,锁对象要唯一
            //3. 判断,共享数据是否结束. 结束
            //4. 判断,共享数据是否结束. 没有结束
        while(true){
            synchronized (Desk.lock){
                if(Desk.count == 0){
                    break;
                }else{
                    if(Desk.flag){
                        //有
                        System.out.println("吃货在吃汉堡包");
                        Desk.flag = false;
                        Desk.lock.notifyAll();
                        Desk.count--;
                    }else{
                        //没有就等待
                        //使用什么对象当做锁,那么就必须用这个对象去调用等待和唤醒的方法.
                        try {
                            Desk.lock.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }
        }
    }
}

public class Demo {
    public static void main(String[] args) {
        /*消费者步骤：
        1，判断桌子上是否有汉堡包。
        2，如果没有就等待。
        3，如果有就开吃
        4，吃完之后，桌子上的汉堡包就没有了
                叫醒等待的生产者继续生产
        汉堡包的总数量减一*/

        /*生产者步骤：
        1，判断桌子上是否有汉堡包
        如果有就等待，如果没有才生产。
        2，把汉堡包放在桌子上。
        3，叫醒等待的消费者开吃。*/
        Foodie f = new Foodie();
        Cooker c = new Cooker();
        f.start();
        c.start();

    }
}

6.4 案例优化

  • 需求
    • 将Desk类中的变量,采用面向对象的方式封装起来
    • 生产者和消费者类中构造方法接收Desk类对象,之后在run方法中进行使用
    • 创建生产者和消费者线程对象,构造方法中传入Desk类对象
    • 开启两个线程
  • 代码实现
public class Desk {
    //定义一个标记
    //true 就表示桌子上有汉堡包的,此时允许吃货执行
    //false 就表示桌子上没有汉堡包的,此时允许厨师执行
    //public static boolean flag = false;
    private boolean flag;

    //汉堡包的总数量
    //public static int count = 10;
    //以后我们在使用这种必须有默认值的变量
   // private int count = 10;
    private int count;

    //锁对象
    //public static final Object lock = new Object();
    private final Object lock = new Object();

    public Desk() {
        this(false,10); // 在空参内部调用带参,对成员变量进行赋值,之后就可以直接使用成员变量了
    }

    public Desk(boolean flag, int count) {
        this.flag = flag;
        this.count = count;
    }

    public boolean isFlag() {
        return flag;
    }

    public void setFlag(boolean flag) {
        this.flag = flag;
    }

    public int getCount() {
        return count;
    }

    public void setCount(int count) {
        this.count = count;
    }

    public Object getLock() {
        return lock;
    }

    @Override
    public String toString() {
        return "Desk{" +
                "flag=" + flag +
                ", count=" + count +
                ", lock=" + lock +
                '}';
    }
}

public class Cooker extends Thread {

    private Desk desk;

    public Cooker(Desk desk) {
        this.desk = desk;
    }
//    生产者步骤：
//            1，判断桌子上是否有汉堡包
//    如果有就等待，如果没有才生产。
//            2，把汉堡包放在桌子上。
//            3，叫醒等待的消费者开吃。

    @Override
    public void run() {
        while(true){
            synchronized (desk.getLock()){
                if(desk.getCount() == 0){
                    break;
                }else{
                    //System.out.println("验证一下是否执行了");
                    if(!desk.isFlag()){
                        //生产
                        System.out.println("厨师正在生产汉堡包");
                        desk.setFlag(true);
                        desk.getLock().notifyAll();
                    }else{
                        try {
                            desk.getLock().wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }
        }
    }
}

public class Foodie extends Thread {
    private Desk desk;

    public Foodie(Desk desk) {
        this.desk = desk;
    }
    @Override
    public void run() {
//        1，判断桌子上是否有汉堡包。
//        2，如果没有就等待。
//        3，如果有就开吃
//        4，吃完之后，桌子上的汉堡包就没有了
//                叫醒等待的生产者继续生产
//        汉堡包的总数量减一

        //套路:
            //1. while(true)死循环
            //2. synchronized 锁,锁对象要唯一
            //3. 判断,共享数据是否结束. 结束
            //4. 判断,共享数据是否结束. 没有结束
        while(true){
            synchronized (desk.getLock()){
                if(desk.getCount() == 0){
                    break;
                }else{
                    //System.out.println("验证一下是否执行了");
                    if(desk.isFlag()){
                        //有
                        System.out.println("吃货在吃汉堡包");
                        desk.setFlag(false);
                        desk.getLock().notifyAll();
                        desk.setCount(desk.getCount() - 1);
                    }else{
                        //没有就等待
                        //使用什么对象当做锁,那么就必须用这个对象去调用等待和唤醒的方法.
                        try {
                            desk.getLock().wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }
        }
    }
}

public class Demo {
    public static void main(String[] args) {
        /*消费者步骤：
        1，判断桌子上是否有汉堡包。
        2，如果没有就等待。
        3，如果有就开吃
        4，吃完之后，桌子上的汉堡包就没有了
                叫醒等待的生产者继续生产
        汉堡包的总数量减一*/

        /*生产者步骤：
        1，判断桌子上是否有汉堡包
        如果有就等待，如果没有才生产。
        2，把汉堡包放在桌子上。
        3，叫醒等待的消费者开吃。*/
        Desk desk = new Desk();
        Foodie f = new Foodie(desk);
        Cooker c = new Cooker(desk);
        f.start();
        c.start();
    }
}

7、阻塞队列

  • 常见BlockingQueue
    • ArrayBlockingQueue: 底层是数组,有界
    • LinkedBlockingQueue: 底层是链表,无界.但不是真正的无界,最大为int的最大值
  • BlockingQueue的核心方法
方法名说明
put(anObject) 将参数放入队列,如果放不进去会阻塞
take() 取出第一个数据,取不到会阻塞
  • 代码实现
public class Demo02 {
    public static void main(String[] args) throws Exception {
        // 创建阻塞队列的对象,容量为 1
        ArrayBlockingQueue<String> arrayBlockingQueue = new ArrayBlockingQueue<>(1);
        // 存储元素
        arrayBlockingQueue.put("汉堡包");
        // 取元素
        System.out.println(arrayBlockingQueue.take());
        System.out.println(arrayBlockingQueue.take()); // 取不到会阻塞

        System.out.println("程序结束了");
    }
}
  • 使用阻塞队列实现等待唤醒机制
public class Cooker extends Thread {

    private ArrayBlockingQueue<String> bd;

    public Cooker(ArrayBlockingQueue<String> bd) {
        this.bd = bd;
    }
//    生产者步骤：
//            1，判断桌子上是否有汉堡包
//    如果有就等待，如果没有才生产。
//            2，把汉堡包放在桌子上。
//            3，叫醒等待的消费者开吃。

    @Override
    public void run() {
        while (true) {
            try {
                bd.put("汉堡包");
                System.out.println("厨师放入一个汉堡包");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

public class Foodie extends Thread {
    private ArrayBlockingQueue<String> bd;

    public Foodie(ArrayBlockingQueue<String> bd) {
        this.bd = bd;
    }

    @Override
    public void run() {
//        1，判断桌子上是否有汉堡包。
//        2，如果没有就等待。
//        3，如果有就开吃
//        4，吃完之后，桌子上的汉堡包就没有了
//                叫醒等待的生产者继续生产
//        汉堡包的总数量减一

        //套路:
        //1. while(true)死循环
        //2. synchronized 锁,锁对象要唯一
        //3. 判断,共享数据是否结束. 结束
        //4. 判断,共享数据是否结束. 没有结束
        while (true) {
            try {
                String take = bd.take();
                System.out.println("吃货将" + take + "拿出来吃了");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

    }
}

public class Demo {
    public static void main(String[] args) {
        ArrayBlockingQueue<String> bd = new ArrayBlockingQueue<>(1);

        Foodie f = new Foodie(bd);
        Cooker c = new Cooker(bd);

        f.start();
        c.start();
    }
}

8、线程池

8.1 线程状态介绍

  • 当线程被创建并启动以后，它既不是一启动就进入了执行状态，也不是一直处于执行状态。线程对象在不同的时期有不同的状态。那么Java中的线程存在哪几种状态呢？Java中的线程状态被定义在了java.lang.Thread.State枚举类中，State枚举类的源码如下：
public class Thread {
    
    public enum State {
    
        /* 新建 */
        NEW , 

        /* 可运行状态 */
        RUNNABLE , 

        /* 阻塞状态 */
        BLOCKED , 

        /* 无限等待状态 */
        WAITING , 

        /* 计时等待 */
        TIMED_WAITING , 

        /* 终止 */
        TERMINATED;
	}
    // 获取当前线程的状态
    public State getState() {
        return jdk.internal.misc.VM.toThreadState(threadStatus);
    }
    
}
  • 通过源码我们可以看到Java中的线程存在6种状态，每种线程状态的含义如下
线程状态具体含义
NEW 一个尚未启动的线程的状态。也称之为初始状态、开始状态。线程刚被创建，但是并未启动。还没调用start方法。MyThread t = new MyThread()只有线程象，没有线程特征。
RUNNABLE 当我们调用线程对象的start方法，那么此时线程对象进入了RUNNABLE状态。那么此时才是真正的在JVM进程中创建了一个线程，线程一经启动并不是立即得到执行，线程的运行与否要听令与CPU的调度，那么我们把这个中间状态称之为可执行状态(RUNNABLE)也就是说它具备执行的资格，但是并没有真正的执行起来而是在等待CPU的度。
BLOCKED 当一个线程试图获取一个对象锁，而该对象锁被其他的线程持有，则该线程进入Blocked状态；当该线程持有锁时，该线程将变成Runnable状态。
WAITING 一个正在等待的线程的状态。也称之为等待状态。造成线程等待的原因有两种，分别是调用Object.wait()、join()方法。处于等待状态的线程，正在等待其他线程去执行一个特定的操作。例如：因为wait()而等待的线程正在等待另一个线程去调用notify()或notifyAll()；一个因为join()而等待的线程正在等待另一个线程结束。
TIMED_WAITING 一个在限定时间内等待的线程的状态。也称之为限时等待状态。造成线程限时等待状态的原因有三种，分别是：Thread.sleep(long)，Object.wait(long)、join(long)。
TERMINATED 一个完全运行完成的线程的状态。也称之为终止状态、结束状态
  • 各个状态的转换，如下图所示

8.2 线程池-基本原理

  • 概述
    • 提到池，大家应该能想到的就是水池。水池就是一个容器，在该容器中存储了很多的水。那么什么是线程池呢？线程池也是可以看做成一个池子，在该池子中存储很多个线程。
  • 线程池存在的意义
    • 系统创建一个线程的成本是比较高的，因为它涉及到与操作系统交互，当程序中需要创建大量生存期很短暂的线程时，频繁的创建和销毁线程对系统的资源消耗有可能大于业务处理时对系统资源的消耗，这样就有点"舍本逐末"了。针对这一种情况，为了提高性能，我们就可以采用线程池。线程池在启动的时候，会创建大量空闲线程，当我们向线程池提交任务的时，线程池就会启动一个线程来执行该任务。等待任务执行完毕以后，线程并不会死亡，而是再次返回到线程池中称为空闲状态。等待下一次任务的执行。

8.3 线程池的设计思路

  1. 准备一个任务容器
  2. 一次性启动多个(2个及以上)消费者线程
  3. 刚开始任务容器是空的，所以线程都在wait
  4. 直到一个外部线程向这个任务容器中扔了一个"任务"，就会有一个消费者线程被唤醒
  5. 这个消费者线程取出"任务"，并且执行这个任务，执行完毕后，继续等待下一次任务的到来

8.4 Executors默认线程池

8.4.1 概述

  • JDK对线程池也进行了相关的实现，在真正企业开发中很少去自定义线程池，而是使用JDK自带的线程池

8.4.2 使用Executors提供的静态方法创建线程池

方法说明
static ExecutorService newCachedThreadPool() 创建一个默认的线程池
static newFixedThreadPool(int nThreads) 创建一个指定最多线程数量的线程池
  • 代码实现
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class MyThreadPoolDemo {
    public static void main(String[] args) throws InterruptedException {

        //1,创建一个默认的线程池对象.池子中默认是空的.默认最多可以容纳int类型的最大值.
        ExecutorService executorService = Executors.newCachedThreadPool();
        //Executors --- 可以帮助我们创建线程池对象
        //ExecutorService --- 可以帮助我们控制线程池

        executorService.submit(()->{
            System.out.println(Thread.currentThread().getName() + "在执行了");
        });

        //Thread.sleep(2000);

        executorService.submit(()->{
            System.out.println(Thread.currentThread().getName() + "在执行了");
        });

        executorService.shutdown();
    }
}

8.4.3 使用Executors提供的静态方法创建指定数量的线程池

方法说明
static ExecutorService newFixedThreadPool(int nThreads) 创建一个指定最多线程数量的线程池
  • 代码实现
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadPoolExecutor;

public class MyThreadPoolDemo2 {
    public static void main(String[] args) {
        //参数不是初始值而是最大值
        ExecutorService executorService = Executors.newFixedThreadPool(10);

        ThreadPoolExecutor pool = (ThreadPoolExecutor) executorService;
        System.out.println(pool.getPoolSize());//0

        executorService.submit(()->{
            System.out.println(Thread.currentThread().getName() + "在执行了");
        });

        executorService.submit(()->{
            System.out.println(Thread.currentThread().getName() + "在执行了");
        });

        System.out.println(pool.getPoolSize());//2
//        executorService.shutdown();
    }
}

8.5 ThreadPoolExecutor创建线程池对象

8.5.1 构造方法参数

  • 构造方法
public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue<Runnable> workQueue,
                          ThreadFactory threadFactory,
                          RejectedExecutionHandler handler)
  • 创建线程池
    • ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(核心线程数量,最大线程数量,空闲线程最大存活时间,时间单位，任务队列,创建线程工厂,任务的拒绝策略)
    • 这里将参数用中文表达，方便理解
  • 参数详解
参数含义要求
参数1 核心线程数量 不能小于0
参数2 最大线程数量 不能小于等于0，最大数量>=核心线程数量
参数3 空闲线程最大存活时间 不能小于0
参数4 时间单位 时间单位
参数5 任务队列 不能为null
参数6 创建线程工厂 不能为null
参数7 任务的拒绝策略 不能为null
  • 代码实现
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class MyThreadPoolDemo3 {
//    参数一：核心线程数量
//    参数二：最大线程数
//    参数三：空闲线程最大存活时间
//    参数四：时间单位
//    参数五：任务队列
//    参数六：创建线程工厂
//    参数七：任务的拒绝策略
    public static void main(String[] args) {
        ThreadPoolExecutor pool = new ThreadPoolExecutor(2,5,2,TimeUnit.SECONDS,new ArrayBlockingQueue<>(10), Executors.defaultThreadFactory(),new ThreadPoolExecutor.AbortPolicy());
        pool.submit(new MyRunnable());
        pool.submit(new MyRunnable());

        pool.shutdown();
    }
}

8.5.2 线程池的原理

  • 当我们通过submit方法向线程池中提交任务的时候，具体的工作流程如下
    1. 客户端每次提交一个任务，线程池就会在核心线程池中创建一个工作线程来执行这个任务，当核心线程池中的线程已满时，进入下一步操作
    2. 把任务试图存储到工作队列中，如果工作队列没有满，则将新提交的任务存储在这个任务队列里，等待核心线程中的空闲线程来执行，如果工作队列满了，则进入下一个流程
    3. 线程池会再次在非核心线程池区域来创建新的工作线程来执行任务，直到当前线程池总线程数量超过最大线程数量时，则会按照指定的任务处理策略处理多余的任务

8.5.3 任务拒绝策略

  • RejectedExecutionHandler是jdk提供的一个任务拒绝策略接口，它下面存在4个子类。
类名作用
ThreadPoolExecutor.AbortPolicy 丢弃任务并抛出RejectedExecutionException异常。是默认的策略
ThreadPoolExecutor.DiscardPolicy 丢弃任务，但是不抛出异常 这是不推荐的做法
ThreadPoolExecutor.DiscardOldestPolicy 抛弃队列中等待最久的任务 然后把当前任务加入队列中
ThreadPoolExecutor.CallerRunsPolicy 调用任务的run()方法绕过线程池直接执行
  • 常用的任务拒绝策略就是第一种
  • 注：明确线程池最多可执行的任务数=队列容量+最大线程数
  1. 演示ThreadPoolExecutor.AbortPolicy任务处理策略
public class ThreadPoolExecutorDemo01 {

    public static void main(String[] args) {

        /**
         * 核心线程数量为1 ， 最大线程池数量为3, 任务容器的容量为1 ,空闲线程的最大存在时间为20s
         */
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(1 , 3 , 20 , TimeUnit.SECONDS ,
                new ArrayBlockingQueue<>(1) , Executors.defaultThreadFactory() , new ThreadPoolExecutor.AbortPolicy()) ;

        // 提交5个任务，而该线程池最多可以处理4个任务，当我们使用AbortPolicy这个任务处理策略的时候，就会抛出异常
        for(int x = 0 ; x < 5 ; x++) {
            threadPoolExecutor.submit(() -> {
                System.out.println(Thread.currentThread().getName() + "---->> 执行了任务");
            });
        }
    }
}
  • 控制台输出结果
pool-1-thread-1---->> 执行了任务
pool-1-thread-3---->> 执行了任务
pool-1-thread-2---->> 执行了任务
pool-1-thread-3---->> 执行了任务
  • 控制台报错，仅仅执行了4个任务，有一个任务被丢弃了
  1. 演示ThreadPoolExecutor.DiscardPolicy任务处理策略
public class ThreadPoolExecutorDemo02 {
    public static void main(String[] args) {
        /**
         * 核心线程数量为1 ， 最大线程池数量为3, 任务容器的容量为1 ,空闲线程的最大存在时间为20s
         */
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(1 , 3 , 20 , TimeUnit.SECONDS ,
                new ArrayBlockingQueue<>(1) , Executors.defaultThreadFactory() , new ThreadPoolExecutor.DiscardPolicy()) ;

        // 提交5个任务，而该线程池最多可以处理4个任务，当我们使用DiscardPolicy这个任务处理策略的时候，控制台不会报错
        for(int x = 0 ; x < 5 ; x++) {
            threadPoolExecutor.submit(() -> {
                System.out.println(Thread.currentThread().getName() + "---->> 执行了任务");
            });
        }
    }
}
  • 控制台输出结果
pool-1-thread-1---->> 执行了任务
pool-1-thread-1---->> 执行了任务
pool-1-thread-3---->> 执行了任务
pool-1-thread-2---->> 执行了任务
  • 控制台没有报错，仅仅执行了4个任务，有一个任务被丢弃了
  1. 演示ThreadPoolExecutor.DiscardOldestPolicy任务处理策略
public class ThreadPoolExecutorDemo02 {
    public static void main(String[] args) {
        /**
         * 核心线程数量为1 ， 最大线程池数量为3, 任务容器的容量为1 ,空闲线程的最大存在时间为20s
         */
        ThreadPoolExecutor threadPoolExecutor;
        threadPoolExecutor = new ThreadPoolExecutor(1 , 3 , 20 , TimeUnit.SECONDS ,
                new ArrayBlockingQueue<>(1) , Executors.defaultThreadFactory() , new ThreadPoolExecutor.DiscardOldestPolicy());
        // 提交5个任务
        for(int x = 0 ; x < 5 ; x++) {
            // 定义一个变量，来指定指定当前执行的任务;这个变量需要被final修饰
            final int y = x ;
            threadPoolExecutor.submit(() -> {
                System.out.println(Thread.currentThread().getName() + "---->> 执行了任务" + y);
            });     
        }
    }
}
  • 控制台输出结果
pool-1-thread-2---->> 执行了任务2
pool-1-thread-1---->> 执行了任务0
pool-1-thread-3---->> 执行了任务3
pool-1-thread-1---->> 执行了任务4
  • 由于任务1在线程池中等待时间最长，因此任务1被丢弃
  1. 演示ThreadPoolExecutor.CallerRunsPolicy任务处理策略
public class ThreadPoolExecutorDemo04 {
    public static void main(String[] args) {

        /**
         * 核心线程数量为1 ， 最大线程池数量为3, 任务容器的容量为1 ,空闲线程的最大存在时间为20s
         */
        ThreadPoolExecutor threadPoolExecutor;
        threadPoolExecutor = new ThreadPoolExecutor(1 , 3 , 20 , TimeUnit.SECONDS ,
                new ArrayBlockingQueue<>(1) , Executors.defaultThreadFactory() , new ThreadPoolExecutor.CallerRunsPolicy());

        // 提交5个任务
        for(int x = 0 ; x < 5 ; x++) {
            threadPoolExecutor.submit(() -> {
                System.out.println(Thread.currentThread().getName() + "---->> 执行了任务");
            });
        }
    }
}
  • 控制台输出结果
pool-1-thread-1---->> 执行了任务
pool-1-thread-3---->> 执行了任务
pool-1-thread-2---->> 执行了任务
pool-1-thread-1---->> 执行了任务
main---->> 执行了任务
  • 通过控制台的输出，我们可以看到次策略没有通过线程池中的线程执行任务，而是直接调用任务的run()方法绕过线程池直接执行。

9、原子性

9.1 volatile关键字

9.1.1 多线程的小问题

  • 某一个线程对共享数据做了修改，但是其他的线程感知不到，也就是说一个线程对共享数据做了修改对其他线程是不可见的

9.1.2 JMM内存模型

  • JMM(Java Memory Model)Java内存模型,是java虚拟机规范中所定义的一种内存模型。
  • JMM内存模型描述了Java程序中各种变量（线程共享变量）的访问规则，以及在JVM中将变量存储到内存以及从内存中读取变量这样的底层细节
  • 特点
    1. 所有的共享变量都存储于主内存（计算机的RAM），这里所说的变量指的是实例变量和类变量，不包含局部变量，因为局部变量是线程私有的，因此不存在竞争问题
    2. 每一个线程还存在自己的工作内存，线程的工作内存，保留了被线程使用的变量的工作副本
    3. 线程对变量的所有操作（读和写）都必须在工作内存中完成，而不能直接操作主内存中的变量，不同线程之间也不能直接访问对方工作内存中的变量，线程之间变量的值的传递需要通过主内存来完成

9.1.3 解决方案

9.1.3.1 使用volatile关键字解决
  • 把共享变量通过volatile关键字进行修饰
public class Money {
    public static volatile int money = 100000;
}
  • 被volatile修饰的变量，线程在对其进行操作的时候，首先会将当前工作内存中的变量副本失效，然后从主内存中重新获取最新的数据，进行操作
  • volatile关键字可以解决多个线程直接对变量进行改变的时候的可见性
9.1.3.2 通过synchronized进行解决
  • 工作原理
    1. 线程获得锁
    2. 清空工作内存
    3. 从主内存拷贝共享数据最新的值到工作内存成为副本
    4. 执行代码
    5. 将修改后的副本的值刷新回主内存中
    6. 线程释放锁
9.1.3.3 两种方案的区别
  • volatile只能修饰实例变量和类变量，而synchronized可以修饰方法以及代码块
  • volatile保证数据的可见性，但是不保证原子性(多线程进行写操作，不保证线程安全);而synchronized是一种排他（互斥）的机制(因此有时我们也将synchronized这种锁称之为排它/互斥锁)，synchronized修饰的代码块，被修饰的代码块称之为同步代码块，无法被中断可以保证原子性，也可以间接的保证可见性

9.2 原子性（AtomicInteger）

9.2.1 原子性测试

  • 原子性是指在一次操作或者多次操作中，要么所有的操作全部都得到了执行并且不会受到任何因素的干扰而中断，要么所有的操作都不执行，多个操作是一个不可分割的整体
  • 例：从张三的账户给李四的账户转1000元，这个动作将包含两个基本的操作：从张三的账户扣除1000元，给李四的账户增加1000元。这两个操作必须符合原子性的要求，要么都成功要么都失败。
  • ++运算符分析
    • count++操作包含3个步骤
    • 从主内存中读取数据到工作内存
    • 对工作内存中的数据进行++操作
    • 将工作内存中的数据写回到主内存
    • 这3步中的任何一步都有可能会被其他线程中断，当中断以后，就会出现数据错误问题

9.2.2 测试volatile不保证原子性

  • 代码演示
public class MyAtomThread implements Runnable {

    private volatile int count = 0; //送冰淇淋的数量

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            //1,从共享数据中读取数据到本线程栈中.
            //2,修改本线程栈中变量副本的值
            //3,会把本线程栈中变量副本的值赋值给共享数据.
            count++;
            System.out.println("已经送了" + count + "个冰淇淋");
        }
    }
}
  • 控制台输出结果出现错误，volatile关键字修饰的变量没有原子性

9.2.3 原子性的解决方案

9.2.3.1 加锁
  • 代码演示
public class MyAtomThread implements Runnable {
    private volatile int count = 0; //送冰淇淋的数量
    private Object lock = new Object();
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            //1,从共享数据中读取数据到本线程栈中.
            //2,修改本线程栈中变量副本的值
            //3,会把本线程栈中变量副本的值赋值给共享数据.
            synchronized (lock) {
                count++;
                System.out.println("已经送了" + count + "个冰淇淋");
            }
        }
    }
}
9.2.3.2 使用JDK提供的原子类
  • java从JDK1.5开始提供了java.util.concurrent.atomic包(简称Atomic包)，这个包中的原子操作类提供了一种用法简单，性能高效，线程安全地更新一个变量的方式。因为变量的类型有很多种，所以在Atomic包里一共提供了13个类，属于4种类型的原子更新方式，分别是原子更新基本类型、原子更新数组、原子更新引用和原子更新属性(字段)。这里我们只讲解使用原子的方式更新基本类型，使用原子的方式更新基本类型Atomic包提供了以下3个类：
类名介绍
AtomicBoolean 原子更新布尔类型
AtomicInterger 原子更新整型
AtomicLong 原子更新长整型
  • 以上3个类提供的方法几乎一模一样，这里仅以AtomicInteger为例进行讲解，AtomicInteger的常用方法如下
  • 构造方法
方法说明
public AtomicInterger() 初始化一个默认值为0的原子型Interger
public AtomicInterger(int initialValue) 初始化一个指定值的原子型Interger
  • 成员方法
方法说明
int get() 获取值
int getAndIncrement() 以原子方式将当前值加一，这里返回的是自增前的值
int incrementAndGet() 以原子方式将当前值加一，这里返回的是自增后的值
int addAndGet(int data) 以原子方式将输入的数值与实例中的值相加并返回结果
int getAndSet(int value) 以原子方式设置为newValue的值，并返回旧值
  • 代码演示
public class MyAtomThread implements Runnable {

    AtomicInteger ac = new AtomicInteger(0);
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            int count = ac.incrementAndGet();
            System.out.println("已经送了" + count + "个冰淇淋");
        }
    }
}

9.3 CAS算法+自旋锁

9.3.1 概述

  • CAS的全称是： Compare And Swap(比较再交换)
  • 是现代CPU广泛支持的一种对内存中的共享数据进行操作的一种特殊指令
  • CAS可以将read-modify-write转换为原子操作，这个原子操作直接由CPU保证
  • CAS有3个操作数：内存值V，旧的预期值A，要修改的新值B。当且仅当旧预期值A和内存值V相同时，将内存值V修改为B并返回true，否则什么都不做，并返回false。
  • 举例说明
    1. 在内存值V当中，存储着为10的变量
    2. 此时线程1想把变量的值增加1，对线程1来说，旧的预期值A = 10 ，要修改的新值B = 11
    3. 在线程1要提交更新之前，另一个线程2抢先一步把内存值V中的变量率先更新成了11
    4. 线程1提交更新，首先进行A和内存值V的实际值比较（Compare），发现A不等于V的值，提交失败
    5. 线程1会重新获取内存值V作为当前A的值，并重新计算想修改的值，对此时的线程1来说，A= 11，B= 12，这个重新尝试的过程被称为内旋
    6. 如果没有其他线程改变V的值，线程1进行Compare，发现A和V的值是相等的
    7. 线程1进行SWAP，把内存V的值替换为B，也就是12

9.3.2 源码解析

public final int getAndAddInt(Object o, long offset, int delta) {
    int v;
    do {
        v = getIntVolatile(o, offset);
    } while (!weakCompareAndSetInt(o, offset, v, v + delta));
    return v;
}
  • 自旋的实现是通过do …while循环进行实现的
  • CAS算法的实现是通过Unsafe这个类中的方法进行实现的
public final native boolean compareAndSetInt(Object o, long offset, int expected, int x);

9.3.3 悲观锁和乐观锁

  • synchronized是从悲观的角度出发
    • 总是假设最坏的情况，每次去拿数据的时候都认为别人会修改，所以每次在拿数据的时候都会上锁，这样别人想拿这个数据就会阻塞直到它拿到锁（共享资源每次只给一个线程使用，其它线程阻塞，用完后再把资源转让给其它线程）。因此synchronized我们也将其称之为悲观锁。jdk中的ReentrantLock也是一种悲观锁。
  • CAS是从乐观的角度出发
    • 总是假设最好的情况，每次去拿数据的时候都认为别人不会修改，所以不会上锁，但是在更新的时候会判断一下在此期间别人有没有去更新这个数据。CAS这种机制我们也可以将其称之为乐观锁。

10、并发工具类

10.1 ConcurrentHashMap

10.1.1 使用

  • ConcurrentHashMap是一个线程安全的Map集合
  • 之前所学习的HashMap是线程不安全的，如果存在多个线程操作同一个HashMap的时候就会出现线程安全问题。在Jdk1.5之前如果我们要通过多个线程操作Map集合，保证数据的安全性，我们常常使用的就是Hashtable。Hashtable是线程安全的。但是Hashtable保证线程安全性的效率比较低，因此在Jdk1.5之后java就提供了ConcurrentHashMap供我们进行使用
  • Hashtable效率低下的原因：Hashtable使用的就是同步方法的方式来保证数据的安全性，并且每一个方法都会加锁。也就是说只要有一个线程对Hashtable进行操作，其他线程必须等待
  • ConcurrentHashMap的继承体系结构
  • ConcurrentHashMap继承自Map，所以是一个双列集合
  • 构造方法
public ConcurrentHashMap() {}
  • 代码演示
public class MyConcurrentHashMapDemo {
    
    public static void main(String[] args) throws InterruptedException {
        
        ConcurrentHashMap<String, String> hm = new ConcurrentHashMap<>();

        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 25; i++) {
                hm.put(i + "", i + "");
            }
        });

        Thread t2 = new Thread(() -> {
            for (int i = 25; i < 51; i++) {
                hm.put(i + "", i + "");
            }
        });

        t1.start();
        t2.start();

        System.out.println("----------------------------");
        //为了t1和t2能把数据全部添加完毕
        Thread.sleep(1000);
        //0-0 1-1 ..... 50- 50
        for (int i = 0; i < 51; i++) {
            System.out.println(hm.get(i + ""));
        }//0 1 2 3 .... 50


    }
}

10.1.2 JDK1.7版本原理

  • ConcurrentHashMap 保证线程安全性并且效率还比较高的原理就在于分段锁
  • 添加元素的过程

10.1.3 JDK1.8版本原理

  • 保证数据安全性的原理
    • CAS算法+局部锁定
  • 添加元素过程

10.2 CountDownLatch

  • 作用
    • 当某一个线程等待其他线程执行完毕之后再进行执行
  • 相关方法
方法说明
public CountDownLatch(int count) 初始化一个指定计数器的CountDownLatch对象
public void await() throws InterruptedException 让当前线程等待
public void countDown() 计数器进行减一
  • 原理
    • CountDownLatch的构造方法参数表示的就是等待的线程数量。内部维护了一个计数器，这个计数器的初始化值就是参数值

10.3 Semaphore

  • Semaphore(信号量)：控制某一段代码同时执行的线程数量
  • 构造方法
方法说明
public Semaphore(int permits) permits表示许可线程的数量
  • 成员方法
方法说明
public void acquire() throws InterruptedException 表示获取许可
public void release() 表示释放许可
  • 使用场景
    • Semaphore可以用来限流
  • 代码演示
public class MyRunnable implements Runnable {
    //1.获得管理员对象，
    private Semaphore semaphore = new Semaphore(2);
    @Override
    public void run() {
        try {
            //2.获得通行证
            semaphore.acquire();

            //3.开始行驶
            System.out.println("获得了通行证开始行驶");
            Thread.sleep(2000);
            System.out.println("归还通行证");

            //4.归还通行证
            semaphore.release();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

public class MySemaphoreDemo {
    public static void main(String[] args) {
        MyRunnable mr = new MyRunnable();

        for (int i = 0; i < 100; i++) {
            new Thread(mr).start();
        }
    }
}

加载全部内容
相关教程
猜你喜欢
用户评论