java 资源竞争_Java并发：解决资源竞争

最新推荐文章于 2021-10-04 21:57:14 发布

七彩极光

最新推荐文章于 2021-10-04 21:57:14 发布

阅读量209

点赞数

文章标签： java 资源竞争

本文链接：https://blog.csdn.net/weixin_36168996/article/details/114086055

版权

解决资源竞争

Java 提供关键字 synchronized 的内置支持。

使用 Lock 对象。

synchronized 关键字

synchronized 关键字获取的锁分为对象锁和类锁。

public class Test {

public synchronized void f(){}

public synchronized static void g(){}

}

调用 f() 是获取的 Test 对象的锁，而调用 g() 获取的是类锁。

synchronized 关键字也可以用来同步代码块

public class Test {

public void f(){

synchronized(this){

// ...

}

public static void g(){

synchronized(Test.class){

// ...

}

同样，f() 方法获取的是对象锁，而 g() 获取的是类锁。

Lock

public interface Lock {

void lock();

void lockInterruptibly() throws InterruptedException;

boolean tryLock();

boolean tryLock(long time, TimeUnit unit) throws InterruptedException;

void unlock();

Condition newCondition();

}

lock() 尝试获取锁，如果获取不到，会阻塞线程，直到获取到锁为止。

lockInterruptibly() 会尝试获取锁，如果获取不到，也会阻塞线程，但是它可以响应中断并且释放锁，也就避免了死锁问题。

tryLock() 会尝试获取锁，如果获取到了就返回 true，否则返回 false。

tryLock(long time, TimeUnit unit) 在限定时间内获取锁，如果获取到了返回 true，如果获取不到就会阻塞线程，但是它可以响应中断并且释放锁。当超过了规定时间还没有获取到锁，自动释放锁。

unLock() 当然就是解锁。

newCondition() 会产生一个与 Lock 对象绑定的 Condition 对象，在操作 Condition 对象前，必须要获取 Lock 对象的锁。这个可以用于线程之间的协作。

ReentrantLock

Lock 直接实现类只有 ReentrantLock类。

public class Test {

private int i = 0;

private Lock mLock = new ReentrantLock();

public void f() {

mLock.lock();

try {

i++;

} finally {

mLock.unlock();

}

在同步的地方，需要行调用 Lock 对象的 lock() 方法获取锁，为了保证不产生死锁情况，用 try-finally 释放锁。

ReadWriteLock

public interface ReadWriteLock {

Lock readLock();

Lock writeLock();

}

ReadWriteLock 接口把锁分为了读锁和写锁两种，因为有时候，多线程只会读取共享资源，而不会写，因为并发地读其实并不会产生并发问题。而写操作是不能与读操作并发进行的，需要等待锁的释放。

ReentrantReadWriteLock

ReentrantReadWriteLock 是 ReadWriteLock 唯一实现类。

public class Test {

private ReadWriteLock mReadWriteLock = new ReentrantReadWriteLock();

private Lock mReadLock = mReadWriteLock.readLock();

public static void main(String[] args) {

ExecutorService service = Executors.newCachedThreadPool();

for (int i = 0; i < 5; i++) {

service.execute(new Runnable() {

@Override

public void run() {

new Test().read();

}

});

}

service.shutdown();

}

public void read() {

mReadLock.lock();

try {

long start = System.currentTimeMillis();

while (System.currentTimeMillis() - start <= 1) {

System.out.println(Thread.currentThread().getName() + " is Reading ...");

}

System.out.println(Thread.currentThread().getName() + " read complete!");

} finally {

mReadLock.unlock();

}

结果为