Lock的使用（五）——使用ReentrantLock类

1.方法isFair()、isHeldByCurrentThread()和isLocked()的测试

  创建项目4.1.12
（1）方法boolean isFair()的作用是判断是不是公平锁。
创建名称为test1的package包，创建类Service.java代码如下：

package test1;

import java.util.concurrent.locks.ReentrantLock;
public class Service {
    public ReentrantLock lock;
    public Service(Boolean isFair) {
        super();
        lock = new ReentrantLock(isFair);
    }
    public void serviceMethod() {
        try {
            lock.lock();
            System.out.println("公平锁情况：" + lock.isFair());
        } finally {
            lock.unlock();
        }
    }
}

创建运行类Run.java代码如下：

package test1;

public class Run {
    public static void main(String[] args) throws InterruptedException {
        final Service service1 = new Service(true);
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                service1.serviceMethod();
            }
        };
        Thread thread = new Thread(runnable);
        thread.start();
        final Service service2 = new Service(false);
        runnable = new Runnable() {
            @Override
            public void run() {
                service2.serviceMethod();
            }
        };
        thread = new Thread(runnable);
        thread.start();
    }
}

程序运行结果如下所示：

公平锁情况：true
公平锁情况：false

在默认的情况下，ReentrantLock类使用的是非公平锁。

（2）方法boolean isHeldByCurrentThread()的作用是查询当前线程是否保持此锁定。
创建名称为test2的package包，创建类Service.java代码如下：

package test2;

import java.util.concurrent.locks.ReentrantLock;
public class Service {
    private ReentrantLock lock;
    public Service(boolean isFair) {
        super();
        lock = new ReentrantLock(isFair);
    }
    public void serviceMethod(){
        try {
            System.out.println(lock.isHeldByCurrentThread());
            lock.lock();
            System.out.println(lock.isHeldByCurrentThread());
        } finally {
            lock.unlock();
        }
    }
}

创建运行类Run.java代码如下：

package test2;

public class Run {
    public static void main(String[] args) throws InterruptedException {
        final Service service1 = new Service(true);
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                service1.serviceMethod();
            }
        };
        Thread thread = new Thread(runnable);
        thread.start();
    }
}

程序运行结果如下所示：

false
true

（3）方法boolean isLocked()的作用是查询此锁定是否由任意线程保持。
创建名称为test3的package包，创建类Service.java代码如下：

package test3;

import java.util.concurrent.locks.ReentrantLock;
public class Service {
    private ReentrantLock lock;
    public Service(boolean isFair) {
        super();
        lock = new ReentrantLock(isFair);
    }
    public void serviceMethod() {
        try {
            System.out.println(lock.isLocked());
            lock.lock();
            System.out.println(lock.isLocked());
        } finally {
            lock.unlock();
        }
    }
}

创建运行类Run.java代码如下：

package test3;

public class Run {
    public static void main(String[] args) throws InterruptedException {
        final Service service1 = new Service(true);
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                service1.serviceMethod();
            }
        };
        Thread thread = new Thread(runnable);
        thread.start();
    }
}

程序运行结果如下所示：

false
true

2.方法lock.lockInterruptibly()、tryLock()和tryLock(long timeout,TimeUint uint)的测试

  创建项目4.1.13
（1）方法void lockInterruptibly()的作用是：如果当前线程未被中断，则获取锁定(需要等待别的线程释放锁才行)，如果已被中断则出现异常。
创建名称为test1的package包，创建类MyService.java代码如下：

package test1;

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;
public class MyService {
    public ReentrantLock lock = new ReentrantLock();
    private Condition condition = lock.newCondition();
    public void waitMethod() {
        try {
            lock.lock();
            System.out.println("lock begin "+Thread.currentThread().getName());
            for (int i = 0; i < Integer.MAX_VALUE / 10; i++) {
                String newString = new String();
                Math.random();
            }
            System.out.println("lock end "+Thread.currentThread().getName());
        } finally {
            if (lock.isHeldByCurrentThread()) {
                lock.unlock();
            }
        }
    }
}

创建运行类Run.java代码如下：

package test1;

public class Run {
    public static void main(String[] args) throws InterruptedException {
        final MyService service = new MyService();
        Runnable runnableRef = new Runnable() {
            @Override
            public void run() {
                service.waitMethod();
            }
        };
        Thread threadA = new Thread(runnableRef);
        threadA.setName("A");
        threadA.start();
        Thread.sleep(500);
        Thread threadB = new Thread(runnableRef);
        threadB.setName("B");
        threadB.start();
        threadB.interrupt(); //此处中断threadB线程，使用lock.lock()方法
        System.out.println("main end!");
    }
}

程序运行结果如下所示：

lock begin A
main end!
lock end A
lock begin B
lock end B

  没有出现异常，A、B线程正常结束，按钮变灰。
该实验使用的是Lock()方法，说明线程B被interrupt中断了，那么执行lock()则不出现异常，正常执行。

  如果使用lockInterruptibly方法则会出现问题。
将类MyService.java中原有代码“lock.lock()”；变成"lock.lockInterruptibly();"。
程序运行结果如下所示：

lock begin A
main end!
java.lang.InterruptedException
	at java.util.concurrent.locks.AbstractQueuedSynchronizer.acquireInterruptibly(AbstractQueuedSynchronizer.java:1219)
	at java.util.concurrent.locks.ReentrantLock.lockInterruptibly(ReentrantLock.java:340)
	at test1.MyService.waitMethod(MyService.java:11)
	at test1.Run$1.run(Run.java:9)
	at java.lang.Thread.run(Thread.java:744)
lock end A

线程B被中断后调用lockInterruptibly方法报异常

（2）方法void tryLock()的作用是：仅在调用时锁定未被另一个线程保持的情况下，才获取该锁定。
创建名称为test2的package包，创建类MyService.java代码如下：

package test2;

import java.util.concurrent.locks.ReentrantLock;

public class MyService {
    public ReentrantLock lock = new ReentrantLock();

    public void waitMethod() {
        if (lock.tryLock()) {
            System.out.println(Thread.currentThread().getName() + "获得锁");
        } else {
            System.out.println(Thread.currentThread().getName() + "没有获得锁");
        }
    }
}

创建运行类Run.java代码如下：

package test2;

public class Run {
    public static void main(String[] args) throws InterruptedException {
        final MyService service = new MyService();
        Runnable runnableRef = new Runnable() {
            @Override
            public void run() {
                service.waitMethod();
            }
        };
        Thread threadA = new Thread(runnableRef);
        threadA.setName("A");
        threadA.start();
        Thread threadB = new Thread(runnableRef);
        threadB.setName("B");
        threadB.start();
    }
}

程序运行结果如下所示：

A获得锁
B没有获得锁

（3）方法void tryLock(long timeout,TimeUnit unit)的作用是：如果给定线程在等待时间内未被另一个线程保持，且当前线程未被中断，则获取该锁定。
创建名称为test3的package包，创建类MyService.java代码如下：

package test3;

import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.ReentrantLock;
public class MyService {
    public ReentrantLock lock = new ReentrantLock();
    public void waitMethod() {
        try {
            if(lock.tryLock(3, TimeUnit.SECONDS)) {
                System.out.println(Thread.currentThread().getName()+"获得锁的时间："+System.currentTimeMillis());
                Thread.sleep(10000);
            } else {
                System.out.println(Thread.currentThread().getName()+"没有获得锁");
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            if (lock.isHeldByCurrentThread()){
                lock.unlock();
            }
        }
    }
}

创建运行类Run.java代码如下：

package test3;

public class Run {
    public static void main(String[] args) throws Exception {
        final MyService service = new MyService();
        Runnable runnableRef = new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"调用waitMethod时间："+System.currentTimeMillis());
                service.waitMethod();
            }
        };
        Thread threadA = new Thread(runnableRef);
        threadA.setName("A");
        threadA.start();
        Thread threadB = new Thread(runnableRef);
        threadB.setName("B");
        threadB.start();
    }
}

程序运行结果如下所示：

A调用waitMethod时间：1661327480581
B调用waitMethod时间：1661327480581
A获得锁的时间：1661327480582
B没有获得锁

线程B超时未获得锁

以上代码下载请点击该链接：https://github.com/Yarrow052/Java-package.git