Java复习07

1. 进程

   进程是正在运行的程序

   • 是系统资源分配和调用的独立单位
   • 每个过程都有自己的内存空间和系统资源

2. 线程

   线程是过程中的单个顺序控制流，是执行路径

   • 单线程：如果一个过程只有一个执行路径，则称为但线程序
   • 多线程：如果一个过程有多个执行路径，则称为多线程序

3. 实现多线程的方法

   方式1：继承Thread类

   • 定义一个类MyThread继承Thread类

   • 在MyThread类中重写run()方法

   • 创建MyThread类的对象

   • 启动线程

   两个小问题：

   • 为什么要重写？run()方法？

     因为run()用于包装被线程执行的代码

   • run()方法和start()方法的差异

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

     start():启动线程，然后通过JVM调用此线程run()方法

4. 设置和获取线程名称

   Thread设置和获取线程名称的方法

   • void setName(String name)：将该线程的名称更改为参数name
   • String getName():返回此线程的名称
   • 线程名也可以通过方法设置

package itheima02;  public class MyThread extends Thread {     @Override     public void run() {         for (int i = 0; i < 100; i  ) {             System.out.println(getName()   ":"   i);         }     } }  /*      private String name;      public Thread() {         init(null, null, "Thread-"   nextThreadNum(), 0);     }      public Thread(ThreadGroup group, Runnable target, String name, long stackSize) {         this(goup, target, name, stackSize, null ,true);     }      private Thread(ThreadGroup g, Runnable target, String name, long stackSize, AccessControlContext acc, boolean inheritYhreadLocals){         this.name=name;           public final String getName() {         return new String(name, true);     }       private static int threadInitNumber;    //从0开始     private static synchronized int nextThreadNum() {         return threadInitNumber  ;     }  */ 

package itheima02;  public class MyThreadDemo {     public static void main(String[] args) {         MyThread my1 = new MyThread();         MyThread my2 = new MyThread();          my1.setName("gaotie");         my2.setName("feiji");          my1.start();         my2.start();     } } 

package itheima02; /*     Thread 获取和设置线程名称的方法         1.         void setName(String name):将该线程的名称更改为等一参数name         String getName():返回此线程的名称  */  public class MyThreadDemo {     public static void main(String[] args) {        /*         MyThread my1 = new MyThread();         MyThread my2 = new MyThread();          //2. 线程名称采用带参结构法设置，也是通过getName()获取值         my1.setName("gaotie");//如果要用这种方法给线程命名，必须在定义类中提供带参法，并通过super访问父类代餐结构的方法         my2.setName("feiji");*/   //        MyThread my1 = new MyThread(); //        MyThread my2 = new MyThread(); // //        my1.start(); //        my2.start();          //static Thread currentThread() 返回引用正在执行的线程对象 //        System.out.println(getName()；//现在main()方法没有继承Thread不能调用getName()获取线程名         //3. static Thread currentThread() 返回引用当前正在执行的线程对象 --- 静态方法 获得线程对象，调用线程对象getName()获取线程名称         System.out.println(Thread.currentThread().getName()main，当前的方法是在一个名称中main执行的线程      } } 

如何获取main)()方法所在的线程名称？

• public static Thread currentThread():返回引用正在执行的当前线程对象

5. 线程调度

   线程有两种调度模型

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

   Java抢占抢占调度模型

   假设只有一台电脑CPU，那么CPU一个指令只能在某个时刻执行，线程只能获得CPU时间片，即试用权，可以执行指令。因此，多线程序的执行是随机的，因为谁抓住了它CPU试用期不一定。

   Thread设置和获取线程优先级的方法

   • public final int getPriority():返回此线程的优先级
   • public final void setPriority(int newPriority):更改此线程的优先级

package itheima03;  public class ThreadPriorityDemo {     public static void main(String[] args) {         ThreadPriority tp1 = new ThreadPriority();         ThreadPriority tp2 = new ThreadPriority();         ThreadPriority tp3 = new ThreadPriority();          tp1.setName("gaotie");         tp2.setName("feiji");         tp3.setName("qiche");          //public final int getPriority()：返回此线程的优先级         System.out.println(tp1.getPriority()；//5         System.out.println(tp2.getPriority()；//5         System.out.println(tp3.getPriority()；//5  默认情况下，这三个线程的优先级为5          // public final void setPriority(int newPriority):更改此线程的优先级 //        tp1.setPriority(10000);// IlegalArgumentException - 优先级不在MIN_PRIOORITY到MAX_PRIOTRITY范围内

        System.out.println(Thread.MAX_PRIORITY);// 10
        System.out.println(Thread.MIN_PRIORITY);// 1
        System.out.println(Thread.NORM_PRIORITY);// 5

        //设置正确的优先级
        tp1.setPriority(5);
        tp2.setPriority(10);
        tp3.setPriority(1);
        //线程优先级高仅仅代表该线程获取CPU的机率高

        tp1.start();
        tp2.start();
        tp3.start();

    }
}

​ 线程默认优先级是5，线程优先级的范围是：1-10

​ 线程优先级高仅仅表示线程获取的CPU时间片的机率高，但是要在次数比较多，或者多次运行的时候才能看到你想要的效果

6. 线程控制

   方法名	说明
   static void sleep(long millis)	使当前正在执行的线程停留（暂停执行）指定的毫秒数
   void join()	等待这个线程死亡
   void setDaemon(boolean on)	将此线程标记为守护线程，当运行的线程都是守护线程时，Java虚拟机将退出

   package itheima03;
   
   public class ThreadJoinDemo {
       public static void main(String[] args) {
           ThreadJoin tj1 = new ThreadJoin();
           ThreadJoin tj2 = new ThreadJoin();
           ThreadJoin tj3 = new ThreadJoin();
   
           tj1.setName("康熙");
           tj2.setName("四阿哥");
           tj3.setName("八阿哥");
   
           tj1.start();
           try {
               tj1.join();
           } catch (InterruptedException e) {
               e.printStackTrace();
           }
           //第一个线程执行完后后两个线程才开始执行
           tj2.start();
           tj3.start();
   
       }
   }
   

   package itheima03;
   /*
       void setDaemon(boolean on): 将此线程标记为守护线程，当运行的线程都是守护线程时，Java虚拟机将退出
    */
   
   public class ThreadDeamonDemo {
       public static void main(String[] args) {
           ThreadDeamon td1 = new ThreadDeamon();
           ThreadDeamon td2 = new ThreadDeamon();
   
           td1.setName("关羽");
           td2.setName("张飞");
   
           //设置主线程为刘备
           Thread.currentThread().setName("刘备");
   
           //设置守护线程，当主线程结束时，两个守护线程也应当结束
           td1.setDaemon(true);
           td2.setDaemon(true);
   
           td1.start();
           td2.start();
   
           for (int i = 0; i < 10; i++) {
               System.out.println(Thread.currentThread().getName() + ":" + i);
           }
       }
   }
   

7. 线程生命周期

   

8. 多线程的实现方式

   方式2：实现Runnable接口

   • 定义一个类MyRunnable实现Runnable接口
   • 在MyRunnable类中重写run()方法
   • 创建MyRunnable类的对象
   • 创建Thread类的对象，把MyRunnable对象作为构造方法的参数
   • 启动线程

   多线程的实现方案有两种

   • 继承Thread类
   • 实现Runnable接口

   相比继承Thread类，实现Runnable接口的好处

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

案例：卖票

需求：某电影院目前正在上映国产大片，共有100张票，而它有3个窗口卖票，请设计一个程序模拟该电影院卖票

思路：

1. ​ 生产者消费者模式概述

   生产者消费者模式是一个十分经典的多线程协作的模式，弄懂生产者消费者问题能够让我们对多线程变成的理解更加深刻

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

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

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

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

   为了体现生产和消费过程中的等待和唤醒，Java就提供了几个方法供我们使用，这几个方法在Object类中

   Object类的等待和唤醒方法：

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

   2. 生产者消费者案例

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

      • 奶箱类(Box):定义一个成员变量，表示第x瓶奶，提供存储牛奶和获取牛奶的操作
      • 生产者类(Producer):实现Runnable接口，重写run()方法，调用存储牛奶的操作
      • 消费者类(Customer):实现Runnable接口，重写run()方法，调用获取牛奶的操作
      • 测试类(BoxDemo):里面有main方法，main()方法中的代码步骤如下
        1. 创建奶箱对象，这是共享数据区域
        2. 创建生产者对象，把奶箱对象作为构造方法参数传递，因为这个类中要调用存储牛奶的操作
        3. 创建消费者对象，把奶箱对象作为构造方法传递参数，因为这个类中要调用获取牛奶的操作
        4. 创建两个线程对象，分别把生产者对象和消费者对象作为构造方法参数传递
        5. 启动线程

      package itheima08;
      
      public class BoxDemo { 
                  
          public static void main(String[] args) { 
                  
              //创建奶箱对象，这是共享数据区域
              Box b = new Box();
      
              //创建生产者对象，把奶箱对象作为构造方法参数传递，因为这个类中要调用存储牛奶的操作
              Producer p = new Producer(b);
      
              //创建消费者对象，把奶箱对象作为构造方法传递参数，因为这个类中要调用获取牛奶的操作
              Customer c = new Customer(b);
      
              //创建两个线程对象，分别把生产者对象和消费者对象作为构造方法参数传递
              Thread t1 = new Thread(p);
              Thread t2 = new Thread(c);
      
              //启动线程
              t1.start();
              t2.start();
              //运行结果用户一直在拿第5瓶奶
      
          }
      }
      

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

   package itheima08;
   
   public class Producer implements Runnable { 
             
       private Box b;
   
       public Producer(Box b) { 
             
           this.b = b;
       }
   
       @Override
       public void run() { 
             
           for (int i = 1; i <= 5; i++) { 
             
               b.put(i);
           }
       }
   }
   

   package itheima08;
   
   public class Customer implements Runnable { 
             
       private Box b;
   
       public Customer(Box b) { 
             
           this.b = b;
       }
   
       @Override
       public void run() { 
             
           while (true) { 
             
               b.get();
           }
       }
   }
   

(“用户拿到第” + this.milk + “瓶奶”);

       //消费完毕后，此修改奶箱状态
       state = false;

       //唤醒其他等待的线程
       notifyAll();
   }

}

```java 
package itheima08;

public class Producer implements Runnable {
    private Box b;

    public Producer(Box b) {
        this.b = b;
    }

    @Override
    public void run() {
        for (int i = 1; i <= 5; i++) {
            b.put(i);
        }
    }
}

package itheima08;

public class Customer implements Runnable { 
        
    private Box b;

    public Customer(Box b) { 
        
        this.b = b;
    }

    @Override
    public void run() { 
        
        while (true) { 
        
            b.get();
        }
    }
}