java中的互斥锁,信号量和多线程等待机制

互斥锁和信号量都是操作系统中为并发编程设计基本概念,互斥锁和信号量的概念上的不同在于,对于同一个资源,互斥锁只有0和1 的概念,而信号量不止于此。也就是说,信号量可以使资源同时被多个线程访问,而互斥锁同时只能被一个线程访问


互斥锁在java中的实现就是 ReetranLock , 在访问一个同步资源时,它的对象需要通过方法 tryLock() 获得这个锁,如果失败,返回 false,成功返回true。根据返回的信息来判断是否要访问这个被同步的资源。看下面的例子

public class ReentranLockExample {
    private static int count = 0;
    private static ReentrantLock reentrantLock = new ReentrantLock();
    static class MyThread extends Thread{

        @Override
        public void run() {
            super.run();
            try {
                while (true){
                    boolean result = reentrantLock.tryLock();
                    if (result){
                        System.out.println(Thread.currentThread().getName() + "get the lock success and run the syn code " + count ++);
                        reentrantLock.unlock();
                    }else{
                        System.out.println(Thread.currentThread().getName() + "get the lock failed and run the syn code " + count);
                    }
                    System.out.println(Thread.currentThread().getName() + "run the asyntronized code  " + count);
                    Thread.sleep(500);
                }

            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    public static void main(String[] args){
        MyThread thread1 = new MyThread();
        MyThread thread2 = new MyThread();
        thread1.start();
        thread2.start();
    }

}


信号量相当于一个计数器,如果线程想要访问某个资源,则先要获得这个资源的信号量,并且信号量内部的计数器减1 ,信号量内部的计数器大于0则意味着有可以使用的资源,当线程使用完某个资源时,必须释放这个资源的信号量。信号量的一个作用就是可以实现指定个线程去同事访问某个资源。只需要在初始化 。 

信号量在 Java中的实现是 Semaphore  ,其在初始化时传入一个整型数, 用来指定同步资源最大的并发访问量

public class SemaphoreExample {
    private static Semaphore semaphore = new Semaphore(2);
    private String lock = "lock";
    private static int count = 0;
    static class MyThread extends Thread {

        @Override
        public void run() {
            super.run();
            try {
                while (true) {
                    semaphore.acquire();
                    Thread.sleep(500);
                    System.out.println(Thread.currentThread().getName() + "get the lock success and run the syn code " + count++);
                    semaphore.release();
                    Thread.sleep(500);
                }

            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    public static void main(String[] args){
        MyThread thread1 = new MyThread();
        MyThread thread2 = new MyThread();
        MyThread thread3 = new MyThread();
        thread1.start();
        thread2.start();
        thread3.start();
    }
}

 CountDownLatch 实现一个等待机制,在诸如 等待与会者到达后,开始会议的使用中。ConutDownLatch 在初始化中一个计数器,用来指定需要等待的个数。在并发编程中,所解决的需求就是,等待所有的线程到达某个点后。才开始进行下一步,有点类似于开会,只有当所有的与会人员都到齐后,会议才能开始

public class CountDownLatchExample {
    private static CountDownLatch mCountDownLatch = new CountDownLatch(3);
    static class MyThread extends Thread {
        int awaitTime;
        public MyThread(int i) {
            this.awaitTime = i;
        }

        @Override
        public void run() {
            super.run();
            try {
                while (true) {
                    Thread.sleep(awaitTime);
                    System.out.println(Thread.currentThread().getName() + "arrived " );
                    mCountDownLatch.countDown();
                    mCountDownLatch.await(); //可以指定等待时间
                    System.out.println(Thread.currentThread().getName() + "start meeting " );
                }

            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    public static void main(String[] args){
        MyThread thread1 = new MyThread(500);
        MyThread thread2 = new MyThread(1000);
        MyThread thread3 = new MyThread(2000);
        thread1.start();
        thread2.start();
        thread3.start();
    }
}

    原文作者:java锁
    原文地址: https://blog.csdn.net/feifeiwendao/article/details/52212719
    本文转自网络文章,转载此文章仅为分享知识,如有侵权,请联系博主进行删除。
点赞