何时需要多线程

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

线程有四种创建方式
解决线程安全问题有3种

基本概念

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

进程(process)是程序的一次执行过程，或是正在运行的一个程序。是一个动态的过程：有它自身的产生、存在和消亡的过程 ——生命周期
进程作为资源分配的单位，系统在运行时会为每个进程分配不同的内存区域。

线程（thread），进程可进一步细化为线程，是一个程序内部的一条执行路径。
>若一个进程同一时间并行执行多个线程，就是支持多线程
>线程作为调度和执行的单位，每个线程拥有独立的运行栈和程序计数器（pc），线程切换的开销小
>一个进程中的多个线程共享相同的内存单元/内存地址空间——>他们从同一堆中分配对象，可以访问相同的变量和对象。这就使得线程间通信更简便、高效。但多个线程操作共享的系统资源可能就会带来安全隐患。

一个Java应用程序java.exe，其实至少有三个线程：main()主线程，gc()垃圾回收线程，异常处理线程。当然如果发生异常，会影响主线程。

并行与并发
并行：多个CPU同时执行多个任务。比如多个人同时做不同的事
并发：一个CPU(采用时间片)同时执行多个任务。

创建线程
方式一：
1.创建一个继承于Thread类的子类
2.重写Thread类的run() —>将此类线程执行的操作申明在run()中
3.创建Thread类的子类的对象
4.调用此对象的start()方法

  1. class MyThread extends Thread{
  2.     @Override
  3.     public void run() {
  4.         for(int i = 0;i < 100; i++){
  5.             if(i % 2 == 0){
  6.                 System.out.println(i);
  7.                 System.out.println(Thread.currentThread().getName() + ":" + i);
  8.             }
  9.         }
  10.     }
  11. }
  12. public class ThreadTest{
  13.     public static void main(String[] args) {
  15.         MyThread t1 = new MyThread();
  16.         //通过子对象调用start:1、启动当前线程 2、调用当前线程的run()
  17.         t1.start();
  18.         // 问题一： 我们不能通过直接调用run()的方式启动线程
  19.         //t1.run();
  20.         // 问题二： 再启动一个线程，遍历100以内的偶数。不可以还让已经start（）的线程去执行。会报IllegalThreadStateException的异常
  21.         //t1.start();
  22.         MyThread t2 = new MyThread();
  23.         t2.start();
  25.         //以下的操作仍然是在主线程下执行
  26.         for(int i = 0;i < 100; i++){
  27.             if(i % 2 == 0){
  28.                 System.out.println(i+"*****************************************");
  29.             }
  30.         }
  32.     }
  33. }
  1. public class ThreadDemo {
  2.     public static void main(String[] args) {
  3.         MyThread01 m1 = new MyThread01();
  4.         MyThread01 m2 = new MyThread01();
  5.         m1.start();
  6.         m2.start();
  7.     }
  8. }
  9. class MyThread01 extends Thread{
  10.     @Override
  11.     public void run() {
  12.         for(int i = 0;i < 100; i++){
  13.             if(i % 2 == 0){
  14.                 System.out.println(Thread.currentThread().getName() + ":" + i);
  15.             }
  16.         }
  17.     }
  18. }

创建Thread的匿名子类的方式

  1.  new Thread(){
  2.             @Override
  3.             public void run() {
  4.                 for(int i = 0;i < 100; i++){
  5.                     if(i % 2 != 0){
  6.                         System.out.println(Thread.currentThread().getName() + ":" + i);
  7.                     }
  8.                 }
  9.             }
  10.         }.start();
  11.   new Thread(){
  12.             @Override
  13.             public void run() {
  14.                 for(int i = 0;i < 100; i++){
  15.                     if(i % 2 == 0){
  16.                         System.out.println(Thread.currentThread().getName() + ":" + i);
  17.                     }
  18.                 }
  19.             }
  20.         }.start();

Thread**类的有关方法**(1)

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

是this，通常用于主线程和Runnable实现类

  • yield()：

释放当前CPU的执行权

Thread**类的有关方法**(2)

  • static void yield()**：**线程让步

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

  • join() **：**当某个程序执行流中调用其他线程的 join() 方法时，调用线程将

被阻塞，直到 join() 方法加入的 join 线程执行完为止，低优先级的线程也可以获得执行

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

令当前活动线程在指定时间段内放弃对CPU控制,使其他线程有机会被执行,时间到后重排队。抛出InterruptedException异常

  • stop(): 强制线程生命期结束，不推荐使用
  • boolean isAlive()**：**返回boolean，判断线程是否还活着


线程的调度

调度策略

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

JAVA的调度方式

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

线程的优先级等级

  • MAX_PRIORITY**：**10
  • MIN _PRIORITY**：**1
  • NORM_PRIORITY**：**5 （默认）

涉及的方法

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

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

_
1.创建一个实现了Runnable接口的类
2.实现类去实现Runnable接口的类
3.创建实现类的对象4.将此对象作为参数传递到Thread类的构造器，创建Thread类的对象
5.通过Thread类的对象调用start()
**

  1. /*
  2. 创建3个窗口卖票，总票数为100张 实现Runnable类方式
  4.  */
  5. class Window1 implements Runnable{
  6.     private int ticket = 100;
  7.     @Override
  8.     public void run() {
  9.         while (true){
  11.                 if(ticket > 0){
  12.                     System.out.println(Thread.currentThread().getName() + ": 卖票，票号为：" + ticket);
  13.                     ticket--;
  14.                 }else {
  15.                     break;
  16.                 }
  17.         }
  18.     }
  19. }
  20. public class WindowTest1 {
  21.     public static void main(String[] args) {
  22.         Window1 w = new Window1();
  25.         Thread t1 = new Thread(w);
  26.         Thread t2 = new Thread(w);
  27.         Thread t3 = new Thread(w);
  29.         t1.setName("窗口一：");
  30.         t2.setName("窗口二：");
  31.         t3.setName("窗口三：");
  33.         t1.start();
  34.         t2.start();
  35.         t3.start();
  36.     }
  37. }

比较创建线程的两种方式：
开发中：优先选择：实现Runnable接口的方式
原因：1、实现的方式没有类的单继承性的局限性
2、实现的方式更适合来处理多个线程有共享数据的情况

联系：class Thread implements Runnable
相同点：两种方式都需要重写run()，将线程要执行的逻辑声明在run（）中

线程的生命周期：

  • JDK**中用Thread.State类定义了线程的几种状态
    要想实现多线程，必须在主线程中创建新的线程对象。Java语言使用Thread类及其子类的对象来表示线程，在它的一个完整的生命周期中通常要经历如下的    五种状态**：
  • 新建**： **当一个Thread类或其子类的对象被声明并创建时，新生的线程对象处于新建状态
  • 就绪**：**处于新建状态的线程被start()后，将进入线程队列等待CPU时间片，此时它已

具备了运行的条件，只是没分配到CPU资源

  • 运行**：**当就绪的线程被调度并获得CPU资源时,便进入运行状态， run()方法定义了线

程的操作和功能

  • 阻塞**：**在某种特殊情况下，被人为挂起或执行输入输出操作时，让出 CPU 并临时中

止自己的执行，进入阻塞状态

  • 死亡**：**线程完成了它的全部工作或线程被提前强制性地中止或出现异常导致结束

线程的同步：

问题的提出：
多个线程执行的不确定性引起执行结果的不稳定
多个线程对账本的共享，会造成操作的不完整，会破坏数据
一定要保证锁是唯一的
1.问题：卖票过程中，出现重票、错票 —->出现了线程安全问题_2.问题出现的原因：当某个线程操作车票的过程中，尚未操作完成时，其他线程参与进来_3.如何解决： 当一个线程a在操作共享数据（ticket）的时候，其他线程不能参与进来。直到线程a操作完ticket时其他线程才可以开始操作ticket。这种情况即使线程a出现了阻塞，也不能被改变。_4.在Java中，我们通过同步机制，来解决线程的安全问题。 方式一 ：同步代码块 synchronized(同步监视器){ 需要监视的代码 } 说明：1.操作共享数据的代码，即为需要被同步的代码 2.共享数据：多个线程共同操作的变量。比如：ticket就是共享数据。 3.同步监视器，俗称：锁，任何一个类的对象都可以充当锁 4.要求：多个线程必须要共用一把锁
synchronized(同步监视器){
操作共享数据的代码
｝
类也是对象synchronized(this){ 此时的this为当前的对象 synchronized(obj){

方式二：同步方法
继承方式

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

实现Runnable方式

  1. class Window1 implements Runnable{
  2.     private int ticket = 100;
  3.     Object obj = new Object();
  4.     @Override
  5.     public void run() {
  6.         while (true){
  7.             synchronized(Window.class){//类也是对象
  8.             //synchronized(this){
  9.                 //此时的this为当前的对象
  10.                 //synchronized(obj){
  11.                 if(ticket > 0){
  12.                     try {
  13.                         Thread.sleep(100);
  14.                     } catch (InterruptedException e) {
  15.                         e.printStackTrace();
  16.                     }
  17.                     System.out.println(Thread.currentThread().getName() + ": 卖票，票号为：" + ticket);
  18.                     ticket--;
  19.                 }else {
  20.                     break;
  21.                 }
  22.             }
  24.         }
  25.     }
  26. }

同步方法总结
1.同步方法仍然涉及到同步监视器，只是不需要我们显式的声明。
2.非静态的同步方法，同步监视器是：this
静态的同步方法，同步监视器是当前类本身。

同步的方式解决了线程的安全问题 —好处
操作同步代码时，只能有一个线程参与，其他线程等待。相当于是一个单线程的过程效率低。

死锁问题

  • 不同的线程分别占用对方需要的同步资源不放弃，都在等待对方放弃

自己需要的同步资源，就形成了线程的死锁

  • 出现死锁后，不会出现异常，不会出现提示，只是所有的线程都处于

阻塞状态，无法继续

解决线程安全问题的方式三 ： Lock锁 —- JDK5.0新增

  1. class Windowz implements Runnable{
  2.     private int ticket = 100;
  3.     private ReentrantLock lock = new ReentrantLock();
  4.     @Override
  5.     public void run() {
  7.         while (ticket!=0){
  8.             lock.lock();
  10.                 if (ticket > 0){
  11.                     try{
  12.                         try {
  13.                             Thread.sleep(100);
  14.                         } catch (InterruptedException e) {
  15.                             e.printStackTrace();
  16.                         }
  18.                         System.out.println(Thread.currentThread().getName() + ": 卖票，票号为：" + ticket);
  19.                         ticket--;
  20.                     }finally {
  21.                         lock.unlock();
  22.                     }
  24.                 }
  25.         }
  26.     }
  27. }

线程的通信

涉及到三个方法：
1.wait(), notify(), notifyAll()三个方法必须使用在同步代码块或同步方法中。
2.wait(), notify(), notifyAll()三个方法的调用者必须是同步代码块或同步方法中的同步监视器否则会出现异常
3.wait(), notify(), notifyAll()三个方法是定义在java.lang.Object类中

  1. class number implements Runnable{
  3.     private int number = 1;
  5.     @Override
  6.     public void run() {
  8.         while (true){
  10.             synchronized (this) {
  12.                 notify();
  13.                 if(number <= 100){
  14.                     System.out.println( Thread.currentThread().getName()  + "打印了：" + number);
  15.                     number++;
  16.                     try {
  17.                         wait();
  18.                     } catch (InterruptedException e) {
  19.                         e.printStackTrace();
  20.                     }
  21.                 }else {
  22.                     break;
  23.                 }
  24.             }
  25.       }
  26.     }
  27. }

sleep和wait的异同

1、相同点：一旦执行方法，都可以使得当前的线程进入阻塞状态。
2、不同点：1）声明的位置不同：Thread类中声明sleep（），Object类中声明wait()
2）调用的要求不同：sleep可以在任何需要的场景下调用。wait()必须在同步代码块或同步方法中
3）关于是否释放同步监视器：如果两个方法都使用在同步代码块或同步方法中，sleep()不会释放锁（同步监视器），wait会释放，用notify（）唤醒

生产者/消费者问题

经典例题：生产者/消费者问题
生产者(Productor)将产品交给店员(Clerk)，而消费者(Customer)从店员处
取走产品，店员一次只能持有固定数量的产品(比如:20），如果生产者试图
生产更多的产品，店员会叫生产者停一下，如果店中有空位放产品了再通知生产者继续生产；如果店中没有产品了，店员会告诉消费者等一下，如果店中有产品了再通知消费者来取走产品。
这里可能出现两个问题：
生产者比消费者快时，消费者会漏掉一些数据没有取到。
消费者比生产者快时，消费者会取相同的数据。

  1. class Clerk{
  2.     private int products = 0;
  4.     public synchronized void cusumer() {
  5.         if(products <= 0){
  6.             try {
  7.                 wait();
  8.             } catch (InterruptedException e) {
  9.                 e.printStackTrace();
  10.             }
  11.         }else {
  13.             System.out.println(Thread.currentThread().getName()+"正在消费第"+products+"个产品");
  14.             products--;
  15.             notifyAll();
  16.         }
  18.     }
  19.     public synchronized void product(){
  20.         if(products >= 20){
  21.             try {
  22.                 wait();
  23.             } catch (InterruptedException e) {
  24.                 e.printStackTrace();
  25.             }
  26.         }else {
  27.             products++;
  28.             System.out.println(Thread.currentThread().getName()+"正在生产第"+products+"个产品");
  29.             notifyAll();
  30.         }
  33.     }
  35. }
  37. class Productor extends Thread{
  39.     private Clerk clerk;
  41.     public Productor(Clerk clerk) {
  42.         this.clerk = clerk;
  43.     }
  45.     @Override
  46.     public void run() {
  47.         while (true){
  49.             try {
  50.                 Thread.sleep((int)Math.random()*1000);
  51.             } catch (InterruptedException e) {
  52.                 e.printStackTrace();
  53.             }
  54.             clerk.product();
  55.         }
  56.     }
  57. }
  59. class Customer extends Thread{
  61.     private Clerk clerk;
  63.     public Customer(Clerk clerk) {
  64.         this.clerk = clerk;
  65.     }
  67.     @Override
  68.     public void run() {
  69.         while (true){
  71.             try {
  72.                 Thread.sleep((int)Math.random()*10);
  73.             } catch (InterruptedException e) {
  74.                 e.printStackTrace();
  75.             }
  76.             clerk.cusumer();
  77.         }
  78.     }
  79. }
  82. public class ProductTest {
  83.     public static void main(String[] args) {
  84.         Clerk clerk = new Clerk();
  86.         Productor p = new Productor(clerk);
  88.         Customer c = new Customer(clerk);
  90.         p.setName("生产者");
  91.         c.setName("消费者");
  93.         p.start();
  94.         c.start();
  96.     }
  101. }

JDK5.0 新增线程创建方式

新增方式一：实现Callable接口
新增方式二：使用线程池

使用线程池

背景：经常创建和销毁、使用量特别大的资源，比如并发情况下的线程，
对性能影响很大。
思路：提前创建好多个线程，放入线程池中，使用时直接获取，使用完
放回池中。可以避免频繁创建销毁、实现重复利用。类似生活中的公共交
通工具。
好处：
 提高响应速度（减少了创建新线程的时间）
 降低资源消耗（重复利用线程池中线程，不需要每次都创建）
 便于线程管理
 corePoolSize：核心池的大小
 maximumPoolSize：最大线程数
 keepAliveTime：线程没有任务时最多保持多长时间后会终止
 …
线程池相关API
 JDK 5.0起提供了线程池相关API：ExecutorService 和 Executors
 ExecutorService：真正的线程池接口。常见子类ThreadPoolExecutor
 void execute(Runnable command) ：执行任务/命令，没有返回值，一般用来执行
Runnable
 Future submit(Callable task)：执行任务，有返回值，一般又来执行
Callable
 void shutdown() ：关闭连接池
 Executors：工具类、线程池的工厂类，用于创建并返回不同类型的线程池
 Executors.newCachedThreadPool()：创建一个可根据需要创建新线程的线程池
 Executors.newFixedThreadPool(n); 创建一个可重用固定线程数的线程池
 Executors.newSingleThreadExecutor() ：创建一个只有一个线程的线程池
 Executors.newScheduledThreadPool(n)：创建一个线程池，它可安排在给定延迟后运
行命令或者定期地执行