进程：正在运行中的程序（直译）。

线程：进程中一个负责程序执行的控制单元(执行路径)。

多线程: 一个进程中可以多执行路径，称之为多线程。

多线程的优缺点:

多线程的好处：解决了多部分同时运行的问题。

多线程的弊端：线程太多会导致效率的降低。

1. Java中实现多线程的手段：

1)、继承Thread类。

  1. // 定义一个类，继承Thread，重写run方法
  2. class ThreadSub extends Thread {
  3.     private String name; // 为了区分线程
  5.     public ThreadSub(String name) {
  6.         this.name = name;
  7.     }
  9.     @Override
  10.     public void run() {
  11.         for (int i = 0; i < 3; i++) {
  12.             System.out.println(name + "执行" + i);
  13.         }
  14.     }
  15. }
  17. // main函数
  18. public static void main(String[] args) {
  19.     Demo1Sub sub1 = new Demo1Sub("多线程01号");
  20.     Demo1Sub sub2 = new Demo1Sub("多线程02号");
  22.     sub1.start();
  23.     sub2.start();
  24. }
  26. 打印结果：
  27.     多线程01号执行0
  28.     多线程02号执行0
  29.     多线程02号执行1
  30.     多线程02号执行2
  31.     多线程01号执行1
  32.     多线程01号执行2

2)、实现Runnable接口。

实现Runnable接口的好处：

1，将线程的任务从线程的子类中分离出来，进行了单独的封装。
按照面向对象的思想将任务的封装成对象。
2，避免了java单继承的局限性。

  1. // Runnable接口详情， 只有一个抽象方法
  2. @FunctionalInterface
  3. public interface Runnable {
  4.     public abstract void run();
  5. }
  7. // 定义一个类，实现Runnable接口，实现未实现的run方法
  8. class ThreadSub2 implements Runnable {
  9.     private String name; // 为了区分线程
  11.     public ThreadSub2(String name) {
  12.         this.name = name;
  13.     }
  15.     @Override
  16.     public void run() {
  17.         for (int i = 0; i < 3; i++) {
  18.             System.out.println(name + "执行" + i);
  19.         }
  20.     }
  21. }
  23. // main函数
  24. public static void main(String[] args) {
  25.     Demo1Sub2 sub1 = new Demo1Sub2("多线程01号");
  26.     Demo1Sub2 sub2 = new Demo1Sub2("多线程02号");
  28.     Thread t1 = new Thread(sub1);
  29.     Thread t2 = new Thread(sub2);
  31.     t1.start();
  32.     t2.start();
  33. }
  35. 打印结果：
  36.     多线程01号执行0
  37.     多线程02号执行0
  38.     多线程02号执行1
  39.     多线程02号执行2
  40.     多线程01号执行1
  41.     多线程01号执行2

3)、匿名函数(其实就两种 这还是实现Runnable的一种)

  1. // 定义一个类
  2. class ThreadSub {
  3.     private String name; // 为了区分线程
  5.     public ThreadSub(String name) {
  6.         this.name = name;
  7.     }
  9.     // 该类中的方法
  10.     public void show() {
  11.         for (int i = 0; i < 3; i++) {
  12.             System.out.println(name + "执行" + i);
  13.         }
  14.     }
  15. }
  17. // 主函数入口
  18. public static void main(String[] args) {
  19.     Demo1Sub sub1 = new Demo1Sub("多线程01号");
  20.     Demo1Sub sub2 = new Demo1Sub("多线程02号");
  22.     // 使用匿名函数直接调用 start 方法
  23.     new Thread(new Runnable() {
  24.         @Override
  25.         public void run() {
  26.             sub1.show();
  27.         }
  28.     }).start();
  30.     Thread t2 = new Thread(new Runnable() {
  31.         @Override
  32.         public void run() {
  33.             sub2.show();
  34.         }
  35.     });
  36.     t2.start()   
  37. }
  38. 打印结果：
  39.     多线程01号执行0
  40.     多线程02号执行0
  41.     多线程02号执行1
  42.     多线程02号执行2
  43.     多线程01号执行1
  44.     多线程01号执行2

2. Thread类中的 start() 方法和 run() 方法的区别：

run()方法: 在本线程内调用该Runnable对象的run()方法，可以重复多次调用；

start()方法: 启动一个线程，调用该Runnable对象的run()方法，不能多次启动一个线程

直接调用run()方法，相当于没有使用多线程技术，需要在run()方法体执行完毕后才会执行下面的代码，还是只有一个主线程的执行路径，按照顺序执行代码。

调用start()方法后，会来启动一个线程，这时线程处于就绪状态，真正实现了多线程。

3. 多线程的状态 (重要)

image.png

4. 卖票(使用Runnable接口，将票封装在任务中，只有一个票对象)

  1. package se.thread;
  2. /*
  3. * 需求： 卖票
  4. *
  5. * 一共有100张票，使用四个线程同时卖票。
  6. * */
  7. public class SaleTicket {
  8.     public static void main(String[] args) {
  10.         // 使用继承Thread 类
  11.         // 既然创建多个线程会有多个车票对象，是否可以创建一个线程，开启四次？
  12.         // 答案是否定，会在main函数中抛出异常，非法的线程状态异常IllegalThreadStateException
  13.         // 一个线程只能被开启一次
  14.         /*
  15.             Ticket t1 = new Ticket();
  16.             Ticket t2 = new Ticket();
  17.             Ticket t3 = new Ticket();
  18.             Ticket t4 = new Ticket();
  20.             t1.start();
  21.             t2.start();
  22.             t3.start();
  23.             t4.start();
  24.         */
  26.         // 使用实现Runnable 接口
  27.         Ticket t = new Ticket(); // 创建一个线程任务。
  29.         Thread t1 = new Thread(t);
  30.         Thread t2 = new Thread(t);
  31.         Thread t3 = new Thread(t);
  32.         Thread t4 = new Thread(t);
  34.         t1.start();
  35.         t2.start();
  36.         t3.start();
  37.         t4.start();
  38.     }
  39. }
  41. // 继承Thread后创建了四个线程，导致每个线程对象都有一个自己的num，就会导致有400张票。
  42. // 实现Runnable创建一个线程任务对象，该对象中有num属性，而其他线程将此对象作为参数，都会使用此对象的num属性
  43. class Ticket /*extends Thread*/ implements Runnable {
  45.     // 继承时使用static可以解决此问题，但是很多情况我们是不想数据共享的。
  46.     // private static int num = 100;
  48.     private int num = 100;
  50.     /*@Override
  51.     public void run() {
  52.         while (true) {
  53.             if(num > 0) {
  54.                 // 注意！！！！！这里存在安全隐患
  55.                 // 即A线程通过了num>0的判断后，CPU不再执行A，执行B也通过了num>0的判断
  56.                 System.out.println(Thread.currentThread().getName()
  57.                         + "......sale....." + (--this.num));
  58.             }
  59.         }
  60.     }*/
  62.     @Override
  63.     public void run() {
  64.         while (true) {
  65.             // 同步 来解决安全隐患
  66.             synchronized(Ticket.class){
  67.                 if(num > 0) {
  68.                     // sleep 用来演示临时阻塞状态下的安全隐患
  69.                     // Thread.sleep(time)，存在InterruptedException异常
  70.                     // 由于实现的Runable接口，并且该接口没有声明过InterruptedException异常，
  71.                     // 所以run方法中的异常只能catch
  72.                     try { Thread.sleep(20); } catch (InterruptedException e) { }
  73.                     System.out.println(Thread.currentThread().getName()
  74.                             + "......sale....." + (--this.num));
  75.                 }
  76.             }
  77.         }
  78.     }
  80. }

5. 线程安全问题产生的原因：

（1）多个线程在操作共享的数据。

（2）操作共享数据的线程代码有多条。(例如售票的，run方法中需要判断 num是否大于零再进行售票，就会有安全隐患)

当一个线程在执行操作共享数据的多条代码过程中，其他线程参与了运算。就会导致线程安全问题的产生。

6. 同步代码块可以解决以上问题

解决思路；

就是将多条操作共享数据的线程代码封装起来，当有线程在执行这些代码的时候，其他线程时不可以参与运算的。

必须要当前线程把这些代码都执行完毕后，其他线程才可以参与运算。

7. 同步代码块的好处和弊端：

同步的好处：解决了线程的安全问题。

同步的弊端：相对降低了效率，因为同步外的线程的都会判断同步锁。

同步的前提：同步中必须有多个线程并使用同一个锁。

8. 同步函数使用的锁是 this

9. 静态的同步函数使用的锁是 该函数所属字节码文件对象, 可以使用getClass()来获取, 也可以使用 当前类名.class

10. 单例中的懒汉式存在多线程安全隐患

11. 死锁

容易出现死锁的一种形式: 同步嵌套(着重看打印结果以及解释)

  1. package com.lius.javase.demo.thread;
  3. /**
  4.  * 死锁:
  5.  *  容易出现死锁的一种形式: 同步嵌套
  6.  */
  7. public class DeathLock implements Runnable{
  9.     public boolean flag;
  11.     DeathLock(boolean flag) {
  12.         this.flag = flag;
  13.     }
  15.     @Override
  16.     public void run() {
  17.         if(flag) {
  18.             synchronized (MyLock.LOCK_A) {
  19.                 System.out.println(Thread.currentThread().getName() + "...if...LOCK_A");
  20.                 synchronized (MyLock.LOCK_B) {
  21.                     System.out.println(Thread.currentThread().getName() + "...if...LOCK_B");
  22.                 }
  23.             }
  24.         } else {
  25.             synchronized (MyLock.LOCK_B) {
  26.                 System.out.println(Thread.currentThread().getName() + "...else...LOCK_B");
  27.                 synchronized (MyLock.LOCK_A) {
  28.                     System.out.println(Thread.currentThread().getName() + "...else...LOCK_A");
  29.                 }
  30.             }
  31.         }
  32.     }
  33. }
  35. class MyLock {
  36.     public static final Object LOCK_A = new Object();
  37.     public static final Object LOCK_B = new Object();
  38. }
  40. class Test {
  41.     public static void main(String[] args) {
  43.         DeathLock target1 = new DeathLock(true);
  44.         DeathLock target2 = new DeathLock(false);
  46.         Thread t1 = new Thread(target1);
  47.         Thread t2 = new Thread(target2);
  49.         t1.start();
  50.         t2.start();
  51.     }
  52. }
  54. 死锁的打印结果: 
  55. Thread-1...else...LOCK_B
  56. Thread-0...if...LOCK_A
  58. 对打印结果进行解释: 
  59. 线程1的标志位(flag)为false, 走了else分支, 拿着B锁进入了else里的第一个同步代码块, 
  60. 在想要拿A锁进入else的下一个代码块的时候, 线程1失去了CPU的执行权, 进入到阻塞状态, 此时线程2抢到执行权;
  61. 线程2的标志位(flag)是true, 走了if分支, 拿着A锁进入了if里的第一个同步代码块,
  62. 在想要拿B锁进入if的下一哥代码块的时候, B锁却还在线程1手里, 所以拿不到, 就发生了死锁现象.

12. 等待唤醒机制

代码示例(同一个资源, 一个线程负责存值, 另一个线程负责取值)

  1. package com.lius.javase.demo.thread;
  3. /**
  4.  * 同一个资源, 一个赋值, 一个取值
  5.  *
  6.  * 使用等待唤醒机制:
  7.  *  设计到的方法:
  8.  *      wait(): 让线程处于冻结状态, 被wait()的线程会被存放到线程池中.
  9.  *      notify(): 唤醒线程池中的一个线程(随机的).
  10.  *      notifyAll(): 唤醒线程池中的所有线程.
  11.  *
  12.  *  这些方法都必须定义在同步中,
  13.  *  因为这些方法都是改变线程状态的方法, 必须要明确操作的到底是哪个锁上的线程.
  14.  */
  15. public class ResourceDemo {
  16.     public static void main(String[] args) {
  18.         Resource r = new Resource();
  20.         Input in = new Input(r);
  21.         Output out = new Output(r);
  23.         Thread t1 = new Thread(in);
  24.         Thread t2 = new Thread(out);
  26.         t1.start();
  27.         t2.start();
  28.     }
  29. }
  31. // 资源
  32. class Resource {
  33.     private String name;
  35.     private String sex;
  37.     private boolean isExists = false; // 是否已有值
  39.     public synchronized void set(String name, String sex) {
  40.         if(isExists) {
  41.             try { this.wait(); } catch (InterruptedException e) { e.printStackTrace(); }
  42.         } /* 注意!!! 这里不能使用 else 代码块 */
  43.         this.name = name;
  44.         this.sex = sex;
  45.         isExists = true;
  46.         this.notify();
  47.     }
  49.     public synchronized void print() {
  50.         if(!isExists) {
  51.             try { this.wait(); } catch (InterruptedException e) { e.printStackTrace(); }
  52.         } else {
  53.             System.out.println(this.name + "..." + this.sex);
  54.             isExists = false;
  55.             this.notify();
  56.         }
  57.     }
  58. }
  60. // 赋值
  61. class Input implements Runnable{
  63.     private final Resource r;
  65.     Input(Resource r) {
  66.         this.r = r;
  67.     }
  69.     boolean flag = false; // 控制赋值切换的
  71.     @Override
  72.     public void run() {
  73.         for(;;) {
  74.             if (flag) {
  75.                 r.set("mike", "man");
  76.             } else {
  77.                 r.set("丽丽", "女女女女女女女女女");
  78.             }
  79.             flag = !flag;
  80.         }
  81.     }
  82. }
  84. // 取值
  85. class Output implements Runnable {
  87.     private final Resource r;
  89.     Output(Resource r) {
  90.         this.r = r;
  91.     }
  93.     @Override
  94.     public void run() {
  95.         for(;;) {
  96.             r.print();
  97.         }
  98.     }
  99. }

为什么操作线程的方法wait, notify, notifyAll 定义在了Object类中？

因为这些方法是监视器的方法。监视器其实就是锁。锁可以是任意的对象，任意的对象调用的方式一定定义在Object类中。

13. 等待唤醒中 多生产多消费问题 ☆☆☆☆

单生产单消费, 因为一共有两个线程, 所以唤醒时必定会唤醒对方的线程, 不会出现多生产多消费的问题

多生产多消费有什么问题?

1. 使用 if 来判断标记, 生产或者消费方唤醒的仍是本方的线程的话, 本方线程不会再去判断标记, 导致生产或者消费执行多次.

解决方式: 将 if 判断 改为 while 循环, 醒来之后仍能判断标记, 避免了多次生产或者消费

2. 将if改为while之后会出现的问题: 如果对方线程全部wait(), 只剩本的一个线程在运行, 执行完一次后唤醒的仍然是本方线程, 会导致所有线程全部被wait();

解决方式: 在唤醒时, 至少能够保证唤醒对方一个线程, 才不会出现该结果, 但无法指定唤醒, 所以只能将 notify() 改为 notifyAll();

  1. package com.lius.javase.demo.thread;
  3. /**
  4.  * 多生产者 -- 多消费者
  5.  *
  6.  * 多生产多消费出现的问题:
  7.  *  1. 使用 if 判断标记, 被 notify 后不会再判断标记了, 直接执行后面的代码, 需要重新判断标记, 将 if 改为 while
  8.  *  2. 将 if 改为 while 后, 造成所有线程全部被 wait(), 即死锁的另外一种情况, 如何解决?
  9.  *      因为至少需要唤醒一个对方的线程, 但是没有指定唤醒, 所以干脆全唤醒, 使用 notifyAll()
  10.  */
  11. public class ProducerConsumerDemo {
  13.     public static void main(String[] args) {
  14.         Resource r = new Resource();
  16.         Producer producer = new Producer(r);
  17.         Consumer consumer = new Consumer(r);
  19.         Thread t0 = new Thread(producer);
  20.         Thread t1 = new Thread(producer);
  21.         Thread t2 = new Thread(consumer);
  22.         Thread t3 = new Thread(consumer);
  24.         t0.start();
  25.         t1.start();
  26.         t2.start();
  27.         t3.start();
  28.     }
  29. }
  31. class Resource {
  33.     private String name;
  35.     private int index = 1;
  37.     private boolean flag = false;
  39.     public synchronized void set(String name) {
  40.         while (this.flag) { // 这里将 if 改为 while 是为了醒来之后再去判断标记, 以免本方线程多次执行
  41.             try {this.wait();} catch (InterruptedException e) {e.printStackTrace();}
  42.         }
  43.         this.name = name + index;
  44.         index++;
  45.         System.out.println(Thread.currentThread().getName() + "...生产者..." + this.name);
  46.         this.flag = true;
  47.         // notify() 改为 notifyAll()
  48.         // 因为使用了 while 会导致所有线程全部被 wait(),
  49.         // 所以必须保证唤醒时可以至少唤醒对面一个, 但无法指定唤醒那个线程, 干脆全部唤醒
  50.         this.notifyAll();
  51.     }
  53.     public synchronized void out() {
  54.         while (!this.flag) { // 这里改为 while 与上同理
  55.             try {this.wait();} catch (InterruptedException e) {e.printStackTrace();}
  56.         }
  57.         System.out.println(Thread.currentThread().getName() + "......消费者......" + this.name);
  58.         this.flag = false;
  59.         this.notifyAll(); // notify() 改为 notifyAll() 与上同理
  60.     }
  62. }
  64. class Producer implements Runnable {
  66.     private final Resource r;
  68.     Producer(Resource r) {
  69.         this.r = r;
  70.     }
  72.     @Override
  73.     public void run() {
  74.         for(;;) {
  75.             r.set("烤鸭");
  76.         }
  77.     }
  78. }
  80. class Consumer implements Runnable {
  82.     private final Resource r;
  84.     Consumer(Resource r) {
  85.         this.r = r;
  86.     }
  88.     @Override
  89.     public void run() {
  90.         for(;;) {
  91.             r.out();
  92.         }
  93.     }
  94. }

3. JDK1.5 之后将同步和锁封装成了对象， 来解决多生产和多消费的问题。

  1. package com.lius.javase.demo.thread;
  3. import java.util.concurrent.locks.Condition;
  4. import java.util.concurrent.locks.Lock;
  5. import java.util.concurrent.locks.ReentrantLock;
  7. /**
  8.  * 多生产多消费, 使用Lock接口替换同步代码块或者同步函数   (JDK1.5之后才有的)
  9.  */
  10. public class ProConLockDemo {
  12.     public static void main(String[] args) {
  13.         Resource r = new Resource();
  15.         Pro producer = new Pro(r);
  16.         Cons consumer = new Cons(r);
  18.         Thread t0 = new Thread(producer);
  19.         Thread t1 = new Thread(producer);
  20.         Thread t2 = new Thread(consumer);
  21.         Thread t3 = new Thread(consumer);
  23.         t0.start();
  24.         t1.start();
  25.         t2.start();
  26.         t3.start();
  27.     }
  29. }
  31. class Resource {
  33.     private String name;
  35.     private int index = 1;
  37.     private boolean flag = false;
  39.     Lock lock = new ReentrantLock();
  41.     // 通过一个锁上挂多组监视器， 来解决 notifyAll() 的效率问题
  42.     Condition con_condition = lock.newCondition(); // 生产者监视器
  43.     Condition pro_condition = lock.newCondition(); // 消费者监视器
  45.     public void set(String name) {
  46.         lock.lock();
  47.         try {
  48.             while (this.flag) {
  49.                 try {
  50.                     con_condition.await();} catch (InterruptedException e) {e.printStackTrace();}
  51.             }
  52.             this.name = name + index;
  53.             index++;
  54.             System.out.println(Thread.currentThread().getName() + "...生产者..." + this.name);
  55.             this.flag = true;
  56.             pro_condition.signal();
  57.         } finally {
  58.             lock.unlock();
  59.         }
  60.     }
  62.     public void out() {
  63.         lock.lock();
  64.         try {
  65.             while (!this.flag) {
  66.                 try {
  67.                     pro_condition.await();} catch (InterruptedException e) {e.printStackTrace();}
  68.             }
  69.             System.out.println(Thread.currentThread().getName() + "......消费者......" + this.name);
  70.             this.flag = false;
  71.             con_condition.signal();
  72.         } finally {
  73.             lock.unlock();
  74.         }
  75.     }
  77. }
  79. class Pro implements Runnable {
  81.     private final Resource r;
  83.     Pro(Resource r) {
  84.         this.r = r;
  85.     }
  87.     @Override
  88.     public void run() {
  89.         for(;;) {
  90.             r.set("烤鸭");
  91.         }
  92.     }
  93. }
  95. class Cons implements Runnable {
  97.     private final Resource r;
  99.     Cons(Resource r) {
  100.         this.r = r;
  101.     }
  103.     @Override
  104.     public void run() {
  105.         for(;;) {
  106.             r.out();
  107.         }
  108.     }
  109. }

14. wait 和 sleep 的区别：

1）wait可以指定时间， 也可以不指定时间（该时间为等待的最长时间）；而sleep必须指定时间。

2）在同步中，对CPU的执行权和锁的处理不同：

wait：释放执行权，释放锁

sleep：释放执行权，不释放锁

15. 停止线程的方法

1，stop方法（过时，存在安全隐患）

2，run方法结束。

如何控制线程任务结束呢？通常使用标记来结束。

如果线程处于冻结状态，无法读取标记该怎么办？interrupt —>