Java中Concurrent包中同步互斥纪录

来源：互联网发布：欧洲卡车模拟2 知乎编辑：程序博客网时间：2024/06/04 23:25

关于多线程，Concurrent包中的lock接口，和信号量很好的帮助我们解决多线程之间的同步，互斥，轮流执行等操作，且简单易懂，共享，相信掌握lock，Semaphore等接口可以解决大部分多线程问题，是很方便的一个类，可以很好的解决轮流打印ABC的问题等，这次我分享一个相似的问题，三个数组{1，3，5，7，9}，{2，4，6，8，9}，{‘a’,'b','c','d','e'},线程1打印1，线程2打印2，线程三打印a,再回来，线程一打印3，如此往下，下面是两种方式实现，synchronized配合nodifyall,wait,也可以实现，类似于lock，这次介绍concurrent中的接口。

第一种 Concurrent.locks

public class Lock {    public static void main(String[] args) throws InterruptedException {        System.out.println("开始");        CountDownLatch num = new CountDownLatch(3);//每一个线程结束减一，保证main线程最后结束        new Thread(new pr(0,num)).start();        new Thread(new pr(1,num)).start();        new Thread(new pr(2,num)).start();        num.await();//此方法会等待num等于0        System.out.println("\r\n结束");    }}class pr implements Runnable{    static ReentrantLock lock = new ReentrantLock(); //ReentrantLock是lock接口的一个实现类    int[] a1 = {1, 3, 5, 7, 9};
    int[] a2 = {2, 4, 6, 8, 0};   
 char[] a3 = {'a', 'b', 'c', 'd', 'e'};    
static int state = 0; //三个进程共享的,三个都可以修改的，state的相关操作可以判断哪一个线程启动   
 private int id;   
 CountDownLatch num = null;   
 public pr(int id,CountDownLatch o){        this.id = id;        this.num = o;    }  
  @Override   
 public void run() {  
      while (state<=14){          
             lock.lock(); //对lock加锁    
             if (state%3==id && state<=14){       
               if (id==0){              
                 System.out.print(a1[state/3]+" ");     
               if (state==12) num.countDown();               
              }else if (id==1){    
                System.out.print(a2[state/3]+" ");          
              if (state==13) num.countDown();        
              }else if (id==2){                 
               System.out.print(a3[state/3]+" ");               
              if (state ==14) num.countDown();         
            }         
       state++;          
     }         
   lock.unlock();//解锁    
  }   
}}


运行效果：
开始
1 2 a 3 4 b 5 6 c 7 8 d 9 0 e 
结束



第二种
信号量（类似于操作系统中的PV操作，信号量是资源数，当信号量<0时，则信号量的绝对值为等待的进程数目），这里想要达到同步效果，
则信号量为1，当一个线程取走这个信号量的时候，（把信号量看成一种许可证）它就可以运行，其他想要争取这个资源的线程需要等待。接下来的这个例子：A，B，C
初始信号量都为1，B,C的信号量先各自夺走一个（但是此时BC不会运行，因为还没有调用start方法），这样就保证A先运行，A获取信号，
执行一些代码后，B释放刚刚被夺走的B资源，A线程执行完毕后（中途不会有其他线程打断A，因为A执行时，BC的信号量为0，而且有信号量的BC
线程还没有start）
，A，C信号量为0，B为1，此时只有B线程可以获取其资源，继续开始，如此反复一遍

import java.util.concurrent.CountDownLatch;import java.util.concurrent.Semaphore;public class Semaph {    static  CountDownLatch count;     static int[] a1 = {1, 3, 5, 7, 9};     static int[] a2 = {2, 4, 6, 8, 0};     static char[] a3 = {'a', 'b', 'c', 'd', 'e'};    static Semaphore A = new Semaphore(1);    static Semaphore B = new Semaphore(1);    static Semaphore C = new Semaphore(1);    public static void main(String[] args) throws InterruptedException {        System.out.println("开始");            B.acquire();            C.acquire();            count = new CountDownLatch(3);            new Thread(new printA()).start();            new Thread(new printB()).start();            new Thread(new printC()).start();            count.await();        System.out.println("\r\n结束");    }    static class printA extends  Thread{        @Override        public void run() {                for (int i = 0; i< 5;i++){                    try {                        A.acquire();                    } catch (InterruptedException e) {                        e.printStackTrace();                    }                    System.out.print(a1[i]+" ");                    try {                        sleep(1000);                    } catch (InterruptedException e) {                        e.printStackTrace();                    }                    B.release();                }            count.countDown();        }    }    static class printB extends  Thread{        @Override        public void run() {            for (int i = 0; i< 5;i++){                try {                    B.acquire();                } catch (InterruptedException e) {                    e.printStackTrace();                }                System.out.print(a2[i]+" ");                try {                    sleep(1000);                } catch (InterruptedException e) {                    e.printStackTrace();                }                C.release();            }            count.countDown();        }    }    static class printC extends  Thread{        @Override        public void run() {            for (int i = 0; i< 5;i++){                try {                    C.acquire();                } catch (InterruptedException e) {                    e.printStackTrace();                }                System.out.print(a3[i]+" ");                try {                    sleep(1000);                } catch (InterruptedException e) {                    e.printStackTrace();                }                A.release();            }            count.countDown();        }    }}运行结果：开始1 2 a 3 4 b 5 6 c 7 8 d 9 0 e 结束

1 0