Java并发编程

最新推荐文章于 2024-09-07 21:32:59 发布

狂飙的dali

最新推荐文章于 2024-09-07 21:32:59 发布

阅读量121

点赞数

分类专栏： Java

本文链接：https://blog.csdn.net/zgsxzdl/article/details/89477072

版权

Java 专栏收录该内容

12 篇文章 0 订阅

订阅专栏

list

synchronized
volatile
ReentrantLock/ReentrantReadWriteLock
CountdownLatch
CyclicBarrier
Semaphore

synchronized

系统关键字，可以修饰方法，也可以对Object使用。

    public synchronized void fun(){}

    public synchronized void fun(){
        Object lock = new Object();
        synchronized (lock) {
            // do something
            try {
                lock.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

在同步代码块中可以使用wait/notify/notifyAll，但是必须使用与synchronized相同的对象。

volatile

关键字，修饰变量，作用：

保证修改对所有线程可见
禁止进行指令重排序，写操作 happens-before 读操作

实现原理：
借助于内存屏障（也成内存栅栏）

它确保指令重排序时不会把其后面的指令排到内存屏障之前的位置，也不会把前面的指令排到内存屏障的后面；即在执行到内存屏障这句指令时，在它前面的操作已经全部完成；
它会强制将对缓存的修改操作立即写入主存；
如果是写操作，它会导致其他CPU中对应的缓存行无效。

ReentrantLock/ReentrantReadWriteLock

Lock相比synchronized提供了更丰富的操作，可以提供多个Condition。
以下内容摘自：https://blog.csdn.net/u011479540/article/details/52013187

public interface Lock {
    void lock();//加锁
    void lockInterruptibly() throws InterruptedException;//加可中断锁
    boolean tryLock();//加锁成功返回true，失败返回false
    boolean tryLock(long time, TimeUnit unit) throws InterruptedException;//加锁成功返回true，失败等待一段时间后若仍无法加锁则返回false，可响应中断
    void unlock();//解锁
    Condition newCondition(); //返回一个Condition，利用它可以如和Synchronizd配合使用的wait（）和notify（）一样对线程阻塞和唤醒，不同的是一个lock可以有多个condition.
}

public interface Condition {
    void await() throws InterruptedException;//类似于wait(),可以响应中断
    void awaitUninterruptibly();//不响应中断的等待
    long awaitNanos(long nanosTimeout) throws InterruptedException;//等待指定时间（单位是纳秒），在接到信号、被中断或到达指定等待时间之前一直处于等待状态。方法返回被唤醒后的剩余等待时间，若返回值小于等于0则代表此次等待超时。
    boolean await(long time, TimeUnit unit) throws InterruptedException;//指定时间到达前结束等待返回true，否则返回false
    boolean awaitUntil(Date deadline) throws InterruptedException;//指定日期到达前被唤醒返回true，否则返回false
    void signal();//唤醒一个等待中的线程，类似于notify()
    void signalAll();//唤醒所有等待中的线程，类似于notifyAll()
}

ReentrantLock 和 ReentrantWriteReadLock 是 Lock的两个实现，在竞争剧烈的时候ReentrantLock表现更好。

ReentrantWriteReadLock提供了读锁和写锁。

读锁可以有多把，但是和写锁互斥
写锁和其他所有锁互斥

CountDownLatch

CountDownLatch、CyclicBarrier和 Semaphore 摘自：
https://www.cnblogs.com/dolphin0520/p/3920397.html

利用它可以实现类似计数器的功能

public CountDownLatch(int count) {  };  //参数count为计数值

public void await() throws InterruptedException { };   //调用await()方法的线程会被挂起，它会等待直到count值为0才继续执行
public boolean await(long timeout, TimeUnit unit) throws InterruptedException { };  //和await()类似，只不过等待一定的时间后count值还没变为0的话就会继续执行
public void countDown() { };  //将count值减1

CyclicBarrier

通过它可以实现让一组线程等待至某个状态之后再全部同时执行。

public CyclicBarrier(int parties, Runnable barrierAction) {}
public CyclicBarrier(int parties) {}

public int await() throws InterruptedException, BrokenBarrierException { };
public int await(long timeout, TimeUnit unit)throws InterruptedException,BrokenBarrierException,TimeoutException { };

初始化parties之后，直接调用await处于栅栏，开始等待，到parties个线程处于栅栏，或者超时，才可以继续下面的操作。barrierAction会在等待的线程中选择一个执行。

Semaphore

Semaphore可以控同时访问的线程个数，通过 acquire() 获取一个许可，如果没有就等待，而 release() 释放一个许可。

public Semaphore(int permits) {          //参数permits表示许可数目，即同时可以允许多少线程进行访问
    sync = new NonfairSync(permits);
}
public Semaphore(int permits, boolean fair) {    //这个多了一个参数fair表示是否是公平的，即等待时间越久的越先获取许可
    sync = (fair)? new FairSync(permits) : new NonfairSync(permits);
}


public void acquire() throws InterruptedException {  }     //获取一个许可
public void acquire(int permits) throws InterruptedException { }    //获取permits个许可
public void release() { }          //释放一个许可
public void release(int permits) { }    //释放permits个许可

public boolean tryAcquire() { };    //尝试获取一个许可，若获取成功，则立即返回true，若获取失败，则立即返回false
public boolean tryAcquire(long timeout, TimeUnit unit) throws InterruptedException { };  //尝试获取一个许可，若在指定的时间内获取成功，则立即返回true，否则则立即返回false
public boolean tryAcquire(int permits) { }; //尝试获取permits个许可，若获取成功，则立即返回true，若获取失败，则立即返回false
public boolean tryAcquire(int permits, long timeout, TimeUnit unit) throws InterruptedException { }; //尝试获取permits个许可，若在指定的时间内获取成功，则立即返回true，否则则立即返回false