线程复习笔记

1 线程的三种方式：
    A 实现Runnable接口  new Thread(new MyRunnable()).start();
    B 继承Thread类
    C Callable与Future方式
2 中断线程
    interrupt方法请求终止线程（线程的中断状态被置位）
    isInterrupted方法，检查这个中断状态
    while( !Thread.currentThread().isInterrupted() ) {  do more work!}
    注：有个静态方法interrupted,也是用来测试当前线程是否被中断，但是这一方法会产      生副作用--他将当前现在的中断状态置为false.
3 线程的六种状态：
    new(新生)、runnable(可运行)、blocked(阻塞)、
    waitng(等待)、timed waiting(计时等待)、terminated(终止)
    当一个线程视图获取一个内部的对象锁，而该锁被其他线程持有，则该线程进入阻塞状态。当线程等待另一个线程通知调度时，他自己进入等待状态。如调用Object.wait或者
     Thread.join
4 wait和sleep区别
    a:sleep() 方法是使线程停止运行一段时间，sleep时间间隔期满后，线程不一定立即恢       复运行。
      wait()是线程交互式，如果线程对一个同步对象（方法）发出一个wait调用，改线程会暂停执行，被调用对象（方法）进入等待状态，直到被唤醒。
    b:Sleep时别的线程也不可以访问锁定对象（睡着也抱着锁）； 
       Wait时别的线程可以访问锁定对象（调用wait，锁就撒手）；
5 锁
    a:synchronized 如：public synchronized void push(char c)；
    b:java.util.concurrent.locks.ReentrantLock类，
    ReentrantLock(boolean fair)
    这个构造方法还可以创建一个带有公平策略的锁。公平锁偏爱等待时间最长的线程。但是，这一公平的保证将大大降低性能。
    注：如果线程调度器选择忽略一个线程，而该线程为了这个锁已经等待很长时间了，哪么也没有几乎公平处理这个锁。
    class X {
      private final ReentrantLock lock = new ReentrantLock();
      public void m() { 
        lock.lock(); // block until condition holds
      try {
         // ... method body
      } finally {
      lock.unlock()
      }
     }
    }
 补充volatile关键字
    有时候为了读写一两个实例域就使用同步，显然开销会很大。这里推荐使用volatile关键字。
         private boolean done;
         public synchronized boolean getDone(){return done;}
         public synchronized void setDone(boolean done) {this.done = done;}
      相当于：
         private volatile boolean done;
         public boolean getDone(){return done;}
         public void setDone(boolean done) {this.done = done;}


6 新的锁控制和应用例子
class Bank
{
   private Lock bankLock;
   private Condition sFouds;


   public Bank()
   {
      bankLock = new ReenTrantLock();
      sFouds = bankLock.newCondition();//条件叫余额充足
   }


   public void transfer()
  {
     backLock.lock();
     while(acounts[forms] < amount)
    {
        sFouds.await();
    }
    //do more work
    sFouds.signalAll();
   }
}


7.内部的锁和条件存在一些局限(synchronized)
    a不能中断一个正在试图获得锁的线程。
    b视图获得锁时不能设定超时。
    c每个锁仅有单一条件，可能不够。


8.特殊锁
    synchronized(obj) { ... }
    使用一个对象的锁定来实现额外的原子操作，称为客户端锁定。client-side locking
    客户端锁定非常脆弱，通常不推荐使用。


9.读写锁
  java.util.concurrent.locks.ReentrantReadWriteLock类
  如果很多线程从一个数据结构读取数据，而很少线程修改其中的数据的话，此类非常有用。
  private ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();
  private Lock readLock = rwl.readLock();
  private Lock writeLock = rwl.writeLock();
  public doble getTBalance()
  {
    readLock.lock();
    try { ... }
    finally {readLock.unlock();}
  }
  public void transfer()
 {
    writeLock.lock();
    try { ... }
    finally {writeLock.unlock();}
  }


10.死锁
  public class DeadLock extends Thread { 


  int flag=0; 
  static Object o1=new Object(); 
  static Object o2=new Object(); 


  public DeadLock(int flag){ 
     this.flag=flag; 
   } 
  @Override 
  public void run() { 
     if(this.flag==1){ 
       synchronized(o1){ 
          System.out.println(Thread.currentThread().getName()+"锁定对象o1"); 
          try { 
              Thread.sleep(1000);//让另一个线程能进入另一块区域，锁定对象o2 
          } catch (InterruptedException e) { 
              e.printStackTrace(); 
          } 
         synchronized(o2){ 
              System.out.print("this.flag="+this.flag); 
          } 
       } 
     }
     if(this.flag==2){ 
         synchronized(o2){ 
            System.out.println(Thread.currentThread().getName()+"锁定对象o2"); 
            try { 
                 Thread.sleep(1000);//让另一个线程能进入另一块区域，锁定对象o1 
             } catch (InterruptedException e) { 
                         e.printStackTrace(); 
             } 
             synchronized(o1){ 
                 System.out.print("this.flag="+this.flag); 
             } 


         } 
     }
  } 


 public static void main(String []args){ 
    DeadLock d1=new DeadLock(1); 
    DeadLock d2=new DeadLock(2); 
    d1.start(); 
    d2.start(); 
  } 
}




11.经典生产者与消费者
class SyncStack{ 
   private int index = 0; 
   private char []data = new char[6]; 


   public synchronized void push(char c){ 
      if(index == data.length){ 
       try{ 
         this.wait(); 
       }catch(InterruptedException e){} 
      } 
      this.notify(); 
      data[index] = c; 
      index++; 
   } 
   public synchronized char pop(){ 
      if(index ==0){ 
        try{ 
          this.wait(); 
        }catch(InterruptedException e){} 
      } 
      this.notify(); 
      index--; 
      return data[index]; 
   } 
  }


 class Producer implements Runnable{ 
      SyncStack stack; 
      public Producer(SyncStack s){ 
         stack = s; 
       } 
      public void run(){ 
        for(int i=0; i<20; i++){ 
         char c =(char)(Math.random()*26+'A');// 
         stack.push(c); 
         System.out.println("produced："+c); 
         Thread.sleep((int)(Math.random()*1000)); 
        } 
     } 
 } 


class Consumer implements Runnable{ 
   SyncStack stack; 
   public Consumer(SyncStack s){ 
      stack = s; 
    } 
   public void run(){ 
      for(int i=0;i<20;i++){ 
         char c = stack.pop(); 
         System.out.println("消费："+c); 
         Thread.sleep((int)(Math.random()*1000)); 
      } 
   } 
}


public class ProduceConsumer { 
   public static void main(String args[]){ 
      SyncStack stack = new SyncStack(); 
      Runnable p=new Producer(stack); 
      Runnable c = new Consumer(stack); 
      Thread t1 = new Thread(p); 
      Thread t2 = new Thread(c); 
      t1.start(); 
      t2.start(); 
   } 
}




12 阻塞队列
  阻塞队列方法分3类，取决与队列满时或空时他们的响应方式，
    如果将队列当做线程管理工具来使用，将要使用put和take方法，满或空，线程阻塞。
    add、 element 、remove和操作抛出异常。
    在一个多线程程序中，队列会在任何时候空或者满，offer、poll、peek,这些方法有返回值。
    java.util.concurrent包提供了阻塞队列的几个变种
       LinkedBlockingQueue 容量默认为int的最大值，也可以指定最大容量。
       LinkedBlockingDeque 是一个双端版本。
       ArrayBlockingQueue 在构造时需指定容量，并且有个可选的参数来指定是否需要公平性。若设置了公平参数，则等待最长时间的线程会优先处理，
                          这一设置会降低性能。
       PriorityBlockingQueue 带优先级的队列




13 Callable与Future
    Runable封装的一个异步运行的任务，可以把它想象成一个没有参数和返回值的异步方法。
    Callable与Runnable类似，但是有返回值。Future保存异步计算的记过，get方法调用被阻塞，直到计算完成。
    FutureTask包装器是一种非常便利的机制，可将Callable接口转换成Future和Runable,它同时实现二者接口。
   例如：
   Callable<Integer> myComputation = ...;
   FutureTask<Integer> task = new FutureTask<Integer>(myComputation)
   new Thread(task).start();
    Integer result = task.get();
例如：
   class MatchCounter implements Callable<Integer>
   {
       private File startDir;
       private String keyword;
       private int count;


       public MatchCounter(File startDir,String keyword)
      {
         this.startDir = startDir;
         this.keyword = keyword;
      }


      @Override
      public Integer call() throws Exception
     {
        count = 0;


        File[] files = startDir.listFiles();
        ArrayList<Future<Integer>> results = new ArrayList<Future<Integer>>();


        for(File f: files) {
          if(f.isDirectory()){
                MatchCounter counter = new MatchCounter(f,keyword);
                FutureTask<Integer> task = new FutureTask<Integer>(counter);
                results.add(task);
                new Thread(task).start(); 
          } else{
            if(search(f)){
                count ++;
            }
          }
       }


    for(Future<Integer> result : results)
    {
      count += result.get();
    }
      return count;
   }


public boolean search(File file) {
    boolean flag = false;
    try
    {
        Scanner in = new Scanner(file);
       while(in.hasNextLine() && !flag)
       {
           String str = in.nextLine();
           if(str.contains(keyword))
           {
               flag = true;
            }
        }
        in.close();
     }
      catch (FileNotFoundException e)
     {
        e.printStackTrace();
     } 
      return flag;
    }
}




14 执行器Executor
   使用线程池理由：
      a:线程池包含许多空闲线程，当一线程退出时，线程不会死亡，而是在池中准备为下一请求提供服务。
      b:使用线程池可以减少并发线程的数目。（创建固定线程数的线程池）
    Executors类有许多静态工厂方法用来构建线程池，如：
       newCachedThreadPool 必要时创建新线程；空闲线程会被保留60秒
       newFuxedThreadPool 该池包含固定数量的线程；空闲线程一致被保留
       newSingleThreadExecutor 只有一个线程的池，该线程顺序执行每一个提交的任务
       newScheduledThreadPool 用于预定执行而构建的固定线程池，替代java.util.Timer
       newSingleThreadScheduledExecutor 用于预定执行而构建的单线程池。
   使用线程池应该做的事：
      1)调用Executors类中的静态方法产生线程池。
      2)调用submit提交Runable或Callable对象，该方法返回值为Future对象。
      3)如果想要取消一个任务，或如果提交Callable对象，那就要保存好返回的Future对象。
      4)当不再提交任务时，调用shutdown。
      ExecutorService pool = Executors.newCachedThreadPool();
      MatchCounter counter = new MathcCounter(...);
      Futurn<Integer> countResult = pool.submit(counter);


   ExecutorService接口常用方法
      invokeAll 执行给定的任务，当所有任务完成时，返回保持任务结果的 Future 列表
          List<Callable<T>> tasks = ...?;
          List<Future<T>> results = executorService.invokeAll(tasks);
      invokeAny 执行给定的任务，如果某个任务已成功完成（也就是未抛出异常），则返回其结果。
          <T> T invokeAny(Collection<? extends Callable<T>> tasks)
      shutdown 启动线程依此顺序关闭，执行以前提交的任务，但不接受新任务
      List<Runnable> shutdownNow() 试图停止所有正在执行的活动任务，暂停处理正在等待的任务，并返回等待执行的任务列表。
      submit 提交一个任务。




15 预定执行
   ScheduleExecutorService接口具有为预定执行（Scheduled Execution)或重复执行而设计的方法。
   Executors类的newScheduledThreadPool 和newSingleThreadScheduledExecutor方法返回实现了ScheduledExecutorService接口的对象。
   java.util.concurrent.ScheduledExecutorService:
        ScheduledFuture<?> schedule(Runnable command, long delay,TimeUnit unit) 预定在指定的时间之后执行
       ScheduledFuture<?> scheduleAtFixedRate(Runnable command,long initialDelay,long period,TimeUnit unit)
          command - 要执行的任务
          initialDelay - 首次执行的延迟时间
          period - 连续执行之间的周期
          unit - initialDelay 和 period 参数的时间单位




16 门闩java.util.concurrent.CountDownLatch
   CountDownLatch
     一个同步辅助类，在完成一组正在其他线程中执行的操作之前，它允许一个或多个线程一直等待。 
     await() 使当前线程在锁存器倒计数至零之前一直等待，除非线程被中断。 
     await(long timeout, TimeUnit unit) 使当前线程在锁存器倒计数至零之前一直等待，除非线程被中断或超出了指定的等待时间。 
     countDown() 递减锁存器的计数，如果计数到达零，则释放所有等待的线程。
     CountDownLatch 很适合用来将一个任务分为n个独立的部分，等这些部分都完成后继续接下来的任务，CountDownLatch 只能出发一次，计数值不能被重置。
     例：一个项目可以分为多个模块，只有但这些模块都完成后才可以继续下一步的工作。
     class Module implements Callable<Integer>
     {
        private CountDownLatch latch;
        private String moduleName;
        private int time;


        public Module(CountDownLatch latch, String moduleName, int time)
       {
           this.latch = latch;
           this.moduleName = moduleName;
           this.time = time;
        }


        private void work() throws InterruptedException
        {
           TimeUnit.MILLISECONDS.sleep(time);
           System.out.println(moduleName + " 完成，耗时:" + time);
         }


       @Override
       public Integer call() throws Exception
       {
          work();
          latch.countDown();
          return time;
       }
     }


    class Controller implements Runnable
    {
          private CountDownLatch latch; 
          private List<Future<?>> runResults; 
          int count = 0;


          public Controller(CountDownLatch latch,List<Future<?>> runResults)
         {
            this.latch = latch;
            this.runResults = runResults;
          }


         @Override
         public void run()
         {
            latch.await();
            for(Future<?> f : runResults)
            {
                count = count + (Integer)f.get();
            } 
            System.out.println("所有模块都完成,耗时:" + count); 
          }
     }


     public class Project
     {
         static final int SIZE = 20;
         public static void main(String[] args) throws InterruptedException, ExecutionException
        {
             List<Future<?>> runResults = new ArrayList<Future<?>>(); 
             CountDownLatch latch = new CountDownLatch(SIZE); 
             ExecutorService exec = Executors.newCachedThreadPool(); 
             for (int i = 0; i < SIZE; i++)
             {
                 Future temp = exec.submit(new Module(latch, "模块" + (i + 1), (i + 1)));
                 runResults.add(temp);
              }


              Controller controller = new Controller(latch,runResults);
              exec.submit(controller);


              exec.shutdown();


        }
    }




17 栅栏java.util.concurrent.CyclicBarrier


       一个同步辅助类，它允许一组线程互相等待，直到到达某个公共屏障点 (common barrier point),线程才继续开始执行任务.
       在涉及一组固定大小的线程的程序中，这些线程必须不时地互相等待，此时 CyclicBarrier 很有用。因为该barrier在释放等待线程后可以重用，
       所以称它为循环的barrier。CyclicBarrier可以多次重复使用.


       await() 在所有参与者都已经在此 barrier 上调用 await 方法之前，将一直等待
       await(long timeout, TimeUnit unit) 在所有参与者都已经在此屏障上调用 await 方法之前将一直等待,或者超出了指定的等待时间。


        3个玩家同时进行通关游戏,当他们都到达或通过某一关后，才可继续往下过关.


        class GameGate
        {
           // 关名称
           private String barrierName;
           // 玩家通关时间
           private int passTime;


           public GameGate(String barrierName, int passTime)
           {
                this.barrierName = barrierName;
                this.passTime = passTime;
           }


          public String getBarrierName()
          {
              return barrierName;
           }


          public int getPassTime()
          {
              return passTime;
           }
       }




      class GameRunable implements Runnable
      {


         // 游戏关集合
         private List<GameGate> gameGates;


         // 玩家名称
         private String gamePlayer;


         private CyclicBarrier cyclicBarrier;


         public GameRunable(List<GameGate> gameGates, String gamePlayer,CyclicBarrier cyclicBarrier)
        {
               this.cyclicBarrier = cyclicBarrier;
               this.gameGates = gameGates;
               this.gamePlayer = gamePlayer;
         }


         public void run()
         {
            try
           {
              for (GameGate gameBarrier : gameGates)
              {
                    Thread.sleep(gameBarrier.getPassTime() * 1000);
                    System.out.println(gamePlayer + " passed game barrier " + gameBarrier.getBarrierName());
                    cyclicBarrier.await();
               }
           } 
         }


       public static void main(String[] args) {
          CyclicBarrier barrier = new CyclicBarrier(3);


          // 为玩家1建立通关任务
          List<GameGate> playerOneGates = new ArrayList<GameGate>(4);
          playerOneGates.add(new GameGate("第一关", 5));
          playerOneGates.add(new GameGate("第二关", 60));
          playerOneGates.add(new GameGate("第三关", 8)); 
          GameRunable task1 = new GameRunable(playerOneGates, "张三", barrier);


         // 为玩家2建立通关任务
          List<GameGate> playerTwoGates = new ArrayList<GameGate>(4);
          playerTwoGates.add(new GameGate("第一关", 1));
          playerTwoGates.add(new GameGate("第二关", 6));
          playerTwoGates.add(new GameGate("第三关", 3));
          GameRunable task2 = new GameRunable(playerTwoGates, "李四", barrier);


         // 为玩家3建立通关任务
         List<GameGate> playerThreeGates = new ArrayList<GameGate>(4);
         playerThreeGates.add(new GameGate("第一关", 7));
         playerThreeGates.add(new GameGate("第二关", 6));
         playerThreeGates.add(new GameGate("第三关", 4));
         GameRunable task3 = new GameRunable(playerThreeGates, "王五", barrier);


         ExecutorService executorService = Executors.newFixedThreadPool(3);
         executorService.submit(task1);
         executorService.submit(task2);
         executorService.submit(task3);
         executorService.shutdown();
      }