补充：

并发：两个或多个事件在同一时间段发生—-交替执行—效率低

并行：两个或多个事件在同时发生—————同时执行—效率高

多线程语法

多线程是java中的一个并发的概念：

  • 在计算机的运行中，所有的进程都是同时运行的（CPU会同时调用，之后会随机的获取分配）

  • 1.在java程序中也是支持的
  • 2.当java执行main方法的时候，其实就是执行一个名字叫做main的线程—主线程
  • 可以在main线程执行的时候，开启多个其他的线程A,B,C等等
  • 多个线程A,B,C等等都是同时执行的，同时等待CPU的调用，相互抢夺CPU调用自己的时间片段
  • 3.Thread类是java中的专门处理线程的api，是java.lang包下的常用类，每一个Thread类的
  • 对象，就代表一个某种状态的线程

  • java.lang包下常用的类(不需要导包)：String，System，八大基本类型，Thread…

  • 进程：表示一个个的正在运行的程序
  • 线程：表示一个个正在运行的程序中的子进程（线程）
  • 包含关系：一个进程包含多个线程 ```java package com.xincheng;

/**

  • @author Lynn
  • @create 2020-12-14-14:46 */

import java.util.Date;

/**

  • 多线程是java中的一个并发的概念：
  • 在计算机的运行中，所有的进程都是同时运行的（CPU会同时调用，之后会随机的获取分配） *
  • 1.在java程序中也是支持的
  • 2.当java执行main方法的时候，其实就是执行一个名字叫做main的线程
  • 可以在main线程执行的时候，开启多个其他的线程A,B,C等等
  • 多个线程A,B,C等等都是同时执行的，同时等待CPU的调用，相互抢夺CPU调用自己的时间片段
  • 3.Thread类是java中的专门处理线程的api，是java.lang包下的常用类，每一个Thread类的
  • 对象，就代表一个某种状态的线程 *
  • java.lang包下常用的类(不需要导包)：String，System，八大基本类型，Thread… *
  • 进程：表示一个个的正在运行的程序
  • 线程：表示一个个正在运行的程序中的子进程（线程）

  • 包含关系：一个进程包含多个线程 */ public class ThreadDemo { //main是一个主线程 public static void main(String[] args) {

    1.  //是主线程调用的一个其他线程
    2.  Date d=new Date();
    3.  System.out.println(d);
    5.  //是主线程调用的一个其他线程
    6.  System.out.println(System.currentTimeMillis());
    8.  say();

    }

    public static void say(){

    1.  System.out.println("hello");

    } } ```

    案例1

    ```java package com.xincheng_01;

/**

  • @author Lynn
  • @create 2020-12-14-15:20 */

/**

  • 自定义线程类 *
  • 定义一个Thread的子类 *

  • 创建线程的第一种方式：继承Thread类 */ public class MyThread extends Thread {

    //重写run方法—相关的逻辑写进去 @Override public void run(){

    1.  for (int i = 0; i <50 ; i++) {
    2.      /**
    3.       * this表示当前被调用的的这个线程
    4.       * 获取现成的名字是java干的事情，我们不管
    5.       */
    6.      System.out.println(this.getName()+":"+i);
    7.  }

    } } java package com.xincheng_01;

/**

  • @author Lynn
  • @create 2020-12-14-15:13 */

/**

  • java中使用Thread类来创建线程： 第一种方式： *
  • 步骤：
  • 1.指定执行现成的目标：定义一个Thread子类，重写run方法，将相关的逻辑实现
  • public void run():将需要的逻辑写在里面，该方法相当于线程中的main方法
  • 2.创建自定义线程的子类对象
  • 3.开启线程操作—触发
  • public void start():只要调用了这个方法，线程才会启动，开始执行 *
  • Thread中的相关方法：
  • public final String getName():获取线程的名字
  • public final void setName():设置线程的名字
  • public static Thread currentThread():获取当前的线程对象 *

  • 线程的运行默认是不可控制的，是CPU随机调用的，我们只能看到运行的结果 / public class ThreadDemo { //主线程 public static void main(String[] args) { //创建线程对象—用于开启线程 Thread t1=new MyThread(); Thread t2=new MyThread();

    //开启线程—直接运行 t1.start(); t2.start();

    System.out.println(“———————————————————“);

    //返回一个main线程—其实就是main方法的线程 Thread mainThread=Thread.currentThread(); System.out.println(mainThread);//Thread[main,5,main]

    for (int i = 0; i <50 ; i++) {

    1.    System.out.println(mainThread.getName()+":"+i);

    } } } ```

    案例2

    ```java package com.xincheng_01;

/**

  • @author Lynn
  • @create 2020-12-14-15:36 */

/**

  • 创建线程的第二种方式：
  • 实现Runnable接口,lang包下的： *
  • 1.实现接口，并且要实现run方法
  • 2.在run方法中，添加逻辑代码
  • 3.通过start启动线程 */ public class MyRunable implements Runnable{ @Override public void run(){
    1.  //返回当前线程
    2.  Thread thisThread=Thread.currentThread();
    3.  for (int i = 0; i <20 ; i++) {
    4.      System.out.println(thisThread.getName()+":"+i);
    5.  }
    } } java package com.xincheng_01;

/**

  • @author Lynn
  • @create 2020-12-14-15:13 */

/**

  • 1.使用匿名内部类创建线程的原理和普通类创建线程的原理完全一样
  • 2.区别在于利用匿名内部类创建线程的写法更加简洁，使用非常多 ```java package com.xincheng_02;

/**

  • @author Lynn
  • @create 2020-12-14-16:06 */

/**

  • 演示匿名内部类创建线程—实际开发中使用 *
  • 1.使用匿名内部类创建线程的原理和普通类创建线程的原理完全一样

  • 2.区别在于利用匿名内部类创建线程的写法更加简洁，使用非常多 */ public class AnonysThreadDemo { public static void main(String[] args) {

    1.  //方式一：使用匿名内部类创建线程的子类对象
    2.  Thread t1 = new Thread() {
    3.      @Override
    4.      public void run() {
    5.          System.out.println("还记得去年陪你过圣诞节的人吗");
    7.      }
    8.  };
    9.  t1.start();
    10.  System.out.println("----------------------------------------------------------------");
    11.  //使用匿名内部类，创建线程的匿名子类对象，并且启动线程
    12.  new Thread() {
    13.      @Override
    14.      public void run() {
    15.          System.out.println("还记得上一次陪你去看演唱会的人吗");
    16.      }
    17.  }.start();
    19.  //方式二：使用匿名内部类的方式，创建执行目标类的对象
    20.  Runnable r = new Runnable() {
    21.      @Override
    22.      public void run() {
    23.          System.out.println("她来听我的演唱会");
    24.      }
    25.  };
    26.  //传入到构造函数
    27.  Thread t2 = new Thread(r);
    28.  t2.start();
    30.  System.out.println("-----------------------------");
    32.  //组合写法-精简写法
    33.  new Thread(new Runnable() {
    34.      @Override
    35.      public void run() {
    36.          System.out.println("往事只能回味");
    37.      }
    38.  }).start();
    40.  //组合写法--普通写法
    41.  Thread t3=new Thread(new Runnable() {
    42.      @Override
    43.      public void run() {
    44.          System.out.println("往事只能回味");
    45.      }
    46.  });
    47.  t3.start();

    } } ```

    练习（售卖车票）

    ```java package com.xincheng_03;

/**

  • @author Lynn
  • @create 2020-12-14-16:29 */

import javax.crypto.interfaces.PBEKey;

/**

  • 这是一个任务

  • 使用第二种方式—使用Runnable接口 */ public class Ticket implements Runnable{ //定义车票数 private int number=100;

    //卖票的逻辑 @Override public void run() {

    1.  //模拟车站不停地卖票--卖光为止
    2.  while (true){
    3.      //有票就卖
    4.      if (number>0){
    5.          System.out.println(Thread.currentThread().getName()+"正在销售第"+(number--)+"张票");
    6.      }else {
    7.          //没有票了
    8.          break;
    9.      }
    10.  }

    } } java package com.xincheng_03;

/**

  • @author Lynn
  • @create 2020-12-14-16:25 */

/**

  • 多线程模拟售卖火车票 *
  • 要求使用第二种方式实现，方便数据共享 *
  • 步骤：
  • 1.定义卖票的线程执行目标：（任务）
  • 在成员变量定义为票数100张，卖掉一张，改数字就减去1，一直到0为止
  • 重写run方法，完成案例
  • 2.创建买票的线程且执行该目标的对象
  • 3.使用该卖票子线程执行对象创建多个线程任务

  • 4.开启多个线程 */ public class TicketDemo { public static void main(String[] args) {

    1.  //创建车票的线程执行目标对象
    2.  Ticket ticket=new Ticket();
    4.  /*//使用该卖票的线程执行目标的对象创建多个任务
    5.  Thread t1 = new Thread(ticket,"jack.Ma");
    6.  Thread t2 = new Thread(ticket,"Huateng.Ma");
    7.  Thread t3 = new Thread(ticket,"Yanhong.Li");
    9.  t1.start();
    10.  t2.start();
    11.  t3.start();*/
    12.  new Thread(ticket,"jack.Ma").start();
    13.  new Thread(ticket,"Huateng.Ma").start();
    14.  new Thread(ticket,"Yanhong.Li").start();

    } } ```

    回顾

    image.png

    线程池与线程生命周期

    线程生命周期图示

    image.png
    image.png

    线程池

    image.png ```java package com.igeek_01;

/**

  • @author Lynn
  • @create 2020-12-14-16:29 */

/**

  • 这是一个任务

  • 使用第二种方式—使用Runnable接口 */ public class Ticket implements Runnable{ //定义车票数 private int number=100;

    //卖票的逻辑 @Override public void run() {

    1.  //模拟车站不停地卖票--卖光为止
    2.  while (true){
    3.      //有票就卖
    4.      if (number>0){
    5.          System.out.println(Thread.currentThread().getName()+"正在销售第"+(number--)+"张票");
    6.      }else {
    7.          //没有票了
    8.          break;
    9.      }
    10.  }

    } } java package com.igeek_01;

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

/**

  • @author Lynn

  • @create 2020-12-15-9:08 */ public class ThreadPoolDemo { public static void main(String[] args) {

    1.  //实例化线程池
    2.  /**
    3.   * ExecutorService是一个接口，专门处理线程池的
    4.   * Executors是一个工具类，提供了很多的方法服务于线程
    5.   * newFixedThreadPool(3)该方法传入的参数表示在线程启动的时候初始化几个线程
    6.   */
    7.  ExecutorService  threadPool= Executors.newFixedThreadPool(3);
    9.  //创建线程的执行目标
    10.  Ticket ticket=new Ticket();
    11.  //向线程池中提交任务目标
    12.  threadPool.submit(ticket);
    13.  threadPool.submit(ticket);
    14.  threadPool.submit(ticket);
    15.  threadPool.submit(ticket);
    16.  threadPool.submit(ticket);
    18.  //在适当的时候也可以关闭线程池，一般不关闭
    19.  //意味着线程池中的所有的线程都销毁

    // threadPool.shutdown(); } } ```

image.png

Callable接口

image.png

  1. package com.igeek_02;
  3. /**
  4.  * @author Lynn
  5.  * @create 2020-12-14-16:29
  6.  */
  8. /**
  9.  * 这是一个任务
  10.  * 使用第二种方式--使用Runnable接口
  11.  */
  12. public class Ticket implements Runnable{
  13.     //定义车票数
  14.     private int number=100;
  16.     //卖票的逻辑
  17.     @Override
  18.     public void run() {
  19.         //模拟车站不停地卖票--卖光为止
  20.         while (true){
  21.             //有票就卖
  22.             if (number>0){
  23.                 System.out.println(Thread.currentThread().getName()+"正在销售第"+(number--)+"张票");
  24.             }else {
  25.                 //没有票了
  26.                 break;
  27.             }
  28.         }
  29.     }
  30. }
  1. package com.igeek_02;
  3. import java.util.concurrent.Callable;
  5. /**
  6.  * @author Lynn
  7.  * @create 2020-12-15-10:03
  8.  */
  9. public class MyCallable implements Callable<String> {
  10.     /**
  11.      * 定义一个线程执行的目标逻辑
  12.      * @return
  13.      * @throws Exception
  14.      */
  15.     @Override
  16.     public String call() throws Exception {
  17.         return "我是线程任务的返回值结果";
  18.     }
  19. }
  1. package com.igeek_02;
  3. import java.util.concurrent.ExecutionException;
  4. import java.util.concurrent.ExecutorService;
  5. import java.util.concurrent.Executors;
  6. import java.util.concurrent.Future;
  8. /**
  9.  * @author Lynn
  10.  * @create 2020-12-15-9:08
  11.  */
  12. public class ThreadPoolDemo {
  13.     public static void main(String[] args) throws ExecutionException, InterruptedException {
  14.         //实例化线程池
  15.         /**
  16.          * ExecutorService是一个接口，专门处理线程池的
  17.          * Executors是一个工具类，提供了很多的方法服务于线程
  18.          * newFixedThreadPool(3)该方法传入的参数表示在线程启动的时候初始化几个线程
  19.          */
  20.         ExecutorService  threadPool= Executors.newFixedThreadPool(3);
  22.         //创建线程的执行目标
  23.         Ticket ticket=new Ticket();
  25.         //利用Callable接口返回Future，（没有返回值的run方法，返回的是null，没有意义)
  26.         Future<?> ticketFuture = threadPool.submit(ticket);
  27.         System.out.println(ticketFuture.get());
  29.         //创建带有返回值的线程执行目标
  30.         MyCallable callable=new MyCallable();
  31.         //向线程中提交任务，并返回线程目标的执行结果
  32.         Future<String> future1= threadPool.submit(callable);
  33.         Future<String> future2= threadPool.submit(callable);
  34.         Future<String> future3= threadPool.submit(callable);
  35.         //从执行结果中返回call的具体值
  36.         String result1=future1.get();
  37.         String result2=future2.get();
  38.         String result3=future3.get();
  39.         System.out.println(result1);
  40.         System.out.println(result2);
  41.         System.out.println(result3);
  43.         //在适当的时候也可以关闭线程池，一般不关闭
  44.         //意味着线程池中的所有的线程都销毁
  45. //        threadPool.shutdown();
  46.     }
  47. }

线程安全问题

image.png

线程安全问题的解决方案—-加锁

image.png

  1. package com.igeek_04;
  3. /**
  4.  * @author Lynn
  5.  * @create 2020-12-15-10:32
  6.  */
  8. /**
  9.  * 使用第二种方式创建线程，原因是执行线程目标对象共享
  10.  *
  11.  * 定义一个卖票的线程执行目标对象--加锁
  12.  */
  13. public class Ticket implements Runnable{
  14.     //票数
  15.     private int number=100;
  17.     //声明成员变量为定义锁对象
  18.     private Object lock=new Object();
  20.     @Override
  21.     public void run() {
  22.         while (true){
  23.             synchronized (lock){
  24.                 //线程暂停
  25.                 try {
  26.                     Thread.sleep(500);
  27.                 } catch (InterruptedException e) {
  28.                     e.printStackTrace();
  29.                 }
  30.                 //有票就卖
  31.                 if (number>0){
  32.                     String threadName=Thread.currentThread().getName();
  33.                     System.out.println(threadName+"正在销售第"+number+"张票");
  34.                     number--;
  35.                 }else {
  36.                     //没票了
  37.                     break;
  38.                 }
  39.             }
  40.         }
  41.     }
  42. }
  1. package com.igeek_04;
  3. /**
  4.  * @author Lynn
  5.  * @create 2020-12-15-10:44
  6.  */
  8. /**
  9.  * 线程安全问题的解决方案 ：
  10.  * 同步代码块
  11.  * synchronized(锁对象){
  12.  *     可能出现线程安全问题的代码
  13.  * }
  14.  */
  15. public class ThreadDemo {
  16.     public static void main(String[] args) {
  17.         //实例化目标
  18.         Ticket ticket=new Ticket();
  20.         //使用该卖票的目标创建多个线程
  21.         Thread thread1=new Thread(ticket,"Jack");
  22.         Thread thread2=new Thread(ticket,"Rose");
  23.         Thread thread3=new Thread(ticket,"Tom");
  25.         //启动多个线程
  26.         thread1.start();
  27.         thread2.start();
  28.         thread3.start();
  29.     }
  30. }

优化

  1. package com.igeek_05;
  3. /**
  4.  * @author Lynn
  5.  * @create 2020-12-15-10:32
  6.  */
  8. /**
  9.  * 使用第二种方式创建线程，原因是执行线程目标对象共享
  10.  *
  11.  * 定义一个卖票的线程执行目标对象--加锁
  12.  */
  13. public class Ticket implements Runnable{
  14.     //票数
  15.     private int number=100;
  17.     //声明成员变量为定义锁对象
  18.     private Object lock=new Object();
  20.     //创建一个标记，让不同的人来执行不同的代码块
  21.     private int x=0;
  23.     @Override
  24.     public void run() {
  25.         while (true){
  26.             //进行取余的运算，模拟卖票的人
  27.             if(x%2==0){
  28.                 //代码块
  29.                 //将完整的一套动作使用synchronized包裹
  30.                 synchronized (lock){
  31.                     //线程暂停
  32.                     try {
  33.                         Thread.sleep(100);
  34.                     } catch (InterruptedException e) {
  35.                         e.printStackTrace();
  36.                     }
  37.                     //有票就卖
  38.                     if (number>0){
  39.                         String threadName=Thread.currentThread().getName();
  40.                         System.out.println(threadName+"正在销售第"+number+"张票");
  41.                         number--;
  42.                     }else {
  43.                         //没票了
  44.                         break;
  45.                     }
  46.                 }
  47.             }else {
  48.                 //代码块
  49.                 //将完整的一套动作使用synchronized包裹
  50.                 synchronized (lock){
  51.                     //线程暂停
  52.                     try {
  53.                         Thread.sleep(500);
  54.                     } catch (InterruptedException e) {
  55.                         e.printStackTrace();
  56.                     }
  57.                     //有票就卖
  58.                     if (number>0){
  59.                         String threadName=Thread.currentThread().getName();
  60.                         System.out.println(threadName+"正在销售第"+number+"张票");
  61.                         number--;
  62.                     }else {
  63.                         //没票了
  64.                         break;
  65.                     }
  66.                 }
  67.             }
  68.             x++;
  69.         }
  70.     }
  71. }
  1. package com.igeek_05;
  3. /**
  4.  * @author Lynn
  5.  * @create 2020-12-15-10:44
  6.  */
  8. /**
  9.  * 线程安全问题的解决方案 ：
  10.  * 同步代码块
  11.  * synchronized(锁对象){
  12.  *     可能出现线程安全问题的代码
  13.  * }
  14.  */
  15. public class ThreadDemo {
  16.     public static void main(String[] args) {
  17.         //实例化目标
  18.         Ticket ticket=new Ticket();
  20.         //使用该卖票的目标创建多个线程
  21.         Thread thread1=new Thread(ticket,"Jack");
  22.         Thread thread2=new Thread(ticket,"Rose");
  23.         Thread thread3=new Thread(ticket,"Tom");
  25.         //启动多个线程
  26.         thread1.start();
  27.         thread2.start();
  28.         thread3.start();
  29.     }
  30. }

同步方法（用synchronized修饰）有静态和非静态的

image.png
非静态方法

  1. package com.igeek_06;
  3. /**
  4.  * @author Lynn
  5.  * @create 2020-12-15-10:32
  6.  */
  8. /**
  9.  * 使用第二种方式创建线程，原因是执行线程目标对象共享
  10.  *
  11.  * 定义一个卖票的线程执行目标对象--加锁
  12.  *
  13.  * 演示synchronized可以用来修饰方法，叫做同步方法
  14.  *
  15.  * 当前案例中，使用对象锁对当前的这个Ticket加锁，目的是this是当前正在被调用的这个Ticket对象，
  16.  * 不管是synchronized代码块中还是封装的一个synchronized方法，都可以保证使用的是同一个锁对象
  17.  */
  18. public class Ticket implements Runnable{
  19.     //票数
  20.     private int number=100;
  22.     //声明成员变量为定义锁对象
  23.     private Object lock=new Object();
  25.     //创建一个标记，让不同的人来执行不同的代码块
  26.     private int x=0;
  28.     @Override
  29.     public void run() {
  30.         while (true){
  31.             //进行取余的运算，模拟卖票的人
  32.             if(x%2==0){
  33.                 //代码块
  34.                 //将完整的一套动作使用synchronized包裹
  35.                 //把当前这个被调用的对象锁住
  36.                 synchronized (this){
  37.                     //线程暂停
  38.                     try {
  39.                         Thread.sleep(100);
  40.                     } catch (InterruptedException e) {
  41.                         e.printStackTrace();
  42.                     }
  43.                     //有票就卖
  44.                     if (number>0){
  45.                         String threadName=Thread.currentThread().getName();
  46.                         System.out.println(threadName+"正在销售第"+number+"张票");
  47.                         number--;
  48.                     }else {
  49.                         this.sell();
  50.                     }
  51.                 }
  52.             }
  53.             //当票数=0，就表示没票了
  54.             if(number<0){
  55.                 break;
  56.             }
  57.             x++;
  58.         }
  59.     }
  61.         public synchronized void sell(){
  62.             try {
  63.                 Thread.sleep(20);
  64.             } catch (InterruptedException e) {
  65.                 e.printStackTrace();
  66.             }
  68.             if (number>0){
  69.                 String threadName=Thread.currentThread().getName();
  70.                 System.out.println(threadName+"正在销售第"+number+"张票");
  71.                 number--;
  72.             }
  73.         }
  74. }
  1. package com.igeek_06;
  3. /**
  4.  * @author Lynn
  5.  * @create 2020-12-15-10:44
  6.  */
  8. import com.igeek_05.Ticket;
  10. /**
  11.  * 线程安全问题的解决方案 ：
  12.  * 同步代码块
  13.  * synchronized(锁对象){
  14.  *     可能出现线程安全问题的代码
  15.  * }
  16.  */
  17. public class ThreadDemo {
  18.     public static void main(String[] args) {
  19.         //实例化目标
  20.         com.igeek_05.Ticket ticket=new Ticket();
  22.         //使用该卖票的目标创建多个线程
  23.         Thread thread1=new Thread(ticket,"Jack");
  24.         Thread thread2=new Thread(ticket,"Rose");
  25.         Thread thread3=new Thread(ticket,"Tom");
  27.         //启动多个线程
  28.         thread1.start();
  29.         thread2.start();
  30.         thread3.start();
  31.     }
  32. }

静态方法

  1. package com.igeek_07;
  3. /**
  4.  * @author Lynn
  5.  * @create 2020-12-15-10:32
  6.  */
  8. /**
  9.  * 使用第二种方式创建线程，原因是执行线程目标对象共享
  10.  *
  11.  * 定义一个卖票的线程执行目标对象--加锁
  12.  *
  13.  * 演示synchronized可以用来修饰方法，叫做同步方法
  14.  * 同时也支持修饰静态方法！！！
  15.  *
  16.  * 当前案例中，使用对象锁对当前的这个Ticket加锁，目的是this是当前正在被调用的这个Ticket对象，
  17.  * 不管是synchronized代码块中还是封装的一个synchronized方法，都可以保证使用的是同一个锁对象
  18.  */
  19. public class Ticket implements Runnable{
  20.     //票数--静态方法不能调用非静态资源
  21.     private static int number=100;
  23.     //声明成员变量为定义锁对象
  24.     private Object lock=new Object();
  26.     //创建一个标记，让不同的人来执行不同的代码块
  27.     private int x=0;
  29.     @Override
  30.     public void run() {
  31.         while (true){
  32.             //进行取余的运算，模拟卖票的人
  33.             if(x%2==0){
  34.                 //代码块
  35.                 //将完整的一套动作使用synchronized包裹
  36.                 //类名直接调用静态方法
  37.                 synchronized (Ticket.class){
  38.                     //线程暂停
  39.                     try {
  40.                         Thread.sleep(50);
  41.                     } catch (InterruptedException e) {
  42.                         e.printStackTrace();
  43.                     }
  44.                     //有票就卖
  45.                     if (number>0){
  46.                         String threadName=Thread.currentThread().getName();
  47.                         System.out.println(threadName+"正在销售第"+number+"张票");
  48.                         number--;
  49.                     }/*else {
  50.                         //没票了
  51.                         break;
  52.                     }*/
  53.                 }
  54.             }else {
  55. //               this.sell();
  56.                 Ticket.sell();
  57.             }
  58.             //当票数=0，就表示没票了
  59.             if(number<0){
  60.                 break;
  61.             }
  62.             x++;
  63.             }
  64.         }
  66.         public static synchronized void sell(){
  67.             try {
  68.                 Thread.sleep(20);
  69.             } catch (InterruptedException e) {
  70.                 e.printStackTrace();
  71.             }
  73.             if (number>0){
  74.                 String threadName=Thread.currentThread().getName();
  75.                 System.out.println(threadName+"正在销售第"+number+"张票");
  76.                 number--;
  77.             }
  78.         }
  79. }
  1. package com.igeek_07;
  3. /**
  4.  * @author Lynn
  5.  * @create 2020-12-15-10:44
  6.  */
  8. import com.igeek_05.Ticket;
  10. /**
  11.  * 线程安全问题的解决方案 ：
  12.  * 同步代码块
  13.  * synchronized(锁对象){
  14.  *     可能出现线程安全问题的代码
  15.  * }
  16.  */
  17. public class ThreadDemo {
  18.     public static void main(String[] args) {
  19.         //实例化目标
  20.         Ticket ticket=new Ticket();
  22.         //使用该卖票的目标创建多个线程
  23.         Thread thread1=new Thread(ticket,"Jack");
  24.         Thread thread2=new Thread(ticket,"Rose");
  25.         Thread thread3=new Thread(ticket,"Tom");
  27.         //启动多个线程
  28.         thread1.start();
  29.         thread2.start();
  30.         thread3.start();
  31.     }
  32. }

回顾

image.png

演示等待和唤醒机制

image.png
image.png

案例

  1. package com.igeek_08;
  3. /**
  4.  * @author Lynn
  5.  * @create 2020-12-15-15:18
  6.  */
  8. /**
  9.  * 资源类（实体类）
  10.  *
  11.  * 定义共享的数据，其中成员：name，sex
  12.  */
  13. public class Person {
  14.     //不使用private是为了便于后面的操作
  15.     String name;
  16.     String sex;
  18.     //状态标记
  19.     /**
  20.      * flag:
  21.      * true:有数据，生产者等待被消费
  22.      * false：没有数据，生产者生产，消费者等待
  23.      */
  24.     boolean flag;
  26.     public Person(){
  27.         super();
  28.     }
  29. }
  1. package com.igeek_08;
  3. /**
  4.  * @author Lynn
  5.  * @create 2020-12-15-15:20
  6.  */
  8. /**
  9.  * 生产者
  10.  *
  11.  * 生产者的执行目标：
  12.  *    反复为Person对象赋值:Jack  男  与  Rose   女
  13.  */
  14. public class PutIn implements Runnable{
  16.     //实例化对象--声明
  17.     private Person person;
  19.     //创建构造方法用于接收外部传入的共享数据Person
  20.     public PutIn(Person person){
  21.         this.person=person;
  22.     }
  23.     @Override
  24.     public void run() {
  25.         //使用循环达到反复赋值的目的
  26.         //如果是奇数，就生成Jack  男，如果是偶数，救生成Rose   女
  27.         int i=0;
  28.         while (true){
  29.             synchronized (person){
  30.                 //判断状态flag是true还是false
  31.                 while (person.flag){
  32.                     //有数据,就等待
  33.                     try {
  34.                         person.wait();//线程阻塞
  35.                     } catch (InterruptedException e) {
  36.                         e.printStackTrace();
  37.                     }
  38.                 }
  39.                 //如果没有数据或者是刚被唤醒
  40.                 //判断生产的内容
  41.                 if (i%2==1){//男
  42.                     person.name="Jack";
  43.                     try {
  44.                         Thread.sleep(100);
  45.                     } catch (InterruptedException e) {
  46.                         e.printStackTrace();
  47.                     }
  48.                     person.sex="男";
  49.                 }else {//女
  50.                     person.name="Rose";
  51.                     try {
  52.                         Thread.sleep(100);
  53.                     } catch (InterruptedException e) {
  54.                         e.printStackTrace();
  55.                     }
  56.                     person.sex="女";
  57.                 }
  58.                 System.out.println(person);
  59.                 System.out.println("生产了"+person.name+"-"+person.sex);
  61.                 //切换状态为true
  62.                 person.flag=true;
  63.                 //如果有消费者等待，就唤醒消费者，如果没有消费者等待，就不需要唤醒，相当于没有执行
  64.                 person.notify();
  65.             }
  66.             i++;
  67.         }
  68.     }
  69. }
  1. package com.igeek_08;
  3. /**
  4.  * @author Lynn
  5.  * @create 2020-12-15-15:29
  6.  */
  8. /**
  9.  * 消费者目标对象
  10.  *
  11.  * 反复的获取Person对象，并且打印
  12.  */
  13. public class GetOut implements Runnable{
  14.     //实例化共享资源
  15.     private Person person;
  17.     public GetOut(Person person) {
  18.         this.person=person;
  19.     }
  21.     @Override
  22.     public void run() {
  23.         //使用循环获取
  24.         while (true) {
  25.             //利用共享对象作为锁
  26.             synchronized (person){
  27.                 //获取判断状态--flag
  28.                 while (!person.flag){
  29.                     //没有数据就等待生产
  30.                     try {
  31.                         person.wait();
  32.                     } catch (InterruptedException e) {
  33.                         e.printStackTrace();
  34.                     }
  35.                 }
  36.                 //有数据或者是刚刚被唤醒
  37.                 try {
  38.                     Thread.sleep(100);
  39.                 } catch (InterruptedException e) {
  40.                     e.printStackTrace();
  41.                 }
  43.                 //进行获取操作
  44.                 String name= person.name;
  45.                 String sex= person.sex;
  46.                 System.out.println(person);
  47.                 System.out.println("消费了："+name+"-"+sex);
  49.                 //切换状态为false
  50.                 person.flag=false;
  52.                 //唤醒生产者，如果有就唤醒，如果没有就不需要唤醒，相当于没有执行
  53.                 person.notify();
  54.             }
  55.         }
  56.     }
  57. }
  1. package com.igeek_08;
  3. /**
  4.  * @author Lynn
  5.  * @create 2020-12-15-15:15
  6.  */
  8. /**
  9.  * 演示等待和唤醒机制
  10.  */
  11. public class WaitNotifyDemo {
  12.     public static void main(String[] args) {
  13.         //实例化对象
  14.         Person person=new Person();
  16.         //创建生产者的执行目标
  17.         PutIn putIn=new PutIn(person);
  19.         //创建消费者的执行目标
  20.         GetOut getOut=new GetOut(person);
  22.         //开启生产者线程
  23.         Thread putInThread=new Thread(putIn);
  24.         putInThread.start();
  26.         //开启消费者线程
  27.         Thread getOutThread=new Thread(getOut);
  28.         getOutThread.start();
  30.     }
  31. }