一、死锁

开发中不用死锁，面试会问：

应用场景：并发场景，多线程，线程之间互不相让，得借助于锁

加锁得目的是为了线程安全，物极必反，尤其是加了锁以后

死锁是一个状态，当两个线程互相持有对方想要得资源得时候，却又不主动释放这个资源得时候，会导致死锁，到家都用不了线程，就无法执行下去。

线程1有一个锁1

线程2有个锁2

线程1等待锁2得释放

线程2等待锁1得释放

死锁案例：背会，面试需手写

  1. package com.qfedu.test;
  3. //死锁
  4. class DeadLock implements Runnable{
  5.     private boolean isFlag;
  6.     private Object obj1;
  7.     private Object obj2;
  9.     public DeadLock(boolean isFlag, Object obj1, Object obj2) {
  10.         this.isFlag = isFlag;
  11.         this.obj1 = obj1;
  12.         this.obj2 = obj2;
  13.     }
  15.     @Override
  16.     public void run() {
  17.         if(isFlag) {//如果是true让线程1进来
  18.             synchronized (obj1) {//锁得是obj1对象
  19.                 //线程1
  20.                 System.out.println(Thread.currentThread().getName() + "锁1");
  21.                 try {
  22.                     Thread.sleep(1000);
  23.                 } catch (InterruptedException e) {
  24.                     // TODO Auto-generated catch block
  25.                     e.printStackTrace();
  26.                 }
  27.                 System.out.println("等待锁2得释放");
  28.                 synchronized (obj2) {
  29.                     System.out.println(Thread.currentThread().getName() + "拿到锁2");
  30.                 }
  31.             }
  32.         }
  33.         if (!isFlag) {//如果为false，让线程2进来
  34.             synchronized(obj2) {
  35.                 System.out.println(Thread.currentThread().getName() + "锁2");
  36.                 try {
  37.                     Thread.sleep(1000);
  38.                 } catch (InterruptedException e) {
  39.                     // TODO Auto-generated catch block
  40.                     e.printStackTrace();
  41.                 }
  42.                 System.out.println("等待锁1得释放");
  43.                 synchronized (obj1) {
  44.                     System.out.println(Thread.currentThread().getName() + "拿到锁1");
  45.                 }
  46.             }
  47.         }
  48.     }
  49. }
  50. public class Demo1 {
  51.     public static void main(String[] args) {
  52.         Object object1 = new Object();
  53.         Object object2 = new Object();
  55.         //第一个线程执行锁1
  56.         new Thread(new DeadLock(true, object1, object2),"线程1").start();
  58.         //第二个线程执行锁2
  59.         new Thread(new DeadLock(false, object1, object2),"线程2").start();
  60.     }
  62. }

二、线程的生命周期

1.线程的创建，开启线程

2.可运行状态，CPU等待，CPU抢占

3.运行状态，CPU使用，CPU等待，CPU抢占

4.阻塞状态，锁，sleep，wait

5.消亡

三、和线程相关的重要方法

object类下面的方法

  1. public final void wait() throws InterruptedException

导致线程等待，知道另一个线程调用该对象的notify()或notifyAll()方法。

总结：对象来调用wait方法，在一个线程中 对象.wait（) 这个线程会阻塞。

想让这个线程继续执行，需要使用另外一个线程去拿同一个对象调用notify方法去唤醒线程

注意事项：

  1. 1.功能是线程等待（阻塞状态），
  3. 2.需要使用对象调用
  5. 3.wait方法一般搭配锁一起使用（保证是同一个对象锁）
  1. package com.qfedu.test2wait;
  3. //wait
  4. //对象调用wait方法，得有对象，有对象得先有类
  5. class Message{
  6.     private String message;
  7.     public Message() {
  8.     }
  9.     public Message(String message) {
  10.         this.message = message;
  11.     }
  12.     public String getMessage() {
  13.         return message;
  14.     }
  15.     public void setMessage(String message) {
  16.         this.message = message;
  17.     }
  18.     @Override
  19.     public String toString() {
  20.         return "Message [message=" + message + "]";
  21.     }
  22. }
  24. //线程 作为等待线程
  25. class Waiter implements Runnable{
  26.     //Waiter 是一个类 可以写构造方法
  27.     private Message msg;//一个类下面得属性可以是另外一个类对象
  29.     //因为要使用对象.wait方法
  30.     public Waiter(Message msg) {
  31.         this.msg = msg;
  32.     }
  34.     @Override
  35.     public void run() {
  36.         String name = Thread.currentThread().getName();
  37.         synchronized (msg) {
  38.             System.out.println(name + "等待唤醒时间：" + System.currentTimeMillis());
  39.             try {
  40.                 msg.wait();//走到这一步 线程不会往下走了
  41.             } catch (InterruptedException e) {
  42.                 // TODO Auto-generated catch block
  43.                 e.printStackTrace();
  44.             }
  45.             System.out.println("线程wait了");
  46.             System.out.println(name + "被唤醒时间：" + System.currentTimeMillis());
  47.             System.out.println(name + "#线程#" + msg.getMessage());
  48.         }
  49.     }
  50. }
  51. //唤醒线程
  52. class Notifier implements Runnable{
  53.     private Message msg;
  55.     public Notifier(Message msg) {
  56.         super();
  57.         this.msg = msg;
  58.     }
  60.     @Override
  61.     public void run() {
  62.         String name = Thread.currentThread().getName();
  63.         System.out.println(name + "开始唤醒等待线程");
  64.         try {
  65.             Thread.sleep(2000);
  66.         } catch (InterruptedException e) {
  67.             // TODO Auto-generated catch block
  68.             e.printStackTrace();
  69.         }
  70.         synchronized (msg) {
  71.             msg.setMessage("！！！！我是修改之后的Message属性值");
  72.             //开始唤醒  msg是等待线程和唤醒线程中的同一个对象
  73.             msg.notify();
  74.             msg.notify();
  75.             msg.notify();
  76. //            msg.notifyAll();
  77.             System.out.println("hahaha？");
  78.         }
  80.     }
  81. }
  82. public class Demo1 {
  83.     public static void main(String[] args) {
  84.         Message message = new Message("我是Message属性");
  85.         Waiter waiter = new Waiter(message);
  86.         new Thread(waiter,"等待线程1").start();
  87.         new Thread(waiter,"等待线程2").start();
  88.         new Thread(waiter,"等待线程3").start();
  90.         Notifier notifier = new Notifier(message);
  91.         new Thread(notifier,"唤醒线程").start();
  92.     }
  94. }

四、生产者消费者模式【重要】

和上午wait和notify方法有关

  1. package com.qfedu.test3Anili;
  3. //生产者消费者模式 案例 购车
  4. //这个类作为线程之间共享的一个资源，会当成一个锁对象
  5. class Goods {
  6.     private String name;// 商品名字
  7.     private double price;// 商品价格
  8.     private boolean isProduct;// 商品是否需要生产
  10.     public Goods() {
  11.     }
  13.     public Goods(String name, double price, boolean isProduct) {
  14.         this.name = name;
  15.         this.price = price;
  16.         this.isProduct = isProduct;
  17.     }
  19.     public String getName() {
  20.         return name;
  21.     }
  23.     public void setName(String name) {
  24.         this.name = name;
  25.     }
  27.     public double getPrice() {
  28.         return price;
  29.     }
  31.     public void setPrice(double price) {
  32.         this.price = price;
  33.     }
  35.     public boolean isProduct() {
  36.         return isProduct;
  37.     }
  39.     public void setProduct(boolean isProduct) {
  40.         this.isProduct = isProduct;
  41.     }
  43.     @Override
  44.     public String toString() {
  45.         return "Goods [name=" + name + ", price=" + price + ", isProduct=" + isProduct + "]";
  46.     }
  48. }
  50. //生产者
  51. class Producer implements Runnable {
  52.     private Goods goods;
  54.     public Producer(Goods goods) {
  55.         this.goods = goods;
  56.     }
  58.     @Override
  59.     public void run() {
  60.         int count = 0;
  61.         while (true) {
  62.             synchronized (goods) {
  63.                 if (goods.isProduct()) {// true 需要生成
  64.                     if (count % 2 == 0) {// 偶数生成汉
  65.                         goods.setName("比亚迪汉");
  66.                         goods.setPrice(30);
  67.                     } else {// 奇数生产唐
  68.                         goods.setName("比亚迪唐");
  69.                         goods.setPrice(25);
  70.                     }
  71.                     // 生产完以后就不需要生产了 改为false
  72.                     goods.setProduct(false);
  73.                     System.out.println("生产者生产了：" + goods.getName() + "，价格为：" + goods.getPrice());
  74.                     count++;
  75.                     // 生产好了 唤醒消费者
  76.                     goods.notify();
  77.                 } else {
  78.                     System.out.println("3");
  79.                     // 不需要生产 生产者进入等待状态（阻塞）
  80.                     try {
  81.                         goods.wait();
  83.                     } catch (InterruptedException e) {
  84.                         // TODO Auto-generated catch block
  85.                         e.printStackTrace();
  86.                     }
  87.                     System.out.println("4");
  88.                 }
  89.             }
  90.         }
  91.     }
  92. }
  94. //消费者
  95. class Consumer implements Runnable {
  96.     private Goods goods;
  98.     public Consumer(Goods goods) {
  99.         this.goods = goods;
  100.     }
  102.     @Override
  103.     public void run() {
  104.         while (true) {
  105. //            System.out.println("睡一会儿再买");
  106.             try {
  107.                 Thread.sleep(1000);
  108.             } catch (InterruptedException e1) {
  109.                 // TODO Auto-generated catch block
  110.                 e1.printStackTrace();
  111.             }
  112.             synchronized (goods) {
  113.                 // 如果是true 需要生成 就是没商品
  114.                 if (!goods.isProduct()) {// false
  115.                     // 不需要生成
  116.                     System.out.println("消费者购买了：" + goods.getName() + "：价格为" + goods.getPrice());
  117.                     // 购买完商品就没了
  118.                     goods.setProduct(true);
  119.                     // 唤醒生产者去生产
  120.                     goods.notify();
  121.                 } else {
  122.                     System.out.println("1");
  123.                     // 需要生成 消费者进入阻塞状态
  124.                     try {
  125.                         goods.wait();
  126.                         continue;
  127.                     } catch (InterruptedException e) {
  128.                         // TODO Auto-generated catch block
  129.                         e.printStackTrace();
  130.                     }
  131.                     System.out.println("2");
  132.                 }
  133.             }
  134.         }
  135.     }
  137. }
  139. public class Demo1 {
  140.     public static void main(String[] args) {
  141.         Goods goods = new Goods("比亚迪汉！！！", 178, false);
  143.         Consumer consumer = new Consumer(goods);
  144.         new Thread(consumer, "消费者线程").start();
  146.         Producer producer = new Producer(goods);
  147.         new Thread(producer, "生产者线程").start();
  149.     }
  151. }

匿名内部类写法【简写】

  1. package com.qfedu.test4;
  3. //创建线程的第三种方式
  4. public class Demo1 {
  5.     public static void main(String[] args) {
  6.         Thread thread = new Thread(new Runnable() {
  8.             @Override
  9.             public void run() {
  10.                 for (int i = 0; i < 10; i++) {
  11.                     System.out.println(i);
  12.                 }
  13.             }
  14.         });
  15.         thread.start();
  17.         new Thread(new Runnable() {
  19.             @Override
  20.             public void run() {
  21.                 for (int i = 0; i < 10; i++) {
  22.                     System.out.println(i);
  23.                 }
  24.             }
  25.         }).start();
  26.     }
  28. }

五、创建线程的第三种方式

1.创建Callable接口的实现类，并实现call方法，该call方法有返回值，在去创建Callable的实现类对象
2.使用一个类 FutureTask这个类去包装Callable 对象，FutureTask对象变相的封装了call方法
3.使用Futruetask对象作为Thread对象的参数并启动新线程
4.可以使用FutureTask.get()这个的对象获取子线程执行结束返回值

  1. package com.qfedu.test4;
  3. import java.util.concurrent.Callable;
  4. import java.util.concurrent.ExecutionException;
  5. import java.util.concurrent.FutureTask;
  7. class MyThread implements Callable<String>{
  9.     @Override
  10.     public String call() throws Exception {
  11.         // TODO Auto-generated method stub
  12.         for (int i = 0; i < 5; i++) {
  13.             System.out.println(Thread.currentThread().getName() + "啥啊");
  14.         }
  15.         return "aaaa";
  16.     }
  18. }
  19. public class Demo2 {
  20.     private static final int String = 0;
  22.     public static void main(String[] args) throws InterruptedException, ExecutionException {
  23.         MyThread myThread1 = new MyThread();
  24.         MyThread myThread2 = new MyThread();
  26.         FutureTask<String> task1 = new FutureTask<String>(myThread1);
  27.         FutureTask<String> task2 = new FutureTask<String>(myThread2);
  29.         new Thread(task1,"线程1").start();
  30.         new Thread(task2,"线程2").start();
  32.         System.out.println(task1.get());
  33.     }
  35. }