jdk1.5以后的多线程同步方式

jdk1.5以后有了java.util.concurrent包

里面对同步提供了相当多的支持

例如lock atomic以及一些可同步操作的容器

下面给出一个常见的多线程面试题及其对应实现

有三个线程ID分别是A、B、C,请有多线编程实现，在屏幕上循环打印10次ABCABC

采用AtomicInteger来实现这个，

不多说了，上代码，还是相当简单易懂的

可以对concurrent包见一斑。

   1. import java.util.concurrent.atomic.AtomicInteger;  
   2.   
   3. public class Print extends Thread{  
   4.     //专门为同步用的　用integer不行，每次都会新建的  
   5.     private AtomicInteger synObj;  
   6.     private int count;  
   7.     private String s;  
   8.     private int flag;  
   9.     private int total = 0;  
  10.       
  11.     public Print(int count,AtomicInteger atomicInteger,String s,int flag) {  
  12.         this.count = count;  
  13.         this.synObj = atomicInteger;  
  14.         this.s = s;  
  15.         this.flag = flag;  
  16.     }  
  17.     public void run() {  
  18.         while(true) {  
  19.             synchronized(synObj) {  
  20.                 if(synObj.intValue()%3 == flag) {  
  21.                     total++;  
  22.                     synObj.set(synObj.intValue()+1);  
  23.                     System.out.println(s);  
  24.                     synObj.notifyAll();  
  25.                     if(total == count) {  
  26.                         break;  
  27.                     }  
  28.                 }else {  
  29.                     try{  
  30.                         synObj.wait();  
  31.                     }catch(Exception e){  
  32.                         e.printStackTrace();  
  33.                     }  
  34.                 }  
  35.             }  
  36.         }  
  37.     }  
  38.     public static void main(String[]args) throws Exception {  
  39.         AtomicInteger synObj = new AtomicInteger(0);  
  40.         Print a = new Print(10,synObj,"A",0);  
  41.         Print b = new Print(10,synObj,"B",1);  
  42.         Print c = new Print(10,synObj,"C",2);  
  43.         a.start();  
  44.         b.start();  
  45.         c.start();  
  46.     }  
  47. }