• 创建线程两种方法：扩展Thread 类 ；实现Runnable 接口 。
    • Thread.States的线程状态：NEW、RUNNABLE、BLOCKED、WAITING、TIME_WAITING、TERMINATED
    • 操作系统线程状态：创建状态 、就绪状态 、运行状态 、阻塞状态 、死亡状态

    • callable区别：

      • 接口。有简单类型参数，与call()方法的返回类型相对应。
      • 声明了call()方法。执行器运行任务时，该方法会被执行器执行。它必须返回声明中指定类型的对象。
      • call()方法可以抛出任何一种校验异常。可以实现自己的执行器并重载afterExecute()方法来处
        理这些异常 。

    • callable代码示例： ```java // 有泛型、有返回值 class MyCallable implements Callable { @Override public String call() throws Exception {

      1.   Thread.sleep(5000);
      2.   return "hello world call() invoked!";

      } }

    public class Main { public static void main(String[] args) throws ExecutionException,InterruptedException { MyCallable myCallable = new MyCallable(); // 设置Callable对象，泛型表示Callable的返回类型 FutureTask futureTask = new FutureTask(myCallable); // 启动处理线程 new Thread(futureTask).start(); // 同步等待线程运行的结果 String result = futureTask.get(); // 5s后得到结果 System.out.println(result); } }

    2. - 锁对象的作用
    3. > 1. 这个对象内部得有一个标志位（state变量），记录自己有没有被某个线程占用。最简单的情况是这个state有0、1两个取值，0表示没有线程占用这个锁，1表示有某个线程占用了这个锁。
    4. > 2. 如果这个对象被某个线程占用，记录这个线程的thread ID。
    5. > 3. 这个对象维护一个thread id list，记录其他所有阻塞的、等待获取拿这个锁的线程。在当前线程释放锁之后从这个thread id list里面取一个线程唤醒。
    7. - 锁如何实现
    8. > 在对象头里，有一块数据叫Mark Word。在64位机器上，Mark Word是8字节（64位）的，这64位中有2个重要字段：锁标志位和占用该锁的thread ID。因为不同版本的JVM实现，对象头的数据结构会有各种差异。
    10. - 实现生产者消费者思路
    11. > 1. 内存队列本身要加锁，才能实现线程安全。(必须实现)
    12. > 2. 阻塞。当内存队列满了，生产者放不进去时，会被阻塞；当内存队列是空的时候，消费者无事可做，会被阻塞。
    13. > 3. 双向通知。消费者被阻塞之后，生产者放入新数据，要notify()消费者；反之，生产者被阻塞之后，消费者消费了数据，要notify()生产者。
    14. > 
    15. > - 如何阻塞
    16. >    - 线程自己阻塞自己，也就是生产者、消费者线程各自调用wait()和notify()。
    17. >    - 用一个阻塞队列，当取不到或者放不进去数据的时候，入队/出队函数本身就是阻塞的。
    18. > - 如何双向通知？
    19. >    - wait()与notify()机制。
    20. >    - Condition机制。
    23. // 单个生产者和消费者的情况
    24. ```java
    25. // 我的理解： 重点是先把阻塞队列实现了，剩下的都好说.jpg
    26. // 阻塞队列
    27. public class MyQueue {
    28.     private String[] data = new String[10];
    29.     private int getIndex = 0;
    30.     private int putIndex = 0;
    31.     private int size = 0;
    32.     public synchronized void put(String element) {
    33.         if (size == data.length) {
    34.             try {
    35.                 wait();
    36.             } catch (InterruptedException e) {
    37.                 e.printStackTrace();
    38.             }
    39.         }
    40.         data[putIndex] = element;
    41.         ++putIndex;
    42.         if (putIndex == data.length) putIndex = 0;
    43.         ++size;
    44.         notify();
    45.     } 
    46.     public synchronized String get() {
    47.         if (size == 0) {
    48.             try {
    49.                 wait();
    50.             } catch (InterruptedException e) {
    51.                 e.printStackTrace();
    52.             }
    53.         }
    54.         String result = data[getIndex];
    55.         ++getIndex;
    56.         if (getIndex == data.length) getIndex = 0;
    57.         --size;
    58.         notify();
    59.         return result;
    60.     }
    61. }
    63. public class Main {
    64.     public static void main(String[] args) {
    65.         MyQueue myQueue = new MyQueue();
    66.         ProducerThread producerThread = new ProducerThread(myQueue);
    67.         ConsumerThread consumerThread = new ConsumerThread(myQueue);
    68.         producerThread.start();
    69.         consumerThread.start();
    70.     }
    71. }
    73. // 生产者
    74. public class ProducerThread extends Thread {
    75.     private final MyQueue myQueue;
    76.     private final Random random = new Random();
    77.     private int index = 0;
    78.     public ProducerThread(MyQueue myQueue) {
    79.         this.myQueue = myQueue;
    80.     }
    81.     @Override
    82.     public void run() {
    83.         while (true) {
    84.             String tmp = "ele-" + index;
    85.             myQueue.put(tmp);
    86.             System.out.println("添加元素：" + tmp);
    87.             index++;
    88.             try {
    89.                 Thread.sleep(random.nextInt(1000));
    90.             } catch (InterruptedException e) {
    91.                 e.printStackTrace();
    92.             }
    93.         }
    94.     }
    95. }
    97. // 消费者
    98. public class ConsumerThread extends Thread {
    99.     private final MyQueue myQueue;
    100.     private final Random random = new Random();
    101.     public ConsumerThread(MyQueue myQueue) {
    102.         this.myQueue = myQueue;
    103.     } 
    104.     @Override
    105.     public void run() {
    106.         while (true) {
    107.             String s = myQueue.get();
    108.             System.out.println("\t\t消费元素：" + s);
    109.             try {
    110.                 Thread.sleep(random.nextInt(1000));
    111.             } catch (InterruptedException e) {
    112.                 e.printStackTrace();
    113.             }
    114.         }
    115.     }
    116. }

    // 多个消费者和生产者 Ps感觉不太对。。。。
    // notify 唤醒的可能还是生产者，感觉用到Condition
    // 把if改成whire

    1. public class MyQueue2 {
    2.     private String[] data = new String[10];
    3.     private int getIndex = 0;
    4.     private int putIndex = 0;
    5.     private int size = 0;
    7.     public synchronized void put(String element) {
    8.         //if (size == data.length) {
    9.         while (size == data.length) {
    10.             try {
    11.                 wait();
    12.             } catch (InterruptedException e) {
    13.                 e.printStackTrace();
    14.             }
    15.             put(element);
    16.         } else {
    17.             put0(element);
    18.             notify();
    19.         }
    20.     }
    21.     private void put0(String element) {
    22.         data[putIndex] = element;
    23.         ++putIndex;
    24.         if (putIndex == data.length) putIndex = 0;
    25.         ++size;
    26.     }
    28.     public synchronized String get() {
    29.         // if (size == 0) {
    30.         while (size == 0) {
    31.             try {
    32.                 wait();
    33.             } catch (InterruptedException e) {
    34.                 e.printStackTrace();
    35.             }
    36.             return get();
    37.         } else {
    38.             String result = get0();
    39.             notify();
    40.             return result;
    41.         }
    42.     }
    43.     private String get0() {
    44.         String result = data[getIndex];
    45.         ++getIndex;
    46.         if (getIndex == data.length) getIndex = 0;
    47.         --size;
    48.         return result;
    49.     }
    50. }

    • 伪代码：生产消费线程 ```java public void enqueue() {

      1.   synchronized (queue) {
      2.       while (queue.full()) {
      3.           queue.wait();
      4.       } //... 数据入列
      5.       queue.notify(); // 通知消费者，队列中有数据了。
      6.   }

      }

      public void dequeue() {

      1.   synchronized (queue) {
      2.       while (queue.empty()) {
      3.           queue.wait();
      4.       } // 数据出队列
      5.       queue.notify(); // 通知生产者，队列中有空间了，可以继续放数据了。
      6.   }

      }

    ```

    • InterruptedException

      如果不是那些显示捕获这个异常的方法，那么不会抛出异常

      thread.interrupted()的精确含义是“唤醒轻量级阻塞”，而不是字面意思“中断一个线程”。

    • 轻量级阻塞和重量级阻塞

    image.png

    • 关于interrupt

      thread.isInterrupted()与Thread.interrupted()的区别因为 thread.interrupted()相当于给线程发送了一个唤醒的信号，所以如果线程此时恰好处于WAITING或者TIMED_WAITING状态，就会抛出一个InterruptedException，并且线程被唤醒。而如果线程此时并没有被阻塞，则线程什么都不会做。但在后续，线程可以判断自己是否收到过其他线程发来的中断信号，然后做一些对应的处理。
      这两个方法都是线程用来判断自己是否收到过中断信号的，前者是实例方法，后者是静态方法。二
      者的区别在于，前者只是读取中断状态，不修改状态；后者不仅读取中断状态，还会重置中断标志位。

    • thread.isInterrupted()与Thread.interrupted()的区别