多线程

基本概念

  • 程序：为完成特定任务、用某种语言编写的一组指令的集合。即指一段静态的代码，静态对象。

  • 进程：程序的一次执行过程，或是正在运行的一个程序。是一个动态的过程：它有自身的产生、存在和消亡。——生命周期

    • 程序是静态的，进程是动态的。
    • 进程作为资源分配的单位，系统在运行时会为每个进程分配不同的内存区域。

  • 线程：进程可进一步细化为线程，是一个程序内部的一条执行路径。

    • 若一个进程同时执行多个线程，就是支持多线程的。
    • 线程作为调度和执行的单位，每个线程拥有独立的运行栈和程序计数器，线程切换的开销小。

  • 并行与并发

    • 并行：多个CPU同时执行多个任务。
    • 并发：一个CPU同时执行多个任务。

线程的创建和使用

  • Java语言的JVM允许程序运行多个线程，它通过Java.lang.Thread类来体现。

  • Thread类的特性

    • 每个线程都是通过某个特定Thread对象的run()方法来完成操作的，经常把run()方法的主题称为线程体。
    • 通过Thread对象的start()方法来启动这个线程，而非直接调用run()。

代码练习：

  1. package day01;
  3. /**
  4.  * 多线程的创建，方式一：继承鱼=于Thread类
  5.  *1.创建一个继承于Thread类的子类
  6.  * 2.重写Thread类的run() --->将此线程执行的操作声明在run()中
  7.  * 3.创建Thread类的子类的对象
  8.  * 4.通过此对象调用strat()
  9.  *
  10.  */
  13. //1.创建一个继承于Thread类的子类
  14.     class MyThread extends Thread{
  15.         //2.重写Thread类的run()
  16.         @Override
  17.         public void run() {
  18.             for (int i = 0; i < 100; i++) {
  19.                 if (i%2==0)
  20.                     System.out.println(Thread.currentThread().getName()+":"+i);
  21.             }
  22.         }
  23. }
  26. public class ThreadTest {
  28.     public static void main(String[] args) {
  29.         //3.创建Thread类的子类对象
  30.         MyThread myThread = new MyThread();
  31.         //4.调用start()
  32.         myThread.start();
  33.         //问题一：我们不能通过直接调用run()的方式启动线程，这样没有创建多线程，只是使用了对象。
  34.       // myThread.run();
  36.         //问题二：再启动一个线程，遍历一百以内的偶数。会报错，原因是不可以让已经start()的线程去执行。需要通过新建一个对象去实现。
  37.        // myThread.start();
  38.         MyThread myThread1 = new MyThread();
  39.         myThread1.start();
  41.         //main方法中的主线程
  42.         for (int i = 0; i < 100; i++) {
  43.             if (i%2==0)
  44.                 System.out.println(Thread.currentThread().getName()+":"+i);
  45.         }
  46.     }
  47. }

  • Thread类的有关方法

    • void start():启动线程，并执行对象的run()方法。
    • run()：线程在被调度时执行的操作。
    • String getName():返回线程的名称。
    • void setName(String name):设置该线程名称。
    • static Thread currentThread():返回当前线程。在Thread子类中就是this，通常用于主线程和Runnable实现类。

    • static void yield():线程让步。

      • 暂停当前正在执行的线程，把执行机会让给优先级相同或更高的线程。
      • 若队列中没有同优先级的线程，忽略此方法。

    • join():当某个程序执行流中调用其他线程的join()方法时，调用线程将被阻塞，直到join()方法加入的join线程执行完为止。

      • 低优先级的线程也可以获得执行。

    • static void sleep(long millis):(指定时间：毫秒)

      • 令当前活动线程在指定时间段内放弃对CPU控制，使其他线程有机会被执行，时间到后重排队。
      • 抛出IntettuptedException异常。
    • stop():强制线程生命期结束，不推荐使用。
    • boolean isAlive():返回boolean，判断线程是否还活着。

  • 线程的调度：

    • 调度策略

      • 时间片。
      • 抢占式：高优先级的线程抢占CPU。

    • Java的调度方法：

      • 同优先级线程组成先进先出队列（先到先服务），使用时间片策略。
      • 对高优先级，使用优先调度的抢占式策略。

  • 线程的优先级：

    • 线程的优先级等级：

      • MAX_PRIORITY:10

      • MIN_PRIORITY:1

        • NORM_PRIORITY:5 默认的优先级值

    • 涉及到的方法：

      • getPriority():返回线程的优先值。
      • setPriority(int newPriority):改变线程的优先级。

    • 说明：

      • 线程创建时继承父线程的优先级。
      • 低优先级只是获得调度的概率低，并非一定是在高优先级线程之后才被调用。
  • 代码练习：
  1. package day01;
  5. class MyThreadTest extends Thread{
  6.     @Override
  7.     public void run() {
  8.         for (int i = 0; i < 100; i++) {
  9.             if (i%2==0)
  10.                 System.out.println(Thread.currentThread().getName()+":"+getPriority()+":"+i);
  11. //            if (i%20==0)
  12. //                this.yield();
  13.         }
  14.     }
  15. }
  16. public class ThreadMethodTest {
  17.     public static void main(String[] args) {
  18.         MyThreadTest myThread = new MyThreadTest();
  20.         //设置分线程的名字
  21.         myThread.setName("线程1：遍历100以内的偶数");
  22.         //设置分线程的优先级
  23.        myThread.setPriority(Thread.MAX_PRIORITY);
  24.         myThread.start();
  27.         //给主线程命名
  28.         Thread.currentThread().setName("主线程：遍历100以内的奇数");   //获取当前主线程
  29.         Thread.currentThread().setPriority(Thread.MIN_PRIORITY);
  30.         for (int i = 0; i < 100; i++) {
  31.             if (i%2!=0)
  32.                 System.out.println(Thread.currentThread().getName()+":"+Thread.currentThread().getPriority()+":"+i);
  33.         }
  34.         System.out.println(myThread.isAlive());
  35.     }
  36. }

  • 创建线程的方式二：实现Runnable接口

    • 创建一个实现了Runnable接口的类。

    • 实现类去实现Runnable中的抽象方法：run()。

    • 创建实现类的对象。

    • 将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象。

    • 通过Thread类的对象调用start()。

    • 代码练习

    • ```java package day01;

class MThread1 implements Runnable{ @Override public void run() { for (int i = 0; i < 100; i++) { if (i%2==0) System.out.println(i); } } } public class MThread { public static void main(String[] args) { MThread1 mThread1 = new MThread1(); Thread thread = new Thread(mThread1); thread.start(); } }

  3. - 
  4. 创建线程的两种方式的比较：
  6.    - 开发中优先选择实现Runnable接口的方式。
  7.    - 原因：
  9.       - 实现的方式没有类的单继承性的局限性。
  10.       - 实现的方式更适合来处理多个线程有共享数据的情况。
  12. ---
  14. <a name="c32ea57d"></a>
  15. ## 线程的生命周期
  17. - 线程生命周期的五种状态：
  19.    - 新建：当一个Thread类或其子类的对象被声明并创建时，新生的线程对象处于新建状态。
  20.    - 就绪：处于新建状态的线程被start()后，将进入线程队列等待CPU时间片，此时它已具备了运行的条件，只是没分配到CPU资源。
  21.    - 运行：当就绪的线程被调度并获得CPU资源时，便进入运行状态，run()方法定义了线程的操作和功能。
  22.    - 阻塞：在某种特俗情况下，被人为挂起或执行输入输出操作时，让出CPU并临时中止自己的执行，进入阻塞状态。
  23.    - 死亡：线程完成了它的全部工作或线程被提前强制性中止或出现异常导致结束。
  25. <a name="4de0e2ae"></a>
  26. ## 线程的同步
  28. - 
  29. Java通过同步机制来解决线程的安全问题。
  31. - 
  32. 方式一：同步代码块
  34.    - 
  35. ```java
  36. synchronized(同步监视器){
  37.     //需要被同步的代码
  38. }

  • 说明：

    • 操作共享数据的代码，即为需要被同步的代码。
    • 共享数据：多个线程共同操作的变量。
    • 同步监视器：俗称：锁。任何一个类的对象都可以充当锁。要求：多个线程必须共用同一把锁。
  • 代码练习： ```java package dayTest;

/**

  • 例子：创建三个窗口卖票，总票数为100张 *
  • 问题：卖票过程中出现了重票和错票。
  • 问题出现的原因：当某个线程操作车票的过程中，尚未完成操作时，其他线程参与进来，也操作车票。
  • 如何解决：当一个线程操作车票时，其他线程不能参与进来。直到该线程操作完成，其他线程才被允许操作车票。
  • 在Java中，通过同步机制来解决线程的安全问题。 */

class Window implements Runnable{

  1. private  int ticket=100;
  2. Object obj=new Object();
  4. @Override
  5. public void run() {
  7.     while (true){
  8.         synchronized (obj){
  9.             if (ticket>0){
  10.                 try {
  11.                     Thread.sleep(10);
  12.                 } catch (InterruptedException e) {
  13.                     e.printStackTrace();
  14.                 }
  15.                 System.out.println(Thread.currentThread().getName()+":卖票，票号为："+ticket);
  16.                 ticket--;
  17.             }else break;
  18.         }
  19.     }
  20. }

} public class WindowTest { public static void main(String[] args) { Window w = new Window();

  1.     Thread w1 = new Thread(w);
  2.     Thread w2 = new Thread(w);
  3.     Thread w3 = new Thread(w);
  5.     //给线程命名
  6.     w2.setName("窗口二");
  7.     w1.setName("窗口一");
  8.     w3.setName("窗口三");
  10.     //给线程设定优先级

// w1.setPriority(Thread.MAX_PRIORITY); // w2.setPriority(Thread.MIN_PRIORITY); // w3.setPriority(Thread.NORM_PRIORITY);

  1.     //执行线程
  2.     w1.start();
  3.     w2.start();
  4.     w3.start();
  5. }

}

  3. - 
  4. 方式二：同步方法
  6.    - 
  7. 如果操作共享数据的代码完整的声明在一个方法中，我们不妨将此方法声明同步。
  9.    - 
  10. 代码练习：
  11. ```java
  12. package dayTest;
  14. /**
  15.  * 使用同步方法解决实现Runnable接口的线程安全问题
  16.  */
  17. class Window1 implements Runnable{
  18.     private  int ticket=100;
  19.     Object obj=new Object();
  20.     @Override
  21.     public void run() {
  22.         while (true){
  23.             show();
  24.         }
  25.     }
  27.     private synchronized void show(){
  28.             if (ticket>0){
  29.                 try {
  30.                     Thread.sleep(10);
  31.                 } catch (InterruptedException e) {
  32.                     e.printStackTrace();
  33.                 }
  34.                 System.out.println(Thread.currentThread().getName()+":卖票，票号为："+ticket);
  35.                 ticket--;
  36.             }
  37.         }
  38.     }
  41. public class WindowTest1 {
  42.     public static void main(String[] args) {
  43.         Window w = new Window();
  45.         Thread w1 = new Thread(w);
  46.         Thread w2 = new Thread(w);
  47.         Thread w3 = new Thread(w);
  49.         //给线程命名
  50.         w2.setName("窗口二");
  51.         w1.setName("窗口一");
  52.         w3.setName("窗口三");
  54.         //给线程设定优先级
  55. //        w1.setPriority(Thread.MAX_PRIORITY);
  56. //        w2.setPriority(Thread.MIN_PRIORITY);
  57. //        w3.setPriority(Thread.NORM_PRIORITY);
  59.         //执行线程
  60.         w1.start();
  61.         w2.start();
  62.         w3.start();
  63.     }
  64. }

  • 线程的死锁问题

    • 不同的线程分别占用对方需要的同步资源不放弃，都在等待对方放弃自己需要的同步资源，就形成了线程的死锁。
    • 出现死锁后不会出现异常，不会出现提示，只是所有的线程都处于阻塞状态，无法继续。

  • 解决方法

    • 专门的算法。
    • 尽量减少同步资源的定义。
    • 尽量避免嵌套同步。

  • Lock锁

    • 从JDK5.0开始，Java提供了更强大的线程同步机制——通过定义同步锁对象来实现同步。同步锁使用Lock对象充当。

    • java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行访问的工具。锁提供了对共享资源的独占访问，每次只能有一个线程对Lock对象加锁，线程开始访问共享资源之前应先获得Lock对象。

    • ReentrantLock类实现了Lock，它拥有与synchronized相同的并发性和内存语义，在实现线程安全的控制中，比较常用的是ReentrantLock，可以显示加锁、释放锁。

    • 代码练习： ```java package day01;

import java.util.concurrent.locks.ReentrantLock;

class Window implements Runnable{ private int ticket=100;

  1. //创建对象
  2. private ReentrantLock lock=new ReentrantLock();
  4. @Override
  5. public void run() {
  6.     while (true){
  7.         try {
  8.             //调用lock
  9.             lock.lock();
  12.             if (ticket>0){
  13.                 try {
  14.                     Thread.sleep(100);
  15.                 } catch (InterruptedException e) {
  16.                     e.printStackTrace();
  17.                 }
  18.                 System.out.println(Thread.currentThread().getName()+":售票，票号为："+ticket);
  19.                 ticket--;
  20.             }else break;
  21.         }
  22.         finally {
  23.             //解锁
  24.             lock.unlock();
  25.         }
  26.     }
  27. }

} public class LockTest { public static void main(String[] args) { Window window = new Window();

  1.     Thread w1=new Thread(window);
  2.     Thread w2=new Thread(window);
  3.     Thread w3=new Thread(window);
  5.     w1.setName("窗口一");
  6.     w2.setName("窗口二");
  7.     w3.setName("窗口三");
  9.     w1.start();
  10.     w2.start();
  11.     w3.start();
  12. }

}

  3. - 
  4. synchronized与Lock的异同
  6.    - 相同点：二者都可以解决线程安全问题。
  7.    - 不同点：前者是执行完相应的同步代码之后自动释放同步监视器，后者是手动的启动同步和释放。
  9. ---
  11. <a name="ffc5004b"></a>
  12. ## 线程的通信
  14. - 
  15. 线程通信的三个方法
  17.    - 
  18. wait():一旦执行此方法，当前线程就进入阻塞状态，并释放同步监视器。
  20.    - 
  21. notify()：一旦执行此方法，就会唤醒被wait的一个线程。如果有多个线程被wait，就唤醒优先级高的那个。
  23.    - 
  24. notifyAll()：一旦执行此方法，就会唤醒所有被wait的线程。
  26.       - 说明
  28.          - 三个方法必须使用在同步代码块或者同步方法中
  29.          - 三个方法的调用者必须是同步代码块或同步方法中的同步监视器。
  30.    - 
  31. 代码练习：
  32. ```java
  33. package day01;
  35. /**
  36.  * 线程通信的例子：使用两个线程打印1-100.线程1，线程2交替打印。
  37.  */
  39. class Number implements Runnable{
  40.     private int number=1;
  41.     @Override
  42.     public void run() {
  45.             while (true){
  46.                 synchronized (this){
  47.                     notify();
  48.                 if (number<=100){
  49.                     System.out.println(Thread.currentThread().getName()+"："+number);
  50.                     number++;
  51.                     try {
  52.                         wait();
  53.                     } catch (InterruptedException e) {
  54.                         e.printStackTrace();
  55.                     }
  56.                 }else break;
  57.             }
  58.         }
  59.     }
  60. }
  62. public class CommunicationTest {
  63.     public static void main(String[] args) {
  64.         Number number = new Number();
  65.         Thread n1 = new Thread(number);
  66.         Thread n2 = new Thread(number);
  68.         n1.setName("线程1");
  69.         n2.setName("线程2");
  71.         n1.start();
  72.         n2.start();
  73.     }
  74. }

sleep()和wait()的异同

  • 相同点：一旦执行方法，都可以使得当前线程进入阻塞状态，

  • 不同点

    • 两个方法声明的位置不同：Thread类中声明sleep()，Object类中声明wait()。
    • 调用的要求不同：sleep()可以在任何需要的场景下调用。wait()必须使用在同步代码块或同步方法之中。
    • 关于是否释放同步监视器：如果两个方法都使用在同步代码块或同步方法中，sleep()不释放同步监视器，wait()释放同步监视器。

生产者消费者问题

代码演示：

  1. package day01;
  3. /**
  4.  * 线程通信的应用：经典例题：生产者、消费者问题
  5.  * 生产者将产品交给店员，而消费者从店员处取走产品，店员一次只能持有固定数量的产品（比如：20），如果生产者试图
  6.  * 生产更多的产品，店员会叫生产者停一下，如果店中有空位放产品了再通知生产者继续生产；如果店中没有产品了，店员会
  7.  * 告诉消费者等一下，如果店中有产品了再通知消费者来取走产品。
  8.  */
  11. class Clerk{
  13.     private int productCount=0;
  14.     //生产产品
  15.     public synchronized void produceProduct() {
  16.         if (productCount<20){
  17.             productCount++;
  18.             System.out.println(Thread.currentThread().getName()+"：开始生产第"+productCount+"个产品");
  20.             notify();
  21.         }
  22.         else {
  23.             //等待
  24.             try {
  25.                 wait();
  26.             } catch (InterruptedException e) {
  27.                 e.printStackTrace();
  28.             }
  29.         }
  30.     }
  32.     //消费产品
  33.     public synchronized void consumeProduct() {
  34.         if (productCount>0){
  35.             System.out.println(Thread.currentThread().getName()+":开始消费第"+productCount+"个产品");
  36.             productCount--;
  37.             notify();
  38.         }else {
  39.             //等待
  40.             try {
  41.                 wait();
  42.             } catch (InterruptedException e) {
  43.                 e.printStackTrace();
  44.             }
  45.         }
  46.     }
  47. }
  49. class Producer extends Thread{//生产者
  50.     private Clerk clerk;
  52.     public Producer(Clerk clerk) {
  53.         this.clerk = clerk;
  54.     }
  56.     @Override
  57.     public void run() {
  58.         System.out.println(getName()+"：开始生产产品······");
  60.         while (true){
  62.             try {
  63.                 Thread.sleep(50);
  64.             } catch (InterruptedException e) {
  65.                 e.printStackTrace();
  66.             }
  68.             clerk.produceProduct();
  69.         }
  70.     }
  71. }
  73. class Consumer extends Thread{//消费者
  74.     private Clerk clerk;
  76.     public Consumer(Clerk clerk) {
  77.         this.clerk = clerk;
  78.     }
  80.     @Override
  81.     public void run() {
  82.         System.out.println(getName()+"：开始消费产品·····");
  84.         while (true){
  86.             try {
  87.                 Thread.sleep(100);
  88.             } catch (InterruptedException e) {
  89.                 e.printStackTrace();
  90.             }
  92.             clerk.consumeProduct();
  93.         }
  94.     }
  95. }
  98. public class ProductTest {
  99.     public static void main(String[] args) {
  100.         Clerk clerk = new Clerk();
  102.         Producer p1 = new Producer(clerk);
  103.         p1.setName("生产者1");
  105.         Consumer c1 = new Consumer(clerk);
  106.         c1.setName("消费者1");
  108.         p1.start();
  109.         c1.start();
  110.     }
  111. }

饿汉式和懒汉式