实战Java高并发程序设计（二）Java并行程序基础

• 进程与线程
  
  1. 进程（Process）是计算机中的程序关于某数据集合上的一次运行活动，是系统进行资源分配和调度的基本单位，是操作系统结构的基础。进程是程序的容器。
  2. 线程（Thread）是CPU调度的最下单位，它是建立在进程的基础上运行的。
  3. 使用多线程而不使用多进程的原因是，线程间的切换和调度的成本远小于进程。
  4. 线程的State有一下几种：
     (1) NEW：线程还没有开始执行。
     (2) RUNNABLE:：线程正在JVM中执行。
     (3) BLOCKED：线程被阻塞并等待一个监听锁
     (4) WAITING：线程无限期等待另一条线程执行特定的操作。
     (5) TIMED_WAITING：在特定时间内等待另外一条线程执行。
     (6) TERMINATED：线程退出。

• 线程的操作

  1. Thread的run方法和start方法的区别（重要）
     
     • start方法会新建一个线程，并让这个线程执行run方法。
     • run方法不会新建线程，而是在当前线程中串行执行run方法。
  2. Thread有一个重要的构造函数Public Thread(Runnable target)。此时执行start或者run方法时，就会执行target对象的run方法。

  3. 线程终止，不要使用stop()方法，调用这个方法会立即终止一个线程，但是由于它太过暴力，可能会出现数据不一致的问题。我们可以自定义方法，让线程在某个合适的位置退出。

     boolean flag = false;
     public void stopMe(){//该方法用于停止该线程
         flag = true;
     }
     @Override
     public void run(){
         while(true){
         if(flag){
             break;
         }
         //Do Something
         }
     }
     

  4. 线程中断不会让线程马上退出，而是给线程发送一个通知，告诉它有人希望它退出。中断能够作用在sleep()或者wait()的操作上。

     public static void Thread.interrupt() //中断线程
     public static boolean Thread.isInterrupted() //判断是否被中断
     public static boolean Thread.interrupted() //判断是否被中断，并清除当前中断状态

     • 注意：Thread.sleep()方法由于中断而抛出异常后，会清空中断标记，如果sleep外面嵌套循环，我们需要在catch中在再次设置中断标记位：Thread.currentThread().interrupt();，否则第二次循环无法捕捉到这个中断。

  5. 等待(wait)和通知(notify)
        这两个方法是Object类的方法，任何对象都能够调用。
        Object.wait()和Object.notify)方法调用有个前提，它必须包含在对应的synchronzied的语句中:

     synchronized(object){
         object.wait();
         object.notify);
     }

     这是因为在执行wait和notify的时候，需要先获得object的监视器。

  6. 挂起(suspend)和继续执行(resume)
        suspend不推荐使用，因为它在暂停线程的同时，不会释放任何资源。如果resume()操作意外地在suspend()之前执行，那么被挂起的线程可能很难继续执行，那么这些资源就无法被释放。而且，对于被挂起的线程，从线程的状态上看还是Runnable的，这会严重影响我们对系统当前状态的判断。

  7. 等待线程结束(join)和谦让(yield)

     1. join的作用是让该线程执行完，当前线程再继续执行。其本质是在当前线程上调用wait()。请看如下代码:

           puiblic volatile static int i = 0;
           public static class MyThread extends Thread{
                public void run(){
                    for(i=0;i<100000;i++);
                }
            }
            public static void main(){
                MyThread mt = new MyThread();
                mt.start();
                mt.join();
                System.out.println(i);
            }

           如果没有mt.join()，那么输出的i很有可能是0或者一个很小的值，但是有了mt.join()，输出的i肯定是100000。

     2. yield的作用是使得当前线程让出CPU，但是之后该线程还是会继续抢夺CPU资源。我们可以对某个不重要或者优先级较低的线程，并且害怕它占用太多的CPU资源，那么就可以适当地调用Thread.yield()。

  8. volatile关键字
        该关键字是用来保证某个变量的可见性的。具体应用如下:

     public class A{
     public volatile static long t=0;
     public static class AddThread implements Runnalbe{
        private long value;
         public AddThread (long value){
             this.value = value;
         }
        public void run(){
            while(true){
                A.t = value;
            }
        }
     }
     }

        我们知道，对long的操作本身是没有原子性的，如果不加volatile关键词，对A.t的赋值操作可能会失败，出现错误值。但是加了该关键字之后，就能保证对long操作的原子性。

        但是volatile关键字无法保证i++的原子性，这需要锁来保证。但是volatile能够保证数据的可见性和有序性。

  9. 守护线程（Daemon）
        在一个Java应用中，如果只有守护线程，那么Java虚拟机就会自然退出。注意：守护线程的设置必须要在线程start之前，否则设置会失败。

  10. 线程优先级（priority）
      在Java中，线程优先级分为10级（1到10），数字越大，优先级越高。一般可以用三个内置静态标量表示：

      public final static int MIN_PRIORITY = 1;
      public final static int NORM_PRIORITY = 5;
      public final static int MAX_PRIORITY = 10;

  11. synchronized关键字
         synchronized关键字得到作用是实现线程同步。它的作用是对同步的代码加锁，使得每一次，只能有一个线程进入同步块，从而保证线程间的安全性。它有以下三种用法：

      指定加锁对象：对给定对象加锁，进入同步代码前要获得给定对象的锁。

      Object obj = new Object();
      synchronized(obj){
      }

      直接作用于实例方法：相当于对当前实例加锁，进入同步代码前要获得当前实例的锁。

      Object obj = new Object();
      public synchronized void increase(){
        i++;
      }
      public void run(){
        for(int i=0;i<100000;i++){
            increase();
        }
      }
      public static void main(){
          Thread t1 = new Thread(obj);
          Thread t2 = new Thread(obj);
      }

      直接作用于静态方法：相当于对当前类加锁，进入同步代码前要获得当前类的锁。

      public static synchronized void increase(){
        i++;
      }

         除了用于线程同步、确保线程安全外，它还可以保证线程间的可见性和有序性。
         注意:以下代码会导致加锁失败。因为Integer属于不变对象，即该对象一旦创建之后，它的值就不会改变。当i的值改变时，会新创建一个对象，因此i随着自增，在不断创建新对象。

      public static Integer i = 0;
      public void run(){
       for(int j=0;j<10000;j++){
           synchronized(i){
               i++;
           }
       }
      }