【JavaSE】多线程Part2（12）

引言

• 健身平台期来的有点早~
• 一个全民狂热，盲目服从的社会是最可怕的

知识点总结

线程的状态

线程的生命周期中有五种运行状态

• New
• Runnable
• Blocked
• Terminated
• Waited
  (老师的图，自己画的太丑了·~~)
  

线程通信

多个线程处理同一资源，但是进行的任务却不相同。
下面以早餐买包子为例介绍：

本例包含四个类
1.资源类
   Baozi.java
2.包子铺
   Merchat.java
3.顾客
   Foodie.java
4.测试类
   TestMain.java

资源类(包子)

public class BaoZi {
       String pi;
       //包子皮
       String xian;
       //包子馅
      boolean state=false;
      //包子是否做好
}

包子铺

包子铺的任务
  1.先判断包子还有没有，有的话就等待，等顾客吃完；
  2.包子没有了，就开始做，做好之后给顾客吃；

public class Merchat extends Thread{
    private BaoZi bz;
    //以包子作为锁的对象，能够避免线程安全问题
    public Merchat(BaoZi bz){
        this.bz=bz;
    }
       public void run()  {
            int count=0;
           while(true){
               synchronized (bz){
               //保证锁的参数对象为同一个
                   if(bz.state==true){
                       try {
                           bz.wait();
                       } catch (InterruptedException e) {
                           e.printStackTrace();
                       }
                   }

                 if(count%2==0){
                     bz.xian="🐕肉馅";bz.pi="厚皮";
                 }
                 else {
                     bz.xian = "🐖肉馅";
                     bz.pi = "薄皮";
                 }
                 count++;
                 System.out.println("包子铺正在做包子嘞~，做的是"+bz.pi+bz.xian+"大包子");
                   try {
                       Thread.sleep(3000);
                   } catch (InterruptedException e) {
                       e.printStackTrace();
                   }
                   bz.state=true;
                  bz.notify();
                   System.out.println("包子做好了");
               }
           }
       }
}

顾客类

顾客的任务
  1.顾客问老板还有包子吗，没有的话就等包子铺做；
  2.包子有的时候开始吃，吃完了让包子铺做；

public class Foodie extends Thread{
     private BaoZi bz;
     public Foodie(BaoZi BZ){
         this.bz=BZ;
     }
     @Override
      public void run(){
          while(true){
               synchronized (bz){
                   if(bz.state==false){
                       try {
                           bz.wait();
                       } catch (InterruptedException e) {
                           e.printStackTrace();
                       }
                   }
                 System.out.println("我正在吃"+bz.pi+bz.xian+"的大包子");
                  bz.state=false;
                  bz.notify();
                   System.out.println("我吃完了，老板再来一个");
                   System.out.println("-----------------------------");
               }
          }
      }
}

测试类

public class TestMain {
    public static void main(String[] args) {
        BaoZi bz=new BaoZi();
        //为两个线程的锁传递同一个对象；
        new Foodie(bz).start();
        new Merchat(bz).start();
    }
}

线程池

线程池就是一个存放线程的集合，线程被调用之后，不会被销毁，而是重新回到集合中；这样可以降低线程多次创建和毁坏后的消耗。

Executors创建线程池

Executors中的.**newFixedThreadPool(length)**返回的是ExecutorService的一个实现类，是一个固定长度的线程池；其中length是线程池的长度。
其中submit()方法是提交一个可执行的任务执行。

public class Demo01 {
    public static void main(String[] args) {
        ExecutorService es=Executors.newFixedThreadPool(2);
        //创建一个长度为2的线程池
        for (int i = 0; i < 10; i++) {
            es.submit(new Runnableimpl());
        }
    }
}
==========================
Runnnableimpl.java
--------------------
public class Runnableimpl implements Runnable {
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"正在执行");
    }
}

从运行结果中我们可以看到，10个任务只有两个线程在执行。