Java并发编程技术

一、线程池相关

线程超级详解：http://blog.youkuaiyun.com/cuigx1991/article/details/48219741

线程池：http://www.importnew.com/19011.html

ExecutorService

http://blog.youkuaiyun.com/yuzhiboyi/article/details/7775266

Callable与Runnable

http://blog.youkuaiyun.com/lu123535884/article/details/49495833

Callable可以返回结果，但是runnable不行。

上代码：

1 2 3 4 5 6 7 8

public   class  TestCallable  implements  Callable<String>{        @Override      public  String call()  throws  Exception {          Thread.sleep( 3000 );          return  "Hello World" ;      } }

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

@Override protected  void  onCreate(Bundle savedInstanceState) {      super .onCreate(savedInstanceState);        TestCallable testCallable =  new  TestCallable();      ExecutorService executorService = Executors.newSingleThreadExecutor();      Future<String> future = executorService.submit(testCallable);      try  {          System.out.println(future.get());      }  catch  (InterruptedException e) {          e.printStackTrace();      }  catch  (ExecutionException e) {          e.printStackTrace();      }      System.out.println( "11111111111111" ); }

可以发现我在TestCallable里加了个sleep，程序还是会后打印"111111111111"那一个串，说明TestCallable的线程会阻塞主线程，真正原因是future.get()会阻塞当前线程，直到callable的call方法结束 。

 

CountDownLatch

可以阻塞当前线程，等待另外一个线程执行完结果后将结果同步返回，异步转同步。

异步转同步需要注意

1）异步的数据一定要是在子线程里，否则会造成当前线程卡顿。

2）如果需要在主线程里同步返回数据，但是取数据走的是子线程，子线程不要使用new Handler(Looper.getMainLooper()) 来做延时操作，否则会造成子线程回调无法countDownLatch减小，最终主线程一直在等待。

在子线程中使用Handler的方法：

1 2 3

HandlerThread handlerThread =  new  HandlerThread( "纯24协议对接收到的数据进行分析" ){}; handlerThread.start(); mHandler =  new  Handler(handlerThread.getLooper());

二、线程交互

 1.唤醒与等待（wait与notify）

  相关博客：http://blog.youkuaiyun.com/qq_26504875/article/details/50703961

  常见异常：http://blog.youkuaiyun.com/zhouxiaoyun0228/article/details/7757313 

  注意事项：1)唤醒与等待是有严格的使用条件的，对象监听器只能在所监听的线程内调用。

       2)wait与notify只能在同步代码块里调用

       3）一般一个任务同步方法执行完，调用监听器wait当前线程。

       4）wait与notify虽然是object的方法，但是作用是作为锁来控制线程。

       5）wait与notify更适用于两个或多个协同工作的线程 

 

  代码实例：   

  2个交互的线程类：    

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32

public  class  MyThread1  extends  Thread{      private  Object lock;      private  int  index =  0 ;        public  MyThread1(Object lock){          this .lock = lock;      }      @Override      public  void  run(){          synchronized  (lock) {              while  ( true ){                  System.out.println( "MyThread1 " +System.currentTimeMillis());                  index++;                  if (index ==  10 ){                      lock.notify();                      break ;                  }                  if (index %  5  ==  0 ){                      try  {                          lock.notify();                          System.out.println( "MyThread1 wait" );                          lock.wait();                      }  catch  (InterruptedException e) {                          e.printStackTrace();                      }                  }              }            }        } }

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30

public  class  MyThread2  extends  Thread{      private  Object lock;      private  int  index =  0 ;        public  MyThread2(Object lock){          this .lock = lock;      }      @Override      public  void  run(){          synchronized  (lock) {              while  ( true ){                  System.out.println( "MyThread2 " +System.currentTimeMillis());                  index++;                  if (index ==  10 ){                      lock.notify();                      break ;                  }                  if (index %  5  ==  0 ){                      try  {                          lock.notify();                          System.out.println( "MyThread2 wait" );                          lock.wait();                      }  catch  (InterruptedException e) {                          e.printStackTrace();                      }                  }              }          }      } }

 2个交互线程的任务调用类：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

public  class  Thread1Tasker  implements  ITask{      private  Object lock;      private  final  static  Thread1Tasker instance =  new  Thread1Tasker();      public  final  static  Thread1Tasker getInstance(){          return  instance;      }        public  Thread1Tasker setLock(Object lock) {          this .lock = lock;          return  this ;      }        @Override      public  void  start() {          MyThread1 t1 =  new  MyThread1(lock);          t1.start();      } }

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

public  class  Thread2Tasker  implements   ITask{      private  Object lock;        private  final  static  Thread2Tasker instance =  new  Thread2Tasker();      public  final  static  Thread2Tasker getInstance(){          return  instance;      }        public  Thread2Tasker setLock(Object lock) {          this .lock = lock;          return  this ;      }          @Override      public  void  start() {          MyThread2 t2 =  new  MyThread2(lock);          t2.start();      } }

 main方法里调用任务：

1 2 3 4 5 6 7 8 9

public  class  Test3 {      public  static  void  main(String[] args)  throws  InterruptedException {          Object lock =  new  Object();          Thread1Tasker.getInstance().setLock(lock)                  .start();          Thread2Tasker.getInstance().setLock(lock)                  .start();      } }

   

 结果打印输出：

 

MyThread1 1516939281372

MyThread1 1516939281372

MyThread1 1516939281372

MyThread1 1516939281372

MyThread1 1516939281372

MyThread1 wait

MyThread2 1516939281374

MyThread2 1516939281374

MyThread2 1516939281374

MyThread2 1516939281374

MyThread2 1516939281374

MyThread2 wait

MyThread1 1516939281374

MyThread1 1516939281374

MyThread1 1516939281374

MyThread1 1516939281374

MyThread1 1516939281374

MyThread2 1516939281374

MyThread2 1516939281374

MyThread2 1516939281374

MyThread2 1516939281374

MyThread2 1516939281374

 可以发现2个线程任务是交替执行的

      本文转自屠夫章哥  51CTO博客，原文链接：http://blog.51cto.com/4259297/1965192，如需转载请自行联系原作者