JUC常用知识点

synchronized关键字

  1.加在静态方法上会对该类的class文件加锁   相当于加在手机代工厂不会影响我手机的使用

  2.加在普通方法上会对该类的实列对象加锁    相当于加在手机上

  3.类中方法没有加synchronized关键字   相当于手机壳   不会影响手机的使用

   加情况1和情况2的锁 不会发生冲突。

  

1.CountDownLatch的应用

原理CountDownLatch主要有两个方法，当一个或多个线程调用await方法时，这些线程会阻塞

*其他线程调用countDown方法会将计数器减1（调用countDown方法的线程不会阻塞）

*当计数器的值变为0时，因await方法阻塞的线程会被唤醒，继续执行。

CountDownLatch是用来控制哪个线程的内容来最后执行

代码应用如下

public class CountDownLatchDemo {
    public static void main(String[] args) throws InterruptedException {
        CountDownLatch countDownLatch = new CountDownLatch(6);

        for (int i = 1; i <= 6 ; i++) {

            new Thread(()->{
                System.out.println(Thread.currentThread().getName()+"\t"+"离开教室");
                countDownLatch.countDown();
            },String.valueOf(i)).start();

        }

        countDownLatch.await();
        System.out.println("关门");
    }
}

2.CyclicBarrier的应用

public class CyclicBarrierDemo {
    public static void main(String[] args) {
       //6个线程执行完await方法后用最后一个线程执行定义的内容
        CyclicBarrier cyclicBarrier = new CyclicBarrier(6, () -> {

            System.out.println(Thread.currentThread().getName()+"\t"+"召唤神龙");
        });

        for (int i = 1; i <=6 ; i++) {

            final Integer temp = i ;
            new Thread(()->
            {
                System.out.println(Thread.currentThread().getName()+"\t"+"已到位");
                try {
                    cyclicBarrier.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } catch (BrokenBarrierException e) {
                    e.printStackTrace();
                }
            },temp.toString()).start();
        }

    }
}

3.semaphore

• 一个计数信号量。 在概念上，信号量维持一组许可证。 如果有必要，每个acquire()都会阻塞，直到许可证可用，然后才能使用它。 每个release()添加许可证，潜在地释放阻塞获取方。 但是，没有使用实际的许可证对象; Semaphore只保留可用数量的计数，并相应地执行。

  信号量通常用于限制线程数，而不是访问某些（物理或逻辑）资源。 例如，这是一个使用信号量来控制对一个项目池的访问的类：

public class SemaphoreDemo {
    public static void main(String[] args) {

        final Semaphore semaphore = new Semaphore(3);

        for (int i = 1; i <=6 ; i++) {
            new Thread(()->
            {
                try {
                    semaphore.acquire();
                    System.out.println(Thread.currentThread().getName()+"\t抢到车位");
                    TimeUnit.SECONDS.sleep(3);
                    System.out.println(Thread.currentThread().getName()+"\t离开车位");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }finally {
                    semaphore.release();
                }
            },String.valueOf(i)).start();
        }
    }
}

4.ReadWriteLock 读写锁

写  写  ×

写 读 ×

读 读 √​​​​​​​

实列代码如下

class Resource
{
    private volatile Map<String,Object> map = new HashMap<>();
    private ReadWriteLock readWriteLock = new ReentrantReadWriteLock();


    public void put(String key,Object value)
    {
        readWriteLock.writeLock().lock();
        try{
            System.out.println(Thread.currentThread().getName()+"\t 开始写入");
            map.put(key, value);
            System.out.println(Thread.currentThread().getName()+"\t 成功写入"+key);

        }catch (Exception e)
        {
            e.printStackTrace();
        }finally {
            readWriteLock.writeLock().unlock();
        }
    }
    public void get(String key)
    {
        readWriteLock.readLock().lock();
        try{
            System.out.println(Thread.currentThread().getName()+"\t 开始读取");
            Object o = map.get(key);
            System.out.println(Thread.currentThread().getName()+"\t 成功读取"+o);

        }catch (Exception e)
        {
            e.printStackTrace();
        }finally {
            readWriteLock.readLock().unlock();
        }
    }
}

public class ReadWritLockDemo {
    public static void main(String[] args) {
        Resource resource = new Resource();
        for (int i = 1; i <=5 ; i++) {
            final int temp = i;
            new Thread(()->
            {
             resource.put(temp+"",temp+"");

            },String.valueOf(i)).start();
        }
        for (int i = 1; i <=5 ; i++) {
            final int temp = i;
            new Thread(()->
            {
             resource.get(temp+"");

            },String.valueOf(i)).start();
        }
    }
}