多线程_进程和线程，并发与并行，线程优先级，守护线程，实现线程的四种方式，线程周期；线程同步，线程中的锁，Lock类，死锁，生产者和消费者案例

Java多线程

1 多线程

1.1进程和线程

• 进程：
  • 是内存中正在运行的程序（进程即运行的程序）
  • 是系统进行资源分配和调用的独立单位
  • 进程都有它自己的内存空间，具体分为代码区、数据区和堆栈区，进程之间的地址空间是隔离的，互不影响
• 线程：
  • 是进程中的单个顺序控制流，是一条执行路径，是一个执行单元
  • 每个线程拥有独立的运行栈和程序计数器（PC）
  • 单线程：一个进程如果只有一条执行路径，则称为单线程程序
  • 多线程：一个进程如果有多条执行路径，则称为多线程程序
• 进程与线程的关系
  • 本质区别：进程是操作系统资源分配的基本单位，而线程是**处理器任务调度和执行（CPU）**的基本单位。
  • 包含关系：一个进程至少有一个线程，线程是进程的一部分，所以线程也被称为轻权进程或者轻量级进程。
  • 资源开销：每个进程都有独立的地址空间，进程之间的切换会有较大的开销；线程可以看做轻量级的进程，同一个进程内的线程共享进程的地址空间，每个线程都有自己独立的运行栈和程序计数器，线程之间切换的开销小。
  • 影响关系：一个进程崩溃后，在保护模式下其他进程不会被影响，但是一个线程崩溃可能导致整个进程被操作系统杀掉，所以多进程要比多线程健壮。

我们可以用工厂来做比对：

1.2 并发与并行

• 并行是指两个或者多个事件在同一时刻发生（多个CPU同时执行多个任务）

  

• 并发是指两个或多个事件在同一时间间隔发生（一个CPU通过分发时间片，同时执行多个任务）

  

• 并发+并行效果

  

1.3 计算机中的核心数和线程数

可通过如下代码获取电脑的配置信息，核心数和线程数

public class SystemInfo {
    public static void main(String[] args) {
        // 获取操作系统MXBean
        OperatingSystemMXBean osBean = ManagementFactory.getOperatingSystemMXBean();

        // 获取处理器核心数
        int availableProcessors = osBean.getAvailableProcessors();
        System.out.println("CPU核心数：" + availableProcessors);

        // 获取线程数
        ThreadMXBean threadMXBean = ManagementFactory.getThreadMXBean();
        int threadCount = threadMXBean.getThreadCount();
        System.out.println("线程数：" + threadCount);
    }
}

输出数据：

• 单核心单线程：CPU在多个线程之间做高速的切换（具体如何切换需要依据相关的算法），这样轮流去执行多个线程 效率低

• 多核心多线程：可以同时执行多个线程，多个线程在多个任务之间做高速的切换，速度是单线程的多倍，换句话说，每个任务被执行到几率都被提高了多倍 效率高

1.4 线程调度

• 两种调度方式

  • 分时调度模型：所有线程轮流使用 CPU 的使用权，平均分配每个线程占用 CPU 的时间片
  • 抢占式调度模型：优先让优先级高的线程使用 CPU，如果线程的优先级相同，那么会随机选择一个，优先级高的线程获取的 CPU 时间片相对多一些

• Java使用的是抢占式调度模型

• 随机性

  假如计算机只有一个 CPU，那么 CPU 在某一个时刻只能执行一条指令，线程只有得到CPU时间片，也就是使用权，才可以执行指令。所以说多线程程序的执行是有随机性，因为谁抢到CPU的使用权是不一定的

1.5 线程优先级

方法名	说明
final int getPriority()	返回此线程的优先级
final void setPriority(int newPriority)	更改此线程的优先级线程默认优先级是5；线程优先级的范围是：1-10

JDK中的线程优先级：

注意：设置了优先级并不一定说先执行完哪个任务后执行完哪个任务，只能说优先级高的在抢占的过程中获取CPU的可能性大一些

可能的执行结果1：

可能的执行结果2：

1.6 守护线程

方法名	说明
void setDaemon(boolean on)	将此线程标记为守护线程，当运行的线程都是守护线程时，Java虚拟机将退出
在Java中，线程分为两种类型：用户线程（User Thread）和守护线程（Daemon Thread）

守护线程是为了支持用户线程的工作而存在的

守护线程具有以下特点：

• 在用户线程结束时自动结束： 当所有的用户线程执行完毕，不管守护线程是否执行完毕，Java虚拟机都会自动退出。
• 没有执行完的守护线程会被强制终止： 如果所有的用户线程都执行完毕，而守护线程还没有执行完毕，Java虚拟机会强制终止守护线程。因此，守护线程不应该执行一些需要确保执行完毕的任务，例如写文件操作。

1.7 Java中实现多线程的四种方式

1.7.1 继承Thread类

• 定义
  • 继承Thread类
  • 重写run()方法 → run()是用来封装被线程执行的代码
• 使用
  • 创建MyThread类的对象
  • 启动线程

启动线程两种方法：

方法名	说明
void run()	在线程开启后，此方法将被调用执行
void start()	使此线程开始执行，Java虚拟机会调用run方法()

• run()方法和start()方法的区别？

  • run()：封装线程执行的代码，直接调用，相当于普通方法的调用

  • start()：启动线程；然后由JVM调用此线程的run()方法

public class MyThread extends Thread {
    @Override
    public void run() {
        for(int i=0; i<100; i++) {
            System.out.print(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()方法来执行：

很显然，先执行了my1.run()，再执行了my2.run()

即，调用run为并发执行，调用start为并行执行。

1.7.2 实现Runnable接口

• 定义

  • 实现实现Runnable接口

  • 重写run()方法

• 使用

  • 创建MyRunnable类的对象

  • 创建Thread类的对象，把MyRunnable对象作为构造方法的参数

  • 启动线程（仍可以选择start或者run，由上面可知，选择start能实现并行）

Thread构造方法：

方法名	说明
Thread(Runnable target)	分配一个新的Thread对象
Thread(Runnable target, String name)	分配一个新的Thread对象，name为线程名称

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

• 相比继承Thread类，实现Runnable接口的好处
  • 避免了Java单继承的局限性
  • 适合多个相同程序的代码去处理同一个资源的情况，把线程和程序的代码、数据有效分离，较好的体现了面向对象的设计思想

1.7.3 实现Callable接口

泛型V通常为执行结果的返回值

作用管理多线程运行的结果

方法名	说明
V call()	计算结果，如果无法计算结果，则抛出一个异常
FutureTask(Callable callable)	创建一个 FutureTask，一旦运行就执行给定的 Callable
V get()	如有必要，等待计算完成，然后获取其结果

• 实现步骤
  • 定义一个类MyCallable实现Callable接口
  • 在MyCallable类中重写call()方法
  • 创建MyCallable类的对象 → MyCallable的对象表示多线程要执行的任务
  • 创建Future的实现类FutureTask对象，把MyCallable对象作为构造方法的参数 → FutureTask的对象作用管理多线程运行的结果
  • 创建Thread类的对象，把FutureTask对象作为构造方法的参数
  • 启动线程
  • 再调用get方法，就可以获取线程结束之后的结果

使用 FutureTask 的一个主要优势是，它可以在任务执行的同时允许你获取多线程的执行结果；

注意，必须要在线程执行之后才可以获取结果，即必须要调用完start()函数之后，才可以获取结果。

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 Demo2 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //线程开启之后需要执行里面的call方法
//        System.out.println("hhhhhhhhhhhh");
        MyCallable mc = new MyCallable();

        //Thread t1 = new Thread(mc);

        //可以获取线程执行完毕之后的结果.也可以作为参数传递给Thread对象
        FutureTask<String> ft = new FutureTask<>(mc);

        //创建线程对象
        Thread t1 = new Thread(ft);

        //开启线程
        t1.start();
        String s = ft.get();
        System.out.println("结果："+s);

    }
}

程序执行结果：

1.7.4 线程池

一个容纳多个线程的容器，其中的线程可以反复使用；

省去了频繁创建线程对象的操作，无需反复创建线程而消耗过多资源。

线程池原理：

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

我们可以使用Executors中所提供的静态方法来创建线程池

函数名称	作用
static ExecutorService newCachedThreadPool()	创建一个默认的线程池
static newFixedThreadPool(int nThreads)	创建一个指定最多线程数量的线程池

1.7.4.1 Executors默认线程池

Executors 可以帮助我们创建线程池对象

ExecutorService 可以帮助我们控制线程池

package com.itheima.mythreadpool;


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

如果保留代码：Thread.sleep(2000)

运行结果：

如果注释掉代码：Thread.sleep(2000)

运行的结果：

1.7.4.2 Executors创建指定上限的线程池

static ExecutorService newFixedThreadPool(int nThreads) 创建一个指定最多线程数量的线程池

getPoolSize() 获取线程池的当前线程数（当前池中的活动线程数）

package com.itheima.mythreadpool;

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

运行结果：

1.7.4.3 线程池ThreadPoolExecutor

ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor (核心线程数量, 最大线程数量, 空闲线程最大存活时间, 任务队列, 创建线程工厂, 任务的拒绝策略) 创建线程池对象；

threadPoolExecutor.submit(Callable) 传入一个自定义接口，提交到线程池里面。

package com.itheima.mythreadpool;

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

1.7.4.4 参数：任务的拒绝策略

RejectedExecutionHandler是jdk提供的一个任务拒绝策略接口，它下面存在4个子类。

拒绝策略接口	解释
ThreadPoolExecutor.AbortPolicy	丢弃任务并抛出RejectedExecutionException异常。是默认的策略
ThreadPoolExecutor.DiscardPolicy	丢弃任务，但是不抛出异常 这是不推荐的做法
ThreadPoolExecutor.DiscardOldestPolicy	抛弃队列中等待最久的任务 然后把当前任务加入队列中
ThreadPoolExecutor.CallerRunsPolicy	调用任务的run()方法绕过线程池直接执行

注：明确线程池最多可执行的任务数 = 队列容量 + 最大线程数（线程池通常包含一个任务队列，用于存放等待执行的任务）

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() + "---->> 执行了任务");
            });
        }
    }
}

控制台输出结果

控制台报错，仅仅执行了4个任务，有一个任务被丢弃了

1.8 线程周期

线程的生命周期：

其中的其他阻塞式方法包括：

• sleep(long time)：用于使当前线程暂时休眠（阻塞）指定的时间

• join()：用于等待调用该方法的线程执行完毕

• wait()：用于在某个对象上等待，同时释放对象的锁

• suspend()：用于暂停线程的执行。但是，suspend 方法已被废弃（deprecated），不推荐使用。因为在调用 suspend 方法时，线程会被挂起，并且可能导致死锁或其他问题。替代方案是使用 wait 和 notify 等机制进行线程间的协作

方法时间到，阻塞方式结束的方式包括：

• sleep() 时间到
• join() 结束
• notify()/notifyAll()
• resume()：恢复被 suspend() 挂起的线程。但 resume() 方法也已经被废弃（deprecated），不再推荐使用，因为它容易导致死锁等问题。在现代的 Java 编程中，不应该使用 suspend() 和 resume()

2 线程同步

进程之间的两种制约关系：同步与互斥

同步（直接制约）：多个进程若有执行顺序的之间的要求，则我们称之为两个进程有同步关系

互斥（间接制约）：若多个进程要求访问临界资源，而临界资源一次只能由一个进程访问，因此而产生的竞争关系称为互斥

2.1 线程导致的安全问题

线程执行的随机性会导致一些安全问题。

最经典的一个例子：电影院卖票。共有100张票，而它有3个窗口卖票，请设计一个程序模拟该电影院卖票

出现的问题：

• 相同的票出现了多次

  分析原因：

  while (true) {
      //tickets = 100;
      //t1,t2,t3
      //假设t1线程抢到CPU的执行权
      if (tickets > 0) {
          //通过sleep()方法来模拟出票时间
          try {
              Thread.sleep(100);
              //t1线程休息100毫秒
              //t2线程抢到了CPU的执行权，t2线程就开始执行，执行到这里的时候，t2线程休息100毫秒
              //t3线程抢到了CPU的执行权，t3线程就开始执行，执行到这里的时候，t3线程休息100毫秒
          } catch (InterruptedException e) {
              e.printStackTrace();
          }
          //假设线程按照顺序醒过来
          //t1抢到CPU的执行权，在控制台输出：窗口1正在出售第100张票
          System.out.println(Thread.currentThread().getName() + "正在出售第" + tickets + "张票");
          //t2抢到CPU的执行权，在控制台输出：窗口2正在出售第100张票
          //t3抢到CPU的执行权，在控制台输出：窗口3正在出售第100张票
          tickets--;
          //如果这三个线程还是按照顺序来，这里就执行了3次--的操作，最终票就变成了97
      }
  }
  

• 出现了负数的票

  分析原因：

  while (true) {
      //tickets = 1;
      //t1,t2,t3
      //假设t1线程抢到CPU的执行权
      if (tickets > 0) {
          //通过sleep()方法来模拟出票时间
          try {
              Thread.sleep(100);
              //t1线程休息100毫秒
              //t2线程抢到了CPU的执行权，t2线程就开始执行，执行到这里的时候，t2线程休息100毫秒
              //t3线程抢到了CPU的执行权，t3线程就开始执行，执行到这里的时候，t3线程休息100毫秒
          } catch (InterruptedException e) {
              e.printStackTrace();
          }
          //假设线程按照顺序醒过来
          //t1抢到了CPU的执行权，在控制台输出：窗口1正在出售第1张票
          //假设t1继续拥有CPU的执行权，就会执行tickets--;操作，tickets = 0;
          //t2抢到了CPU的执行权，在控制台输出：窗口1正在出售第0张票
          //假设t2继续拥有CPU的执行权，就会执行tickets--;操作，tickets = -1;
          //t3抢到了CPU的执行权，在控制台输出：窗口3正在出售第-1张票
          //假设t2继续拥有CPU的执行权，就会执行tickets--;操作，tickets = -2;
          System.out.println(Thread.currentThread().getName() + "正在出售第" + tickets + "张票");
          tickets--;
      }
  }
  

2.2 解决方法

• 安全问题出现的条件

  • 是多线程环境

  • 有共享数据

  • 有多条语句操作共享数据

• 如何解决多线程安全问题呢?

  • 基本思想：让程序没有安全问题的环境（破环三个条件中的一个）

• 怎么实现呢?

  • 把多条语句操作共享数据的代码给锁起来，让任意时刻只能有一个线程执行即可
  • Java提供了同步代码块的方式来解决
  • Java还提供了同步方法的方式来解决

2.2.1 同步代码块

• 同步代码块格式：

  synchronized(任意对象) { 
  	多条语句操作共享数据的代码 
  }
  

  synchronized(任意对象)：就相当于给代码加锁了，任意对象就可以看成是一把锁

• 同步的好处和弊端

  • 好处：解决了多线程的数据安全问题

  • 弊端：当线程很多时，因为每个线程都会去判断同步上的锁，这是很耗费资源的，无形中会降低程序的运行效率

public class SellTicket implements Runnable {
    private int tickets = 100;
    private Object obj = new Object();

    @Override
    public void run() {
        while (true) {
            //tickets = 100;
            //t1,t2,t3
            //假设t1抢到了CPU的执行权
            //假设t2抢到了CPU的执行权
            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出来了，这段代码的锁就被释放了
        }
    }
}

为什么要有这个obj？

这里的obj是一把锁。多个线程共用这一把锁，才能保证共享资源的安全

2.2.2 同步方法

同步方法会在方法级别进行同步，确保在同一时刻只有一个线程能够执行该方法

• 一般同步方法

  就是把synchronized关键字加到方法上

  修饰符 synchronized 返回值类型 方法名(方法参数) { 
  	方法体；
  }
  

  同步方法的锁对象是：this

  private synchronized void sellTicket() {
      if (tickets > 0) {
          try {
              Thread.sleep(100);
          } catch (InterruptedException e) {
              e.printStackTrace();
          }
          System.out.println(Thread.currentThread().getName() + "正在出售第" + tickets + "张票");
          tickets--;
      }
  }
  

• 静态同步方法：就是把synchronized关键字加到静态方法上

  修饰符 static synchronized 返回值类型 方法名(方法参数) { 
  	方法体；
  }
  

  同步静态方法的锁对象是：类名.class

  private static synchronized void sellTicket() {
      if (tickets > 0) {
          try {
              Thread.sleep(100);
          } catch (InterruptedException e) {
              e.printStackTrace();
          }
          System.out.println(Thread.currentThread().getName() + "正在出售第" + tickets + "张票");
          tickets--;
      }
  }
  

2.2.3 注意事项 重要

1 锁的指定

• 任意对象都可以作为同步锁

• 同步代码块中：自己指定，很多时候是this或类名.class

• 同步方法中：非静态方法用this，静态方法类名.class

2 锁的使用

• 必须保证使用同一个资源的多个线程共用一把锁，破坏这条规则将无法保证共享资源的安全

• 一个线程类中的所有静态方法共用同一把锁（类名.class），所有非静态方法共用同一把锁（this）

3 释放锁的操作

• 当前线程的同步方法、同步代码块执行结束
• 当前线程在同步代码块、同步方法中遇到break、return终止了该代码块、 该方法的继续执行
• 当前线程在同步代码块、同步方法中出现了未处理的Error或Exception，导致异常结束
• 当前线程在同步代码块、同步方法中执行了线程对象的wait()方法，当前线程暂停，并释放锁

4 不会释放锁的操作

• 线程执行同步代码块或同步方法时，程序调用``Thread.sleep()、 Thread.yield()`方法暂停当前线程的执行
• 线程执行同步代码块时，其他线程调用了该线程的suspend()方法将该线程 挂起，该线程不会释放锁（同步监视器）。
• 应尽量避免使用suspend()和resume()来控制线程

3 了解线程安全的类

• StringBuffer

  • 线程安全，可变的字符序列

  • 从版本JDK 5开始，被StringBuilder 替代。 通常应该使用StringBuilder类，因为它支持所有相同的操作，但它更快，因为它不执行同步

• Vector

  • 从Java 2平台v1.2开始，该类改进了List接口，使其成为Java Collections Framework的成员。 与新的集合实现不同， Vector被同步。 如果不需要线程安全的实现，建议使用ArrayList代替Vector

• Hashtable

  • 该类实现了一个哈希表，它将键映射到值。 任何非null对象都可以用作键或者值
  • 从Java 2平台v1.2开始，该类进行了改进，实现了Map接口，使其成为Java Collections Framework的成员。 与新的集合实现不同， Hashtable被同步。 如果不需要线程安全的实现，建议使用HashMap代替Hashtable

4 Lock锁

• lock锁锁什么？

  锁住了同步代码块的部分

• 为什么引入lock锁？

  虽然我们可以理解同步代码块和同步方法的锁对象问题，但是我们并没有直接看到在哪里加上了锁，在哪里释放了锁，为了更清晰的表达如何加锁和释放锁，JDK5以后提供了一个新的锁对象Lock

Lock是接口不能直接实例化，这里采用它的实现类ReentrantLock来实例化

• ReentrantLock构造方法

  方法名	说明
  ReentrantLock()	创建一个ReentrantLock的实例

• 加锁解锁方法

  方法名	说明
  void lock()	获得锁
  void unlock()	释放锁

public class SellTicket implements Runnable {
    private int tickets = 100;
    private Lock lock = new ReentrantLock();

    @Override
    public void run() {
        while (true) {
            try {
                lock.lock();
                if (tickets > 0) {
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + "正在出售第" + tickets + "张票");
                    tickets--;
                }
            } finally {
                lock.unlock();
            }
        }
    }
}
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();
    }
}

5 死锁（操作系统知识点）

5.1 定义

死锁是指两个或两个以上的进程在执行过程中，由于竞争资源或者由于彼此通信而造成的一种阻塞现象，若无外力作用，它们都将无法推进下去

5.2 产生的原因

5.2.1 两大原因

• 竞争不可剥夺资源（可剥夺资源不会产生死锁）
• 进程推进顺序不当

5.2.2 四个必要条件

• 互斥条件
• 请求和保持条件
• 不可剥夺条件
• 循环等待条件

5.3 处理死锁的基本方法

5.3.1 预防死锁

事先预防的方法。通过设置某些限制条件，去破坏产生死锁的四个必要条件中的一个或几个

• 破坏互斥条件

  就是在系统里取消互斥。若资源不被一个进程独占使用，那么死锁是肯定不会发生的。但一般来说，所列的四个条件中，“互斥”条件很难破坏，但是可以利用spooling技术破坏。

• 破坏请求和保持条件

  即在进程在其运行之前一次申请所需求的所有资源，在它的资源未满足前，不分配资源，不投入运行

• 破坏不可剥夺条件

  即破坏“不可抢占“条件，就是允许对资源实行抢夺

• 破坏循环等待条件

  破坏”循环等待“条件的一种方法，是将系统中的所有资源统一编号，进程可在任何时候提出资源申请，但所有的申请必须按照资源的编号顺序（升序）提出。这样做就能保证系统不出现死锁。

5.3.2 避免死锁

在资源动态分配的过程中，用某种方法防止系统进入不安全状态，从而避免发生死锁

其中，银行家算法是一种最有代表性的避免死锁的算法

6 经典案例

6.1 生产者和消费者问题

生产者消费者模式是一个十分经典的多线程协作的模式。

所谓生产者消费者问题，实际上主要是包含了两类线程：

• 一类是生产者线程用于生产数据

• 一类是消费者线程用于消费数据

为了解耦生产者和消费者的关系，通常会采用共享的数据区域，就像是一个仓库

• 生产者生产数据之后直接放置在共享数据区中，并不需要关心消费者的行为

• 消费者只需要从共享数据区中去获取数据，并不需要关心生产者的行为

• Object类的等待和唤醒方法

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

wait()、notify()、和notifyAll()是Java中用于实现线程间协作的方法，它们是Object类的成员方法，因此可以被任何Java对象调用。这些方法必须在同步块或同步方法中调用，因为它们依赖于对象的监视器（monitor）

synchronized (obj) {
    // some code
    obj.wait(); // 释放obj的锁，线程进入等待状态
    // some code after notify
}

synchronized (obj) {
    // some code
    obj.notify(); // 唤醒等待在obj上的一个线程
    // or obj.notifyAll(); 唤醒等待在obj上的所有线程
    // some code after notify
}

对象的监视器，即对象的内部锁。每个对象都有一个内部锁，但内部锁不是对象的属性，是Java中用于管理多线程访问共享资源的机制。当一个线程进入同步代码块或同步方法时，它会自动获取对象的内部锁，并在退出同步代码块或方法时释放这个锁。这种机制确保了同一时刻只有一个线程能够执行被锁保护的代码。

• 生产者消费者案例中包含的类：

  奶箱类(Box)：定义一个成员变量，表示第x瓶奶，提供存储牛奶和获取牛奶的操作

  生产者类(Producer)：实现Runnable接口，重写run()方法，调用存储牛奶的操作

  消费者类(Customer)：实现Runnable接口，重写run()方法，调用获取牛奶的操作

  测试类(BoxDemo)：里面有main方法，main方法中的代码步骤如下

  ①创建奶箱对象，这是共享数据区域

  ②创建消费者创建生产者对象，把奶箱对象作为构造方法参数传递，因为在这个类中要调用存储牛奶的操作

  ③对象，把奶箱对象作为构造方法参数传递，因为在这个类中要调用获取牛奶的操作

  ④创建2个线程对象，分别把生产者对象和消费者对象作为构造方法参数传递

  ⑤启动线程

• 代码实现

  public class Box {
      //定义一个成员变量，表示第x瓶奶
      private int milk;
      //定义一个成员变量，表示奶箱的状态
      private boolean state = false;
  
      //提供存储牛奶和获取牛奶的操作
      public synchronized void put(int milk) {
          //如果有牛奶，等待消费
          if(state) {
              try {
                  wait();
              } catch (InterruptedException e) {
                  e.printStackTrace();
              }
          }
  
          //如果没有牛奶，就生产牛奶
          this.milk = milk;
          System.out.println("送奶工将第" + this.milk + "瓶奶放入奶箱");
  
          //生产完毕之后，修改奶箱状态
          state = true;
  
          //唤醒其他等待的线程
          notifyAll();
      }
  
      public synchronized void get() {
          //如果没有牛奶，等待生产
          if(!state) {
              try {
                  wait();
              } catch (InterruptedException e) {
                  e.printStackTrace();
              }
          }
  
          //如果有牛奶，就消费牛奶
          System.out.println("用户拿到第" + this.milk + "瓶奶");
  
          //消费完毕之后，修改奶箱状态
          state = false;
  
          //唤醒其他等待的线程
          notifyAll();
      }
  }
  
  public class Producer implements Runnable {
      private Box b;
  
      public Producer(Box b) {
          this.b = b;
      }
  
      @Override
      public void run() {
          for(int i=1; i<=30; i++) {
              b.put(i);
          }
      }
  }
  
  public class Customer implements Runnable {
      private Box b;
  
      public Customer(Box b) {
          this.b = b;
      }
  
      @Override
      public void run() {
          while (true) {
              b.get();
          }
      }
  }
  
  public class BoxDemo {
      public static void main(String[] args) {
          //创建奶箱对象，这是共享数据区域
          Box b = new Box();
  
          //创建生产者对象，把奶箱对象作为构造方法参数传递，因为在这个类中要调用存储牛奶的操作
          Producer p = new Producer(b);
          //创建消费者对象，把奶箱对象作为构造方法参数传递，因为在这个类中要调用获取牛奶的操作
          Customer c = new Customer(b);
  
          //创建2个线程对象，分别把生产者对象和消费者对象作为构造方法参数传递
          Thread t1 = new Thread(p);
          Thread t2 = new Thread(c);
  
          //启动线程
          t1.start();
          t2.start();
      }
  }
  

• 运行结果：