#include <pthread.h>
#include <iostream>
using namespace std;

pthread_mutex_t g_mutex = PTHREAD_MUTEX_INITIALIZER;

void testLock()
{
    int ret = pthread_mutex_trylock(&g_mutex);
    cout << "try lock:" << ret << endl;
    ret = pthread_mutex_unlock(&g_mutex);
    cout << "unlock:" << ret << endl;
}

int main()
{
    testLock();
    cout << "---------test lock twice---------" << endl;
    pthread_mutex_lock(&g_mutex);
    testLock();
    pthread_mutex_unlock(&g_mutex);
}

try lock:0
unlock:0
---------test lock twice---------
try lock:16
unlock:0

概述
tryLock 是防止自锁的一个重要方式。
tryLock()方法是有返回值的，它表示用来尝试获取锁，如果获取成功，则返回true，如果获取失败(即锁已被其他线程获取)，则返回false，这个方法无论如何都会立即返回。在拿不到锁时不会一直在那等待。
package test;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
//学习 tryLock
//tryLock()方法是有返回值的，它表示用来尝试获取锁，如果获取成功，则返回true，如果获取失败(即锁已被其他线程获取)，则返回false，这个方法无论如何都会立即返回。在拿不到锁时不会一直在那等待。
public class tryLock {
public static void main(String[] args) {
System.out.println("开始");
final Lock lock = new ReentrantLock();
new Thread() {
@Override
public void run() {
String tName = Thread.currentThread().getName();
if (lock.tryLock()) {
System.out.println(tName + "获取到锁！");
} else {
System.out.println(tName + "获取不到锁！");
return;
}
try {
for (int i = 0; i < 5; i++) {
System.out.println(tName + ":" + i);
}
Thread.sleep(5000);
} catch (Exception e) {
System.out.println(tName + "出错了！！！");
} finally {
System.out.println(tName + "释放锁！！");
lock.unlock();
}
}
}.start();
new Thread() {
@Override
public void run() {
String tName = Thread.currentThread().getName();
if (lock.tryLock()) {
System.out.println(tName + "获取到锁！");
} else {
System.out.println(tName + "获取不到锁！");
return;
}
try {
for (int i = 0; i < 5; i++) {
System.out.println(tName + ":" + i);
}
} catch (Exception e) {
System.out.println(tName + "出错了！！！");
} finally {
System.out.println(tName + "释放锁！！");
lock.unlock();
}
}
}.start();
System.out.println("结束");
}
}

tryLock 有两个重载的方法，分别如下：
boolean tryLock();
boolean tryLock(long time, TimeUnit unit) throws InterruptedException;

tryLock() 会立马返回一个布尔值，如果获得了锁就返回 true；如果没有获得锁就返回 false。无论是返回 true 还是 false，都会继续执行之后的代码。
tryLock(long time, TimeUnit unit) 会等待指定的时间，如果时间到了还没获得锁就返回 false；如果在时间范围内获得了锁就立刻返回 true，不用等待时间结束。无论是返回 true 还是 false，都会继续执行之后的代码。
我们来拿第二个方法进行测试，代码如下：
public class T03_ReentrantLock3 {
    Lock lock = new ReentrantLock();

    int count = 10;

    void m1() {
        try {
            lock.lock();
            for (int i = 0; i < count; i++) {
                TimeUnit.SECONDS.sleep(1);
                System.out.println(i + 1);
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    void m2() {
        boolean tryLock = false;
        try {
            // 尝试在 5 秒内获得锁
            tryLock = lock.tryLock(5, TimeUnit.SECONDS);
            System.out.println("m2..." + tryLock);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (tryLock) {
                lock.unlock();
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        T03_ReentrantLock3 reentrantLock3 = new T03_ReentrantLock3();
        new Thread(reentrantLock3::m1).start();
        TimeUnit.SECONDS.sleep(1);
        new Thread(reentrantLock3::m2).start();
    }
}

控制台输出如下：
1
2
3
4
5
6
m2...false
7
8
9
10

我们把变量 count 变为 2 再进行测试，控制台输出如下：
1
2
m2...true

Java多线程：tryLock()方法
tryLock(long time, TimeUnit unit) 的作用在给定等待时长内锁没有被另外的线程持有，并且当前线程也没有被中断,则获得该锁，通过该方法可以实现锁对象的限时等待。
package com.wkcto.lock.reentrant;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.ReentrantLock;
/**
*tryLock(long time, TimeUnit unit) 的基本使用
*/
public class Test07 {
static class TimeLock implements Runnable{
private static ReentrantLock lock = new ReentrantLock();    //定义锁对象
@Override
public void run() {
try {
if ( lock.tryLock(3, TimeUnit.SECONDS) ){       //获得锁返回true
System.out.println(Thread.currentThread().getName() + "获得锁,执行耗时任务");
//                    Thread.sleep(4000);         //假设Thread-0线程先持有锁,完成任务需要4秒钟,Thread-1线程尝试获得锁,Thread-1线程在3秒内还没有获得锁的话,Thread-1线程会放弃
Thread.sleep(2000);          //假设Thread-0线程先持有锁,完成任务需要2秒钟,Thread-1线程尝试获得锁,Thread-1线程会一直尝试,在它约定尝试的3秒内可以获得锁对象
}else {         //没有获得锁
System.out.println(Thread.currentThread().getName() + "没有获得锁");
}
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
if (lock.isHeldByCurrentThread()){
lock.unlock();
}
}
}
}
public static void main(String[] args) {
TimeLock timeLock = new TimeLock();
Thread t1 = new Thread(timeLock);
Thread t2 = new Thread(timeLock);
t1.start();
t2.start();
}
}
tryLock()仅在调用时锁定未被其他线程持有的锁，如果调用方法时，锁对象对其他线程持有，则放弃，调用方法尝试获得没，如果该锁没有被其他线程占用则返回true表示锁定成功; 如果锁被其他线程占用则返回false,不等待。
package com.wkcto.lock.reentrant;
import java.util.concurrent.locks.ReentrantLock;
/**
*tryLock()
*  当锁对象没有被其他线程持有的情况下才会获得该锁定
*/
public class Test08 {
static class Service{
private ReentrantLock lock = new ReentrantLock();
public void serviceMethod(){
try {
if (lock.tryLock()){
System.out.println(Thread.currentThread().getName() + "获得锁定");
Thread.sleep(3000);     //模拟执行任务的时长
}else {
System.out.println(Thread.currentThread().getName() + "没有获得锁定");
}
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
if (lock.isHeldByCurrentThread()){
lock.unlock();
}
}
}
}
public static void main(String[] args) throws InterruptedException {
Service service = new Service();
Runnable r = new Runnable() {
@Override
public void run() {
service.serviceMethod();
}
};
Thread t1 = new Thread(r);
t1.start();
Thread.sleep(50);       //睡眠50毫秒,确保t1线程锁定
Thread t2 = new Thread(r);
t2.start();
}
}
package com.wkcto.lock.reentrant;
import java.util.Random;
import java.util.concurrent.locks.ReentrantLock;
/**
* 使用tryLock()可以避免死锁
*/
public class Test09 {
static class  IntLock implements Runnable{
private static ReentrantLock lock1 = new ReentrantLock();
private static ReentrantLock lock2 = new ReentrantLock();
private int lockNum;        //用于控制锁的顺序
public IntLock(int lockNum) {
this.lockNum = lockNum;
}
@Override
public void run() {
if ( lockNum % 2 == 0 ){    //偶数先锁1,再锁2
while (true){
try {
if (lock1.tryLock()){
System.out.println(Thread.currentThread().getName() + "获得锁1, 还想获得锁2");
Thread.sleep(new Random().nextInt(100));
try {
if (lock2.tryLock()){
System.out.println(Thread.currentThread().getName() + "同时获得锁1与锁2 ----完成任务了");
return;         //结束run()方法执行,即当前线程结束
}
} finally {
if (lock2.isHeldByCurrentThread()){
lock2.unlock();
}
}
}
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
if (lock1.isHeldByCurrentThread()){
lock1.unlock();
}
}
}
}else {     //奇数就先锁2,再锁1
while (true){
try {
if (lock2.tryLock()){
System.out.println(Thread.currentThread().getName() + "获得锁2, 还想获得锁1");
Thread.sleep(new Random().nextInt(100));
try {
if (lock1.tryLock()){
System.out.println(Thread.currentThread().getName() + "同时获得锁1与锁2 ----完成任务了");
return;         //结束run()方法执行,即当前线程结束
}
} finally {
if (lock1.isHeldByCurrentThread()){
lock1.unlock();
}
}
}
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
if (lock2.isHeldByCurrentThread()){
lock2.unlock();
}
}
}
}
}
}
public static void main(String[] args) {
IntLock intLock1 = new IntLock(11);
IntLock intLock2 = new IntLock(22);
Thread t1 = new Thread(intLock1);
Thread t2 = new Thread(intLock2);
t1.start();
t2.start();
//运行后,使用tryLock()尝试获得锁,不会傻傻的等待,通过循环不停的再次尝试,如果等待的时间足够长,线程总是会获得想要的资源
}
}