Java基础知识---多线程

版权声明：本文为小斑马伟原创文章，转载请注明出处！

多线程的内容主要包含以下主要五大模块：

• 1 程序、进程、线程的概念
• 2 Java中多线程的创建和使用
• 3 线程的生命周期
• 4 线程的同步
• 5 线程的通信

一、基本概念：程序-进程-线程

-> 程序(program):是为完成特定任务、用某种语言编写的一组指令的集合。即指一段静态的代码，静态对象。
-> 进程(process):是程序的一次执行过程，或是正在运行的一个程序。动态过程：有它自身的产生、存在和消亡的过程。如：运行中的QQ，运行中的MP3播放器。程序是静态的，进程是动态的。
-> 线程(thread):进程可进一步细化为线程，是一个程序内部的一条执行路径。
若一个程序可同一时间执行多个线程，就是支持多线程的

进程与多进程

每个Java程序都有一个隐含的主线程： main 方法。

何时需要多线程

• 1 程序需要同时执行两个或多个任务。
• 2 程序需要实现一些需要等待的任务时，如用户输入、文件读写操作、网络操作、搜索等。
• 3 需要一些后台运行的程序时。

二、线程的创建和启动

Java语言的JVM允许程序运行多个线程，它通过java.lang.Thread类来实现。Thread类的特性：每个线程都是通过某个特定Thread对象的run()方法来完成操作的，经常把run()方法的主体称为线程体。通过该Thread对象的start()方法来调用这个线程。

创建线程的两种方式

1.继承Thread类

  class SubThread extends Thread {
      static Object obj = new Object();
     //2.重写Thread类的run()方法。方法内实现此子线程要完成的功能
      public void run() {
           synchronized (obj) {
              for(int i = 1; i <= 100; i++) {
                 System.out.println(Thread.currentThread().getName()+"i:="+i);
              }
          }
         //show();
      }

      private  synchronized void show() { //this充当为锁 错误
           for(int i = 1; i <= 100; i++) {
              System.out.println(Thread.currentThread().getName()+"i:="+i);
           }
     }
  }

  public class TestThread {
      public static void main(String[] args) {
          //3.创建一个子类的对象
          SubThread st = new SubThread();
         //4.调用线程的start():启动此线程；调用相应的run()方法
          st.setName("子线程1");
          st.setPriority(Thread.MAX_PRIORITY);
          st.start();
          Thread.currentThread().setName("====主线程");
          for(int i = 1; i <= 100; i++) {
              if(i % 10 == 0) {
                  Thread.currentThread().yield(); //强制释放CUP的使用权
              }
        
         if(i == 20) {
            try {
                st.join(); 
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println(Thread.currentThread().getName()+"i:="+i);
    }

• 1 定义子类继承Thread类。
• 2 子类中重写Thread类中的run方法。
• 3 创建Thread子类对象，即创建了线程对象。
• 4 调用线程对象start方法：启动线程，调用run方法。

2. 实现Runnable接口

class PrintNum1 implements Runnable {

   @Override
   public void run() {
      //子线程执行的代码
      for(int i = 1; i <= 100; i++) {
          if(i %2 == 0) {
              System.out.println(Thread.currentThread().getName() +":"+i);
          }
      }
   }
}

public class TestThread1 {
    public static void main(String[] args) {
    PrintNum1 p = new PrintNum1();
    //要想启动一个多线程,必须调用start()
    Thread t1 = new Thread(p);
    t1.start(); //启动线程:执行Thread对象生成时构造器形参的对象的run方法

    //再创建一个线程
    Thread t2 = new Thread(p);
    t2.start();
}

• 1 定义子类，实现Runnable接口。
• 2 子类中重写Runnable接口中的run方法。
• 3 通过Thread类含参构造器创建线程对象。
• 4 将Runnable接口的子类对象作为实际参数传递给Thread类的构造方法中。
• 5 调用Thread类的start方法：开启线程，调用Runnable子类接口的run方法。

继承方式和实现方式的联系与区别

继承Thread: 线程代码存放Thread子类run方法中。
实现Runnable：线程代码存在接口的子类的run方法。

实现方法的好处

• 1 避免了单继承的局限性。
• 2 多个线程可以共享同一个接口实现类的对象，非常适合多个相同线程来处理同一份资源。

Thread的常用方法:

• 1.start():启动线程并执行相应的run()方法
• 2.run():子线程要执行的代码放入run()方法中
• 3.currentThread():静态的，调取当前的线程
• 4.getName():获取此线程的名字
• 5.setName():设置此线程的名字
• 6.yield():调用此方法的线程释放当前CPU的执行权
• 7.join():在A线程中调用B线程的join()方法，表示：当执行到此方法：A线程停止执行，直到B线程执行完毕.
• 创建一个子线程,完成1-100之间自然数的输出，同样地，主线程执行同样的操作
• 创建多线程第一种方式：继承java.lang.Thread类
• 8.isAlive():判断当前线程是否还存活
• 9.sleep(long l):显示的让当前线程睡眠1毫秒
• 10:线程通信:wait() notify()

static void yield()：线程让步
暂停当前正在执行的线程，把执行机会让给优先级相同或更高的线程
若队列中没有同优先级的线程，忽略此方法
join() ：当某个程序执行流中调用其他线程的 join() 方法时，调用线程将被阻塞，直到 join() 方法加入的 join 线程执行完为止
低优先级的线程也可以获得执行
static void sleep(long millis)：(指定时间:毫秒)
令当前活动线程在指定时间段内放弃对CPU控制,使其他线程有机会被执行,时间到后重排队。
抛出InterruptedException异常
stop(): 强制线程生命期结束
boolean isAlive()：返回boolean，判断线程是否还活着

使用多线程的优点

只使用单个线程完成多个任务（调用多个方法），肯定比用多个线程来完成用的时间更短。多线程程序的优点：

• 1 提高应用程序的响应。对图形化界面更有意义，可增强用户体验。
• 2 提高计算机系统CPU的利用率。
• 3 改善程序结构。将既长又复杂的进程分为多个线程，独立运行，利于理解和修改。

线程的调度

线程的调度
时间片
抢占式：高优先级的线程抢占CPU
Java的调度方法
同优先级线程组成先进先出队列（先到先服务） ，使用时间片策略
对高优先级 使用优先调度的抢占式策略
线程的优先级控制
MAX_PRIORITY (10)
MIN_PRIORITY (1);
NORM_PRIORITY (5);
涉及的方法
getPriority():返回线程优先值
setPriority(int newPriority):改变线程的优先级

三、线程的生命周期

JDK中用Thread.State枚举表示了线程的几种状态
要想实现多线程，必须在主线程中创建新的线程对象。Java语言使Thread类及其子类的对象来表示线程，在它的一个完整的生命周期中通常要经历如下的五种状态：
新建： 当一个Thread类或其子类的对象被声明并创建时，新生的线程对象处于新建状态。
就绪：处于新建状态的线程被start()后，将进入线程队列等待CPU时间片，此时它已具备了运行的条件。
运行：当就绪的线程被调度并获得处理器资源时,便进入运行状态， run()方法定义了线程的操作和功能。
阻塞：在某种特殊情况下，被人为挂起或执行输入输出操作时，让出 CPU 并临时中止自己的执行，进入阻塞状态。
死亡：线程完成了它的全部工作或线程被提前强制性地中止 。

三、线程的同步

多个线程执行的不确定性引起执行结果的不稳定。多个线程对数据的共享，会造成操作的不完整性，会破坏数据。
模拟火车站售票程序，开启三个窗口售票。

class Window1 implements Runnable {
    int ticket = 100;
    Object obj = new Object();
    @Override
    public void run() {
       while(true) {
        show();
    }
}

private synchronized void show() {
    if(ticket > 0) {
        try {
            Thread.currentThread().sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName()+"售票：票号为 ="
                +ticket --);
    }
}

测试端：

public class TestWindow {
public static void main(String[] args) {
    Window1 w  = new Window1();
    Thread st  = new Thread(w);
    Thread st1 = new Thread(w);
    Thread st2 = new Thread(w);
    
    st.setName("售票窗口1");
    st.start();
    st1.setName("售票窗口2");
    st1.start();
    st2.setName("售票窗口2");
    st2.start();
}

此程序存在线程的安全问题:打印车票时，会出现重票和错票。
多线程出现了安全问题
问题的原因：当多条语句在操作同一个线程共享数据时，一个线程对多条语句只执行了一部分，还没有执行完，另一个线程参与进来执行。导致共享数据的错误。
解决的办法：对多条操作共享数据的语句，只能让一个线程都执行完，在执行过程中，其他线程不可以参与执行。
java如何实现线程的安全：线程的同步机制

• 1 方式一：同步代码块
  synchronized(同步监视器) {
  //需要被同步的代码块（即为操作共享数据的代码）
  }

  while(true) {
        synchronized (this) {  //表示当前对象  即为w 
        if(ticket > 0) {
            try {
                    Thread.currentThread().sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName()+"售票：票号为 ="
                        +ticket --);
            } else {
                break;          
            }
    }
  

共享数据:多个线程共同操作的同一数据（变量）同步监视器：由一个类的对象来充当。那个线程获取监视器，谁就执行大括号里被同步的代码，称锁。要求所有的线程必须共用同一把锁！
注：在实现的方式中或者继承的过程中，锁只能用同一个

• 2 方式二：同步方法
  将操作共享数据的方法声明为synchronized.即此方法为同步方法，能够保证当其中一个线程执行。此方法时，其它线程在外等待至此线程执行完成此方法。

  private synchronized void show() {
    if(ticket > 0) {
        try {
            Thread.currentThread().sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName()+"售票：票号为 ="
                +ticket --);
    }
  }
  

线程的 同步的弊端：由于同一个时间只能有一个线程访问共享数据，效率变低了。
互斥锁：在Java语言中，引入了对象互斥锁的概念，来保证共享数据操作的完整性。每个对象都对应于一个可称为“互斥锁”的标记，这个标记用来保证在任一时刻，只能有一个线程访问该对象。关键字synchronized 来与对象的互斥锁联系。当某个对象用synchronized修饰时，表明该对象在任一时刻只能由一个线程访问。同步的局限性：导致程序的执行效率要降低。同步方法（非静态的）的锁为this。同步方法（静态的）的锁为当前类本身。

分析同步原理
释放锁的操作

• 1 当前线程的同步方法、同步代码块执行结束.
• 2 当前线程在同步代码块、同步方法中遇到break、return终止了该代码块、该方法的继续执行。
• 3 当前线程在同步代码块、同步方法中出现了未处理的Error或Exception，导致异常结束。
• 4 当前线程在同步代码块、同步方法中执行了线程对象的wait()方法，当前线程暂停，并释放锁。

不会释放锁的操作

• 1 线程执行同步代码块或同步方法时，程序调用Thread.sleep()、Thread.yield()方法暂停当前线程的执行。
• 2 线程执行同步代码块时，其他线程调用了该线程的suspend()方法将该线程挂起，该线程不会释放锁（同步监视器）。应尽量避免使用suspend()和resume()来控制线程。

线程死锁的问题：不同的线程分别占用对方需要的同步资源不放弃，都在等待对方放弃自己需要的同步资源，就形成了线程的死锁。

public class TestDeadLock {
static StringBuffer sb1 = new StringBuffer();
static StringBuffer sb2 = new StringBuffer();
public static void main(String[] args) {
    new Thread(){
        public void run() {
            synchronized (sb1) {
                try {
                    Thread.currentThread().sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                sb1.append("A");
                synchronized (sb2) {
                    sb2.append("B");
                    System.out.println(sb1);
                    System.out.println(sb2);
                }
            }
        };
    }.start();
    
    new Thread() {
        public void run() {
            synchronized (sb2) {
                try {
                    Thread.currentThread().sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                sb1.append("C");
                synchronized (sb1) {
                    sb2.append("D");
                    System.out.println(sb1);
                    System.out.println(sb2);
                }
            }
        };
    }.start();
}

五 线程通信

wait() 与 notify() 和 notifyAll()
wait()：令当前线程挂起并放弃CPU、同步资源，使别的线程可访问并修改共享资源，而当前线程排队等候再次对资源的访问
notify()：唤醒正在排队等待同步资源的线程中优先级最高者结束等待
notifyAll ()：唤醒正在排队等待资源的所有线程结束等待.
Java.lang.Object提供的这三个方法只有在synchronized方法或synchronized代码块中才能使用，否则会报java.lang.IllegalMonitorStateException异常。

wait() 方法

• 1 在当前线程中调用方法： 对象名.wait()。
• 2 使当前线程进入等待（某对象）状态 ，直到另一线程对该对象发出 notify (或notifyAll) 为止。
• 3 调用方法的必要条件：当前线程必须具有对该对象的监控权（加锁）
  调用此方法后，当前线程将释放对象监控权 ，然后进入等待。
• 4 在当前线程被notify后，要重新获得监控权，然后从断点处继续代码的执行。

notify()/notifyAll()

• 1 在当前线程中调用方法： 对象名.notify()

• 2 功能：唤醒等待该对象监控权的一个线程。

• 3 调用方法的必要条件：当前线程必须具有对该对象的监控权（加锁）

  class Clerk { //店员
     int product;
  
     public synchronized void addProduct() { //生成产品
     if(product >= 20) {
        try {
            wait();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    } else {
        product ++;
        System.out.println(Thread.currentThread().getName()+":生成了第一个产品"+product);
        notifyAll();
    }
  }
  
  public synchronized void consumeProduct() { //消费产品
    if(product <= 0) {
        try {
            wait();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    } else {
        System.out.println(Thread.currentThread().getName()+":生成了第一个产品"+product);
        product --;
        notifyAll(); 
      }
    }
  }
  
  
  class Producer implements Runnable { //生成者
     Clerk clerk;
  
     public Producer(Clerk clerk) {
        this.clerk = clerk;
     }
  
    @Override
    public void run() {
    System.out.println("生成者开始生产产品");
    while(true) {
        try {
            Thread.currentThread().sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        clerk.addProduct();
        }
     }
  }
  
  class Consumer implements Runnable { //消费者
      Clerk clerk;
  
      public Consumer(Clerk clerk) {
          this.clerk = clerk;
      }
  
     @Override
    public void run() {
    System.out.println("消费者消费产品");
    while(true) {
        try {
            Thread.currentThread().sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        clerk.consumeProduct();
         }
      }
  
  }
  public class TestProduceConsume {
  
    public static void main(String[] args) {
    Clerk clerk = new Clerk();
    
    Producer p1 = new Producer(clerk);
    Consumer c1 = new Consumer(clerk);
    
    Thread t1 = new Thread(p1); //一个生成者的线程
    Thread t2 = new Thread(c1);
    
    t1.setName("生成者1");
    t2.setName("消费者1");
    t1.start();
    t2.start();
   }
  }
  

• 生成者/消费者问题
• 生成者（Productor）将产品交给店员(Clerk),而消费者(Customer)从店员处取走产品
• 店员一次只能持有固定数量的产品（比如：20）,如果生成者试图生成更多的产品。店员会叫生成者停一下，
• 如果店中有空位放产品了再通知生产者继续生产；如果店中没有产品了，店员会告诉消费者等一下，
• 如果店中有产品了再通知消费者来取走产品。

分析：

• 1.是否涉及到多线程的问题？是！生成者、消费者
• 2.是否涉及到共享数据？有！考虑线程的安全
• 3.此共享数据是谁？即为产品的数量
• 4.是否涉及到线程的通信呢？存在者生产者与消费者的通信