为什么要使用多线程

Java天生就是多线程程序，简单的一个main() 方法的执行，其实是由main线程和其它的线程共同执行的。当然使用多线程有如下的好处：

        1、利用更多的处理器核心

        2、更快的响应速度，如将数据一致性不强的操作交给其它的线程去操作

        3、更好的编程模型

线程简介

一、线程优先级

在线程执行过程中，线程优先级决定了需要分配处理器资源的多少，从而决定了获取时间片的多少。现在线程构建时，可以通过setPriority()方法来修改优先级，默认优先级是5.但是在不同的JVM以及操作系统上面，线程的规划有些不同，甚至有些操作系统会忽略对线程优先级的设定，都是采用默认值。

二、线程状态

线程状态

Daemon 是一种支持线程，主要用来支持程序的后台的调度，所以当Java虚拟机中不存在非Daemon线程（main 线程）时，Java虚拟机将会退出。

import java.util.concurrent.TimeUnit;      /**   * Created by shidong.wu on 2017/10/13.   */   public class Daemon {       public static void main(String[] args) {           Thread thread = new Thread(new DaemonRunner(),"DaemonRunner");           thread.setDaemon(true);           thread.start();       }       static class DaemonRunner implements Runnable {           @Override           public void run() {               try {                   TimeUnit.SECONDS.sleep(10);               }catch (InterruptedException e) {                  }finally {                   System.out.println("Daemon finally");               }           }       }   }  

运行上面的程序终端没有任何输出，主要是因为非Daemon线程(main线程)运行结束后，Java虚拟机退出了，所以DaemRunner中的finally代码块没有执行。

三、中断

中断可以理解为线程的一个标识位属性，它标识一个线程是否其它的线程进行的了中断操作。其它的线程通过调用当前线程的interrupt()方法对其进行中断操作。线程通过方法isInterrupt()方法来检查自身是否被中断来进行响应。抛出InterruptException的线程的，他的中断标识会被清除。

线程间通信

一、volatile 和synchronized 关键字

在前面的已经讲过它们的内存含义了，

1、关键字volatile用来修饰一个字段(变量)，就是告诉程序任意一个线程，对该变量的读取都要去共享内存中获取，而都变量的修改必须要同步刷新到共享内存里，volatile保证了所有线程的对变量的访问可见性。但是过多的使用volatile，会影响程序的执行效率。

        2、关键字synchronized用来修饰方法和代码块，它主要保证多个线程在同一时刻，只能有一个线程处于synchronized修饰的方法和代码块中，其本质是对一个对象监视器（Monitor）的获取，这个获取的过程是排他的，同一个时刻，只能有一个线程能获取大对象的监视器。没有获取到监视器的线程进入同步队列，等待其他线程释放锁。如下图：

二、等待/通知机制

等待 / 通知机制是指一个线程A调用了对象O的wait()方法，释放锁，进入等待状态，而线程B调用了对象O的notify()或者notifyAll()方法，线程A收到通知后从对象O的wait()方法返回，进而执行后面的操作。

等待 / 通知机制的经典范式，分为，消费者和生产者；

消费者遵循的规范：

1、获取对象的锁

2、如果条件不满足，调用对象的wait()方法，被通知后还要进行条检查

3、条件满足后执行对应的逻辑

对应的伪代码：

synchronized(对象){

while（条件不满足）{

对象.wait();

   }

对应的逻辑；

}

生产者遵循的规范：

1、获取对象的锁

2、改变条件

3、通知所有等待在该对象的线程

对此的伪代码：

synchronized （对象） {

改变条件；

       对象.notifyAll();

}

下面我们就利用上面的等待 / 通知的范式实现一个线程的等待/ 通知的机制；

 package com.concurrency;  import java.text.SimpleDateFormat; import java.util.Date; import java.util.concurrent.TimeUnit;  /**  * Created by shidong.wu on 2017/10/14.  */ public class WaitNotify {      private static boolean flag = true;       private  static Object lock = new Object();      public static void main(String[] args) throws Exception{         Thread waitThread = new Thread(new Wait(),"waitThread");         waitThread.start();         TimeUnit.SECONDS.sleep(1);          Thread notifyThread = new Thread(new Notify(),"notifyThread");         notifyThread.start();     }       static class Wait implements Runnable {         public void run() {             // 加锁，lock对象加锁             synchronized (lock) {                 while (flag){  // 条件不满足                     try {                         lock.wait();                     }catch (InterruptedException e){                     }                 }                 // 条件满足时，进行完成操作                 System.out.println(Thread.currentThread() + new SimpleDateFormat("HH:mm:ss").format(new Date()));             }         }     }      static class Notify implements Runnable {         public void run() {             // 加锁，lock对象加锁             synchronized (lock) {                 lock.notifyAll(); // 通知                 flag = false;              }         }     } }  

三、join() 使用

如果一个线程A调用了thread.join()表示线程A等待线程thread线程终止之后，才从threa.join()处返回。

四、ThreadLocal 使用

ThreadLocal 是一个线程变量，这个变量是附带在线程上面的。