JAVAday31

 1.Callable<Object> 是接口  在并发包下的
     Runnable ， 提供了 带有返回值的线程体 
     重写call方法，在启动线程时，需要一个FutrueTask辅助类帮助启动
     
     FutrueTask t = new FutrueTask(callable);
     
     new Thread(Runnable a); 
   
     t.get();  获取call方法的返回值
     t.cancel(); 终止 线程执行
     
   2.synchronized 关键字      互斥锁
     Lock 锁 ， 接口 ， 必须用  
        |-- ReetrantLock;
                 lock(); 手动上锁
                 unlock();  手动释放锁 ， 一般用于 finally 块儿
        |-- ReadWriterLock  读写锁
        
   3.闭锁： CountDownLatch    维护了一个变量， 这个变量的值 是线程的个数 
       跟join 阻止正在运行的线程， 让其进入挂起状态，
         直到 子线程运行完毕， 才能继续执行 
        
        count = new CountDownLatch(int count);
        
        run, call
        count.countDown();    - 1   0 
        count.await();  阻止正在运行的线程进入阻塞状态
        
    4.同步容器: 所有线程安全的 集合
          ArrayList:null 
          Vector ： 不会
          List list = Collections.synchronizedList(new ArrayList());    
        虽然是线程安全的，但是不支持 复合操作 ， 一个时间段 ，执行两个任务
          next();
          add(); 
        会出现并发修改异常 ConcurrentModificationException
         
       线程安全， 不支持复合操作    Hashtable： 独占锁 ， 线程安全， 串行
              线程安全， 还支持复合操作
          ConcureentHashMap： 分段锁机制， 16 ，Segment[]
      
     5. 静态 和  非静态方法
             在多线程 并发的情况下，各自持有几个锁 
 
    6.线程八锁： 
        1)    2个普通的同步方法，  一个对象        一把锁
        2)    2个普通的同步方法，  二个对象       二把锁
        3)    一个 静态同步方法， 一个非静态同步方法，  一个对象     二把锁
        4)    一个静态的同步方法， 一个非静态同步方法   二 个对象    二把锁
        5)    2个 静态同步 方法     一个对象 ， 一把锁
        6)    2个静态方法 ， 两个对象  ，  一把锁
        7)    两个普通的同步方法，一个  非同步方法 ，   一个对象 ， 
         8) 在同步方法中添加 Thread.sleep方法 ，

    7.线程池:  
        原理：里面维护了 一个线程队列
                  好处： 不需要自己创建 线程和 销毁线程， 大大提高了性能
        ExcuteService service =
         Executors.newFixedThreadPool(int count);
         Executors.newSingalThreadExcutor();
         Executors.newCacheThreadPool(); 
         
        service.submit(); 分配任务  
        service.shutDown(); 销毁线程池
}
------------------------------------------------
JUC_Day02:
  1.volatile:关键字
    
  2.原理变量类： 
      java.util.concurrent.atomic.* 
     
    AtomicInteger： 维护了一个 volatile 关键字修改的 int 变量
        常用方法: get();
                 incrementAndGet();   ++i
                  getAndIncrement();      i++  
                  getAndDecrement();   i--
                 decrementAndGet();   --i;
----------------------------------------------------------
线程之间的通讯: 
   1.Object ：
           notify();
           notifyAll();
           wait(); 
           
   2.Condition ： 使用条件 必须绑定一个 Lock锁的实例
      
Lock lock = new ReetrantLock();
           
            lock.newCondition(); 线程之间的通讯

Object类 的方法 和 Condition 方法对比: 
   Object 类 wait方法   和  await(); 功能一致
             notify方法  和  signal();
             notifyAll(); 和 signalAll();
             
注意Condition在使用时 必须 持有 Lock锁的实例
 就是不能unlock();             
-----------------------------------------------
   3.读写锁 
          ReentrantReadWriteLock.
             调用. ReadLock().lock(); 
          ReentrantReadWriteLock.WriteLock();
                      调用. WriteLock().lock(); 
        unlock();
        unlock();
        
   4.分支合并框架ForkJoinPool : jdk1.8提供的 分支合并框架
          机制 "工作窃取" 机制

分支合并框架是 jdk 1.7提供的，只不过是在 jdk1.8才被使用
 原理是 将大任务拆分成若干小份，进行递归执行，从而达到
 提高解决问题的效率;
  ForkJoinPool 是用来执行 整体任务
        
        Object obj = invoke(任务类);
         
 我们在拆分时需要使用 RecursiveTask(带返回值) ， RecursiveAction(不带返回值)
   帮我们做递归拆分， 

RecursiveTask类中的方法: 
   fork(); 拆分
   join(); 合并