ReentrantLock的使用-高并发

1. 

* 使用ReentrantLock可以代替Synchronized
 * 需注意：必须手动释放锁（重要！！！！）
 * 使用synchronized如果遇到异常，jvm会自动释放锁
 * 当时lock会手动释放锁，因此经常在finally中进行锁的释放

2.

 * 与Synchronized区别：
 * 使用ReentrantLock可以进行尝试锁定 tryLock()
 * 这样无法锁定，或者在指定时间内无法锁定，线程可以决定是否继续等待

*3
 * 使用ReentrantLock可以调用lockInterruptibly方法，可以对线程interrupt方法做出响应
*4.
 *RetrantLock还可以指定为公平锁 即等的时间长 先占有锁；效率低！
 *  Synchronized默认为非公平锁 看线程调度器  即竞争锁 效率高！
 

package reentrantlock_test;

import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * 使用ReentrantLock可以代替Synchronized
 * 需注意：必须手动释放锁（重要！！！！）
 * 使用synchronized如果遇到异常，jvm会自动释放锁
 * 当时lock会手动释放锁，因此经常在finally中进行锁的释放
 * @author x1c
 *
 */
public class ReentrantLock1 {
	Lock lock = new ReentrantLock(); //Lock java.util.concurrent.locks.Lock
	
	void m1() {
		lock.lock(); //synchronized(this)
		try {
			for (int i = 0; i < 10; i++) {
					TimeUnit.SECONDS.sleep(1);
					System.out.println(i);
			}
		} catch (InterruptedException e) {
				e.printStackTrace();
		}finally {
			lock.unlock(); //必须手动释放锁！！！
		}
	}
	void m2() {
		lock.lock();
		System.out.println("m2===");
		lock.unlock();
	}
	public static void main(String[] args) {
		ReentrantLock1 rl = new ReentrantLock1();
		new Thread(rl::m1).start();
		try {
			TimeUnit.SECONDS.sleep(1);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		new Thread(rl::m2).start();
	}
}

3. 

package reentrantlock_test;

import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * 使用ReentrantLock可以代替Synchronized
 * 需注意：必须手动释放锁（重要！！！！）
 * 使用synchronized如果遇到异常，jvm会自动释放锁
 * 当时lock会手动释放锁，因此经常在finally中进行锁的释放
 * -------------------------
 * 与Synchronized区别：
 * 使用ReentrantLock可以进行尝试锁定 tryLock()
 * 这样无法锁定，或者在指定时间内无法锁定，线程可以决定是否继续等待
 * @author x1c
 *
 */
public class ReentrantLock2 {
	Lock lock = new ReentrantLock(); //Lock java.util.concurrent.locks.Lock
	
	void m1() {
		lock.lock(); //synchronized(this)
		try {
			for (int i = 0; i < 10; i++) {
					TimeUnit.SECONDS.sleep(1);
					System.out.println(i);
			}
		} catch (InterruptedException e) {
				e.printStackTrace();
		}finally {
			lock.unlock(); //必须手动释放锁！！！
		}
	}
	void m2() {
		/*
//		lock.lock();
		boolean locked = lock.tryLock(); //尝试锁定
		System.out.println("m2===");
//		lock.unlock();
		if (locked) {
			lock.unlock();
		}
		*/
		boolean locked = false;
		try {
			locked = lock.tryLock(5, TimeUnit.SECONDS);//参数：时间数值+单位 boolean java.util.concurrent.locks.Lock.tryLock(long time, TimeUnit unit) throws InterruptedException
		} catch (InterruptedException e) {
			e.printStackTrace();
		} finally {
			if (locked) {
				lock.unlock();
			}
		}
	}
	public static void main(String[] args) {
		ReentrantLock2 rl = new ReentrantLock2();
		new Thread(rl::m1).start();
		try {
			TimeUnit.SECONDS.sleep(1);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		new Thread(rl::m2).start();
	}
}

3. 

package reentrantlock_test;

import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * 1
 * 使用ReentrantLock可以代替Synchronized
 * 需注意：必须手动释放锁（重要！！！！）
 * 使用synchronized如果遇到异常，jvm会自动释放锁
 * 当时lock会手动释放锁，因此经常在finally中进行锁的释放
 * -------------------------
 * 2
 * 与Synchronized区别：
 * 使用ReentrantLock可以进行尝试锁定 tryLock()
 * 这样无法锁定，或者在指定时间内无法锁定，线程可以决定是否继续等待
 *---------------------------
 *3
 * 使用ReentrantLock可以调用lockInterruptibly方法，可以对线程interrupt方法做出响应
 *
 */
public class ReentrantLock3 {
	public static void main(String[] args) {
		Lock lock = new ReentrantLock(); //Lock java.util.concurrent.locks.Lock
		
		Thread t1 = new Thread(()->{
			lock.lock(); //synchronized(this)
			try {
				System.out.println("t1.start");
				TimeUnit.SECONDS.sleep(Integer.MAX_VALUE);
				System.out.println("t1.end");
			} catch (InterruptedException e) {
				System.out.println("interrupted!!!!");
			}finally {
				lock.unlock(); //必须手动释放锁！！！
			}
		});
		t1.start();
		
		
		Thread t2 = new Thread(()->{
			try {
//			lock.lock();
				lock.lockInterruptibly(); //可以对interruptible做出响应
				System.out.println("t2.start");
				TimeUnit.SECONDS.sleep(5);
				System.out.println("t2.end");
			} catch (InterruptedException e) {
				System.out.println("2-interrupted-1!!!!");
			} finally {
				if (lock.tryLock()) {
					lock.unlock();
				}
			}
		});
		t2.start(); //线程启动
		try {
			TimeUnit.SECONDS.sleep(2);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		t2.interrupt(); //线程打断
	}
	
	
	
}

4.

package reentrantlock_test;

import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * 1
 * 使用ReentrantLock可以代替Synchronized
 * 需注意：必须手动释放锁（重要！！！！）
 * 使用synchronized如果遇到异常，jvm会自动释放锁
 * 当时lock会手动释放锁，因此经常在finally中进行锁的释放
 * -------------------------
 * 2
 * 与Synchronized区别：
 * 使用ReentrantLock可以进行尝试锁定 tryLock()
 * 这样无法锁定，或者在指定时间内无法锁定，线程可以决定是否继续等待
 *---------------------------
 *3
 * 使用ReentrantLock可以调用lockInterruptibly方法，可以对线程interrupt方法做出响应
 *
 *4.
 *RetrantLock还可以指定为公平锁 即等的时间长 先占有锁；效率低！
 *  Synchronized默认为非公平锁 看线程调度器  即竞争锁 效率高！
 *
 */
public class ReentrantLock4 extends Thread{
	private static ReentrantLock lock = new ReentrantLock(true); //参数为true表示公平java.util.concurrent.locks.ReentrantLock.ReentrantLock(boolean fair)
	@Override
		public void run() {
			for (int i = 0; i < 10; i++) {
				lock.lock();
				try {
					System.out.println(Thread.currentThread().getName()+"获得锁");
				} finally {
					lock.unlock();
				}
			}
		}
	public static void main(String[] args) {
		ReentrantLock4 rl = new ReentrantLock4();
		Thread th1 = new Thread(rl);// java.lang.Thread.Thread(Runnable target)
		Thread th2 = new Thread(rl);
		th1.start();
		th2.start();
	}
	
	
}