多线程学习

1.进程与线程

• 进程：正在运行的程序,是系统进行资源分配的基本单位。

  • 目前操作系统都是支持多进程,可以同时执行多个进程，通过进程ID（process ID-PID）区分。
  • 单核CPU在同一个时刻,只能运行一个进程;宏观并行、微观串行。

• 线程，又称轻量级进程（Light Weight Process）。进程中的一条执行路径，也是CPU的基本调度单位。

  • 一个进程由一个或多个线程组成，彼此间完成不同的工作，同时执行，称为多线程。
  • 迅雷是一个进程,当中的多个下载任务即是多个线程。
  • Java虚拟机是一个进程，当中默认包含主线程（(main) ,可通过代码创建多个独立线程,与main并发执行。

• 进程与线程的区别：

  • 1、进程是操作系统资源分配的基本单位，而线程是CPU的基本调度单位。
  • 2、一个程序运行后至少有一个进程。
  • 3、一个进程可以包含多个线程，但是至少需要有一个线程，否则这个进程是没有意义。
  • 4、进程间不能共享数据段地址,但同进程的线程之间可以。

• 线程的组成：

  • 任何一个线程都具有基本的组成部分:

  • CPU时间片:操作系统（0S）会为每个线程分配执行时间。

  • 运行数据:

    • 堆空间:存储线程需使用的对象，多个线程可以共享堆中的对象。

    • 栈空间:存储线程需使用的局部变量，每个线程都拥有独立的栈。

  • 线程的逻辑代码。

• 线程的特点：

  • 1、线程抢占式执行。
    • 效率高
    • 可防止单一线程长时间独占CPU
  • 2、在单核CPU中，宏观上同时执行，微观上顺序执行。

2.创建线程

• 创建线程三种方式

  • 1、【继承Thread类,重写run方法】

  • 2、【实现Runnable接口】

  • 3、【实现Callable接口】

2.1【继承Thread类,重写run方法】，有四个步骤

• 继承Thread类
• 覆盖run（）方法
• 创建子类对象
• 调用start（）方法

//获取线程ID和线程名称:
1、在Thread的子类中调用this.getId()或this.getName ()
2、使用Thread.currentThread().getId()和Thread. currentThread().getName ()
//修改线程名称，线程ID不能修改
1、调用线程对象的setName()方法。
2、使用线程子类的构造方法赋值。

/**
 * 线程类
 */
public class MyThread extends Thread{
    public MyThread() {
    }

    public MyThread(String name) {
        super(name);//把name传给父类Thread的构造函数
    }

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
//            方法1：this.getId()或this.getName ()
//            this.getID：获取线程ID
//            this.getName：获取线程名称
//            System.out.println("线程ID："+this.getId()+"线程名称：" +this.getName()+
//                    "子线程.........."+i);
//            方法2：Thread.currentThread()：获取当前线程
            System.out.println("线程ID："+ Thread.currentThread().getId() +
                    "线程名称："+Thread.currentThread().getName()+"子线程.........."+i);
        }
    }
}

public class Test {
    public static void main(String[] args) {
        //1.创建线程对象
        MyThread myThread=new MyThread();
        //2.启动线程,不能调用run（）方法，在main（）方法中调用run（）方法相当于调用对象的一个普通方法
        myThread.setName("我的子线程1");//修改线程名字，要在线程启动之前修改，线程ID不能修改
        myThread.start();

        MyThread myThread1=new MyThread("我的子线程2");
//        myThread.setName("我的子线程2");
        myThread1.start();

        for (int i = 0; i < 500; i++) {
            System.out.println("主线程========="+i);
        }
    }
}

实现四个窗口各卖100张票的功能：

/**
 * 买票窗口类
 */
public class TicketWin extends Thread{
    private int count=100;

    public TicketWin() {
    }

    public TicketWin(String name) {
        super(name);
    }

    @Override
    public void run() {
       //实现卖票功能
        while (true){
            if(count<=0){
                break;
            }
            System.out.println(Thread.currentThread().getName()+"卖了第"+count+"张票");
            count--;
        }
    }
}
//测试类
public class TestWin {
    public static void main(String[] args) {
        //创建四个线程对象
        TicketWin tw1=new TicketWin("1号窗口");
        TicketWin tw2=new TicketWin("2号窗口");
        TicketWin tw3=new TicketWin("3号窗口");
        TicketWin tw4=new TicketWin("4号窗口");
        //启动线程
        tw1.start();
        tw2.start();
        tw3.start();
        tw4.start();
    }
}

2.2【实现Runnable接口】，有四个步骤

• 实现Runnable接口
• 覆盖run（）方法
• 创建实现类的对象
• 创建线程对象
• 调用start()方法

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 TestMyRunnable {
    public static void main(String[] args) {
//        //创建MyRunnable接口，表示线程要执行的功能
//        MyRunnable mr=new MyRunnable();
//        Thread thread=new Thread(mr,"我的线程1");
//        thread.start();
//        for (int i = 0; i < 500; i++) {
//            System.out.println("main..........."+i);
//        }
        //只是用MyRunnable一次的话，代码有些冗长，使用匿名内部类进行优化
    Thread thread=new Thread(new Runnable(){
        @Override
        public void run() {
            for (int i = 0; i < 100; i++) {
                System.out.println(Thread.currentThread().getName()+"........"+i);
            }
        }
    },"我的线程1");
        thread.start();
        for (int i = 0; i < 500; i++) {
            System.out.println("main..........."+i);
        }
    }
}

实现四个窗口一共卖100张票的功能：

/**
 * 票类（共享资源类）
 */
public class TicketWin2 implements Runnable{
    public int ticket=100;
    @Override
    public void run() {
        while (true){
            if (ticket<=0){
                break;
            }
            System.out.println(Thread.currentThread().getName()+"卖了第"+ticket+"张票");
            ticket--;
        }
    }
}

//测试类
public class TestWin2 {
    public static void main(String[] args) {
        TicketWin2 tw1=new TicketWin2();
        Thread thread1=new Thread(tw1,"1号窗口");
        Thread thread2=new Thread(tw1,"2号窗口");
        Thread thread3=new Thread(tw1,"3号窗口");
        Thread thread4=new Thread(tw1,"4号窗口");
        thread1.start();
        thread2.start();
        thread3.start();
        thread4.start();
    }
}
//这样执行会出现线程安全问题

你和你女朋友共用一张银行卡，你向卡中存钱，你女朋友从卡中取钱,使用程序模拟过程：

/**
 * 银行卡类
 */
public class BankCard {
    private double money;

    public double getMoney() {
        return money;
    }

    public void setMoney(double money) {
        this.money = money;
    }
}

//存钱
public class AddMoney implements Runnable{
    private BankCard card;

    public AddMoney() {
    }

    public AddMoney(BankCard card) {
        this.card = card;
    }

    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            card.setMoney(card.getMoney()+1000);
            System.out.println(Thread.currentThread().getName()+"存了1000，余额是："+card.getMoney());
        }
    }
}

//取钱
public class SubMoney implements Runnable{
    private BankCard card;

    public SubMoney() {
    }

    public SubMoney(BankCard card) {
        this.card = card;
    }

    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            if (card.getMoney()>=1000) {
                card.setMoney(card.getMoney() - 1000);
                System.out.println(Thread.currentThread().getName() + "取了1000，余额是：" + card.getMoney());
            }else{
                System.out.println("余额不足");
                i--;
            }
            }
    }
}

//测试类
public class Test {
    public static void main(String[] args) {
        //1.创建一张银行卡
        BankCard bankCard=new BankCard();
        //2.创建存钱，取钱
        AddMoney add=new AddMoney(bankCard);//可以使用匿名内部类简化代码
        SubMoney sub=new SubMoney(bankCard);
        //3.创建线程
        Thread thread1=new Thread(add,"晨晨");//new Thread(add,"晨晨").start()
        Thread thread2=new Thread(sub,"冰冰");
        //4.启动线程
        thread1.start();
        thread2.start();
    }
}

3.线程的状态

注：JDK1.5之后，就绪和运行统称为Runnable

4.线程常用方法

//休眠: 当前线程主动休眠millis毫秒。
public static void sleep(long millis)
//放弃:当前线程主动放弃时间片，回到就绪状态，竞争下一次时间片。
public static void yield()
//加入:允许其他线程加入到当前线程中。
public final void join()
   
//修改线程优先级：
   //线程对象.setPriority()；线程优先级为1-10，默认为5,优先级越高，表示获取CPU机会越多。
   
//守护线程：
   //线程对象.setDaemon(true);设置为守护线程。
   //线程有两类:用户线程（前台线程)、守护线程（后台线程)。
   //如果程序中所有前台线程都执行完毕了，后台线程会自动结束。
   //垃圾回收器线程属于守护线程。

//休眠
public class SleepThread extends Thread{
  @Override
  public void run() {
      for (int i = 0; i < 10; i++) {
          System.out.println(Thread.currentThread().getName()+"......"+i);
          try {
              Thread.sleep(1000);//休眠1000ms
              //这个异常不能抛出，因为这个父类没有抛出异常
              // 子类继承父类，子类不能抛出比父类更多更宽的异常
          } catch (InterruptedException e) {
              e.printStackTrace();
          }
      }
  }
}

//测试类
public class TestSleep {
  public static void main(String[] args) {
      SleepThread sleepThread=new SleepThread();
      sleepThread.start();
      SleepThread sleepThread1=new SleepThread();
      sleepThread1.start();
  }
}

//放弃
public class YieldThread extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName()+"......"+i);
            //主动放弃CPU
            Thread.yield();
        }
    }
}

//测试类
public class TestYield {
    public static void main(String[] args) {
        YieldThread yieldThread=new YieldThread();
        YieldThread yieldThread1=new YieldThread();
        yieldThread.start();
        yieldThread1.start();
    }
}

//加入线程
public class JoinThread extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 30; i++) {
            System.out.println(Thread.currentThread().getName()+"........"+i);
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

//测试类
public class TestJoin {
    public static void main(String[] args) {
        JoinThread jt=new JoinThread();
        jt.start();

        try {
            jt.join();//加入当前线程（main主线程），并阻塞当前线程，直到加入线程执行完毕
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        for (int i = 0; i < 20; i++) {
            System.out.println(Thread.currentThread().getName()+"=========="+i);
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

//修改线程优先级
public class PriorityThread extends Thread{
   @Override
    public void run(){
       for (int i = 0; i < 50; i++) {
           System.out.println(Thread.currentThread().getName()+"........"+i);
       }
    }
}

//测试类
public class TestPriority {
    public static void main(String[] args) {
        PriorityThread pt1=new PriorityThread();
        PriorityThread pt2=new PriorityThread();
        PriorityThread pt3=new PriorityThread();

        pt1.setPriority(1);
        pt3.setPriority(10);

        pt1.start();
        pt2.start();
        pt3.start();

    }
}

//守护线程
public class DaemonThread extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 50; i++) {
            System.out.println(Thread.currentThread().getName()+"........"+i);
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

//测试类
public class TestDaemon {
    public static void main(String[] args) {
        //1.创建线程（默认是前台线程）
        //主线程也属于前台线程
        DaemonThread d1=new DaemonThread();
        //设置线程为守护线程（后台线程）
        //前台线程执行完毕，后台线程自动结束
        d1.setDaemon(true);
        d1.start();

        for (int i = 0; i < 50; i++) {
            System.out.println(Thread.currentThread().getName()+"=========="+i);
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

5.线程安全问题

• 需求:A线程将“Hello”存入数组;B线程将“World”存入数组。
  • A线程查找到了下标0，但还没来得及将数据存放进去，时间片到期，然后B线程查找到下标0并将数据存放了进去，然后A线程继续执行，把数据存放到下标0处，出现了数据覆盖的问题。
• 多线程安全问题:
  • 当多线程并发访问临界资源时，如果破坏原子操作，可能会造成数据不一致。
  • 临界资源:共享资源(同一对象），一次仅允许一个线程使用，才可保证其正确性。
  • 原子操作:不可分割的多步操作，被视作一个整体，其顺序和步骤不可打乱或缺省。

/**
 * 线程安全问题示例代码
 * 两个线程同时向一个数组中存放数据
 */
public class ThreadSafe {
    private static int index=0;
    public static void main(String[] args) throws Exception{
        //创建数组
        String[] s=new String[5];
        //创建两个操作
        Runnable runnableA=new Runnable() {
            @Override
            public void run() {
                s[index]="hello";
                index++;
            }
        };
        Runnable runnableB=new Runnable() {
            @Override
            public void run() {
                s[index]="world";
                index++;
            }
        };
        //创建两个线程对象
        Thread t1=new Thread(runnableA,"A");
        Thread t2=new Thread(runnableB,"B");
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println(Arrays.toString(s));
    }
}

//执行结果
//[world, null, null, null, null]

5.1同步机制

5.1.1同步方式1：同步代码块

• //同步代码块
  synchronized(临界资源对象){//对临界资源对象加锁
      //代码（原子操作）
  }
  //注：
  	//每个对象都有一个互斥锁标记，用来分配给线程的。
  	//只有拥有对象互斥锁标记的线程，才能进入对该对象加锁的同步代码块。
  	//线程退出同步代码块时,会释放相应的互斥锁标记。
  
  

  /**
   * 线程安全问题
   * 两个线程同时向一个数组中存放数据
   */
  public class ThreadSafe {
      private static int index=0;
      public static void main(String[] args) throws Exception{
          //创建数组
          String[] s=new String[5];
          //创建两个操作
          Runnable runnableA=new Runnable() {
              @Override
              public void run() {
                  synchronized (s){
                      s[index]="hello";
                      index++;
                  }
              }
          };
          Runnable runnableB=new Runnable() {
              @Override
              public void run() {
                  synchronized (s){
                      s[index]="world";
                      index++;
                  }
              }
          };
          //创建两个线程对象
          Thread t1=new Thread(runnableA,"A");
          Thread t2=new Thread(runnableB,"B");
          t1.start();
          t2.start();
          t1.join();
          t2.join();
          System.out.println(Arrays.toString(s));
      }
  }
  //执行结果一定可以把hello和world写入数组，先后顺序不一定
  

  //使用同步代码块来优化：四个窗口一共卖100张票
  /**
   * 票类（共享资源类）
   */
  public class TicketWin2 implements Runnable{
      public int ticket=100;
      //创建锁
      private Object obj=new Object();
      @Override
      public void run() {
          while (true){
              synchronized (obj){//不可以使用synchronized (new Object)，因为在main进程中创建了四个进程，相当于创建了四把锁
                  //可以使用synchronized (this)，可以使用当前对象作为锁
                  if (ticket<=0){
                      break;
                  }
                  System.out.println(Thread.currentThread().getName()+"卖了第"+ticket+"张票");
                  ticket--;
              }
          }
      }
  }
  
  //测试类
  public class TestWin2 {
      public static void main(String[] args) {
          TicketWin2 tw1=new TicketWin2();
          Thread thread1=new Thread(tw1,"1号窗口");
          Thread thread2=new Thread(tw1,"2号窗口");
          Thread thread3=new Thread(tw1,"3号窗口");
          Thread thread4=new Thread(tw1,"4号窗口");
          thread1.start();
          thread2.start();
          thread3.start();
          thread4.start();
      }
  }
  

//使用同步代码块来优化：你和你女朋友共用一张银行卡，你向卡中存钱，你女朋友从卡中取钱,使用程序模拟过程：
/**
 * 银行卡类
 */
public class BankCard {
    private double money;

    public double getMoney() {
        return money;
    }

    public void setMoney(double money) {
        this.money = money;
    }
}

//存钱
public class AddMoney implements Runnable{
    private BankCard card;

    public AddMoney() {
    }

    public AddMoney(BankCard card) {
        this.card = card;
    }

    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            synchronized (card) {
                card.setMoney(card.getMoney() + 1000);
                System.out.println(Thread.currentThread().getName() + "存了1000，余额是：" + card.getMoney());
            }
        }
    }
}

//取钱
public class SubMoney implements Runnable{
    private BankCard card;

    public SubMoney() {
    }

    public SubMoney(BankCard card) {
        this.card = card;
    }

    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            synchronized (card){
            if (card.getMoney()>=1000) {
                card.setMoney(card.getMoney() - 1000);
                System.out.println(Thread.currentThread().getName() + "取了1000，余额是：" + card.getMoney());
            }else {
                System.out.println("余额不足");
                i--;
            }
            }
    }
}

//测试类
public class Test {
    public static void main(String[] args) {
        //1.创建一张银行卡
        BankCard bankCard=new BankCard();
        //2.创建存钱，取钱
        AddMoney add=new AddMoney(bankCard);//可以使用匿名内部类简化代码
        SubMoney sub=new SubMoney(bankCard);
        //3.创建线程
        Thread thread1=new Thread(add,"晨晨");//new Thread(add,"晨晨").start()
        Thread thread2=new Thread(sub,"冰冰");
        //4.启动线程
        thread1.start();
        thread2.start();
    }
}

5.1.2 同步方式2：同步方法

• 同步方法：

synchronized 返回值类型 方法名称 （形参列表）{//对当前对象（this）加锁
    //代码（原子操作）
}
注：只有拥有对象互斥锁标记的线程，才能进入该对象加锁的同步方法中。
    线程退出同步方法时,会释放相应的互斥锁标记。

//以四个窗口共卖100张票为例
/**
 * 票类（共享资源类）
 */
public class TicketWin2 implements Runnable{
    public int ticket=100;
    //创建锁
    private Object obj=new Object();
    @Override
    public void run() {
        while (true){
            if(!sale()){
                break;
            }         
            }
        }
    }
//同步方法：

    public synchronized boolean sale(){//锁是当前对象,this
//  public synchronized static boolean sale(){//锁是当前类，Ticket.class
        if (ticket<=0){
                    return false;
                }
                System.out.println(Thread.currentThread().getName()+"卖了第"+ticket+"张票");
                ticket--;
        		return true;
    }
}

//测试类
public class TestWin2 {
    public static void main(String[] args) {
        TicketWin2 tw1=new TicketWin2();
        Thread thread1=new Thread(tw1,"1号窗口");
        Thread thread2=new Thread(tw1,"2号窗口");
        Thread thread3=new Thread(tw1,"3号窗口");
        Thread thread4=new Thread(tw1,"4号窗口");
        thread1.start();
        thread2.start();
        thread3.start();
        thread4.start();
    }
}

5.2同步规则

• 注意:
  • 只有在调用包含同步代码块的方法，或者同步方法时，才需要对象的锁标记。
  • 如调用不包含同步代码块的方法，或普通方法时，则不需要锁标记，可直接调用。
• 已知JDK中线程安全的类:
  • StringBuffer
  • Vector
• Hashtable
  • 以上类中的公开方法,均为synchonized修饰的同步方法。

5.3死锁

• 死锁;

  • 当第一个线程拥有A对象锁标记，并等待B对象锁标记，同时第二个线程拥有B对象锁标记，并等待A对象锁标记时，产生死锁。
  • 一个线程可以同时拥有多个对象的锁标记，当线程阻塞时，不会释放已经拥有的锁标记，由此可能造成死锁。

  /**
   * 创建两个锁对象
   */
  public class MyLock {
      //两个锁
      public static Object a=new Object();
      public static Object b=new Object();
  }
  
  //男孩线程
  public class Boy extends Thread{
      @Override
      public void run() {
          synchronized (MyLock.a){
              System.out.println("男孩拿到了a");
              synchronized (MyLock.b){
                  System.out.println("男孩可以吃东西了");
              }
          }
      }
  }
  
  //女孩线程
  public class Girl extends Thread{
      @Override
      public void run() {
          synchronized (MyLock.b){
              System.out.println("女孩拿到了b");
              synchronized (MyLock.a){
                  System.out.println("女孩可以吃东西了");
              }
          }
      }
  }
  
  //测试类
  public class TestDeadLock {
      public static void main(String[] args) {
          Boy boy=new Boy();
          Girl girl=new Girl();
          boy.start();
          try {
              Thread.sleep(100);
          } catch (InterruptedException e) {
              e.printStackTrace();
          }
          girl.start();
      }
  }
  

5.4线程通信

• 等待:

public final void wait （）
public final void wait(long timeout)
//必须在对obj加锁的同步代码块中。在一个线程中，调用obj.wait() 时，此线程会释放其圳有的所有锁标记。同时此线程阻塞在o的等待队列中。释放锁，进入等待队列。

• 通知

public final void notify()//随机唤醒一个在等待队列中的线程
public final void notifyAll() //随机所有在等待队列中的线程

//银行卡类
public class BankCard {
    //余额
    private double money;
    private boolean flag=false;//true表示有钱，可以取钱；false表示没钱，可以存钱
    //存钱
    public synchronized void sava(double m){
        while (flag){//有钱
            try {
                this.wait();//进入等待队列，同时释放锁
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        money=money+m;
        System.out.println(Thread.currentThread().getName()+"存了"+m+"余额是"+money);
        //修改标记
        flag=true;
        //唤醒存钱线程
        this.notifyAll();
    }
    //取钱
    public synchronized void take(double m){
        while (!flag){//if（！flag）：只判断一次
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        money=money-m;
        System.out.println(Thread.currentThread().getName()+"取了"+m+"余额是"+money);
        //修改标记
        flag=false;
        //唤醒取钱线程
        this.notifyAll();//this.notify():只唤醒一个，多线程执行会出现死锁
    }
}

//存钱操作
public class AddMoney implements Runnable{
    private BankCard card=new BankCard();

    public AddMoney(BankCard card) {
        this.card = card;
    }

    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            card.sava(1000);
        }
    }
}

//取钱操作
public class SubMoney implements Runnable{
    private BankCard card=new BankCard();

    public SubMoney(BankCard card) {
        this.card = card;
    }

    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            card.take(1000);
        }
    }
}

//测试类
public class Test {
    public static void main(String[] args) {
        //1.创建银行卡
        BankCard card=new BankCard();
        //2.创建操作
        AddMoney add=new AddMoney(card);
        SubMoney sub=new SubMoney(card);
        //3.创建线程对象
        Thread chenchen=new Thread(add,"晨晨");
        Thread bingbing=new Thread(sub,"冰冰");
        Thread mingming=new Thread(add,"明明");
        Thread lili=new Thread(sub,"丽丽");
        //4.启动线程
        chenchen.start();
        bingbing.start();
        mingming.start();
        lili.start();
    }
}

• 生产者、消费者问题:

  若干个生产者在生产产品，这些产品将提供给若干个消费者去消费，为了使生产者和消费者能并发执行，在两者之间设置一个能存储多个产品的缓冲区，生产者将生产的产品放入缓冲区中，消费者从缓冲区中取走产品进行消费，显然生产者和消费者之间必须保持同步，即不允许消费者到一个空的缓冲区中取产品，也不允许生产者向一个满的缓冲区中放入产品。

//面包类
public class Bread {
    private int id;
    private String productName;

    public Bread() {
    }

    public Bread(int id, String productName) {
        this.id = id;
        this.productName = productName;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getProductName() {
        return productName;
    }

    public void setProductName(String productName) {
        this.productName = productName;
    }
}

//存放面包的数组
public class BreadCon {
    //存放面包的数组
    private Bread[] cons=new Bread[6];
    //存放面包的位置
    private int index=0;
    public synchronized void input(Bread b){//锁this
        //判断容器有没有满
        while (index>5){
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        cons[index]=b;
        System.out.println(Thread.currentThread().getName()+"生产了"+b.getId()+ "");
        index++;
        //唤醒
        this.notifyAll();
    }

    public synchronized void output(){//锁this
        //判断容器有没有满
        while (index<=0){
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        index--;
        Bread b=cons[index];
        System.out.println(Thread.currentThread().getName()+"消费了"+b.getId()+ "生产者:"+b.getProductName());
        cons[index]=null;
        //唤醒生产者
        this.notifyAll();
    }

}

//生产操作
public class Produce implements Runnable{
    private BreadCon breadCon;

    public Produce(BreadCon breadCon) {
        this.breadCon = breadCon;
    }

    @Override
    public void run() {
        for (int i = 0; i <6; i++) {
            breadCon.input(new Bread(i,Thread.currentThread().getName()));
        }
    }
}

//消费操作
public class Consume implements Runnable{
     private BreadCon breadCon;

    public Consume(BreadCon breadCon) {
        this.breadCon = breadCon;
    }

    @Override
    public void run() {
        for (int i = 0; i < 3; i++) {
            breadCon.output();
        }
    }
}

//测试类
public class Test {
    public static void main(String[] args) {
        //容器
        BreadCon breadCon=new BreadCon();
        //创建操作：生产和消费
        Produce produce=new Produce(breadCon);
        Consume consume=new Consume(breadCon);
        //创建生产者和消费者
        Thread thread1=new Thread(produce, "北京的生产者");
        Thread thread2=new Thread(produce, "上海的生产者");
        Thread thread3=new Thread(consume, "南京的消费者");
        Thread thread4=new Thread(consume, "天津的消费者");
        Thread thread5=new Thread(consume, "太原的消费者");

        //启动线程
        thread1.start();
        thread2.start();
        thread3.start();
        thread4.start();
        thread5.start();

    }
}

多线程学习

原文：https://www.cnblogs.com/Ng3061851/p/14946380.html