Java多线程-新特征-锁(上)-学习笔记3

在Java5中，专门提供了锁对象，利用锁可以方便的实现资源的封锁，用来控制对竞争资源并发访问的控制，这些内容主要集中在java.util.concurrent.locks 包下面，里面有三个重要的接口Condition、Lock、ReadWriteLock。

Condition: 
Condition 将 Object 监视器方法（wait、notify 和 notifyAll）分解成截然不同的对象，以便通过将这些对象与任意 Lock 实现组合使用，为每个对象提供多个等待 set （wait-set）。

 

Lock: 
Lock 实现提供了比使用 synchronized 方法和语句可获得的更广泛的锁定操作。

 

ReadWriteLock: 
ReadWriteLock 维护了一对相关的锁定，一个用于只读操作，另一个用于写入操作。

有关锁的介绍,API文档解说很多，看得很烦，还是看个例子再看文档比较容易理解。

 

Demo实例：

 

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

//线程锁对象
public class LockTest {

	public static void main(String[] args) {
		LockTest test = new LockTest();

		// 创建并发访问的账户
		MyAccount myAcc = test.new MyAccount("95599200901215522", 10000);
		// 创建一个锁对象
		Lock lock = new ReentrantLock();
		// 创建一个线程池
		ExecutorService pool = Executors.newCachedThreadPool();
		// 创建一些并发访问用户，一个信用卡，存的存，取的取，好热闹啊
		User u1 = test.new User("张三", myAcc, -4000, lock);
		User u2 = test.new User("张三他爹", myAcc, 6000, lock);
		User u3 = test.new User("张三他弟", myAcc, -8000, lock);
		User u4 = test.new User("张三", myAcc, 800, lock);
		// 在线程池中执行各个用户的操作
		pool.execute(u1);
		pool.execute(u2);
		pool.execute(u3);
		pool.execute(u4);
		// 关闭线程池
		pool.shutdown();
	}

	class User implements Runnable {

		private String name;
		private MyAccount myAccount;
		private int opcash;// 操作金额
		private Lock myLock;// 锁对象

		public User(String name, MyAccount myAccount, int opcash, Lock myLock) {
			this.name = name;
			this.myAccount = myAccount;
			this.opcash = opcash;
			this.myLock = myLock;
		}

		@Override
		public void run() {
			String op;
			if (opcash > 0) {
				op = "存款";
			} else {
				op = "取款";
			}

			// 获取锁
			myLock.lock();
			// 执行现金业务
			System.out.println(name + "正在操作" + myAccount + "账户，" + op + "金额为"
					+ opcash + "，当前金额为" + myAccount.getCash());
			myAccount.setCash(myAccount.getCash() + opcash);
			System.out.println(name + "操作" + myAccount + "账户成功，" + op + "金额为"
					+ opcash + "，当前金额为" + myAccount.getCash());

			System.out.println("============");
			// 释放锁，否则别的线程没有机会执行了
			myLock.unlock();
		}

	}

	// 信用卡，可随意透支
	class MyAccount {
		private String cardno;// 卡号
		private int cash;// 余额 测试就直接用int了

		public MyAccount(String cardno, int cash) {
			super();
			this.cardno = cardno;
			this.cash = cash;
		}

		public String getCardno() {
			return cardno;
		}

		public void setCardno(String cardno) {
			this.cardno = cardno;
		}

		public int getCash() {
			return cash;
		}

		public void setCash(int cash) {
			this.cash = cash;
		}

		@Override
		public String toString() {
			return "MyAccount{" + "卡号='" + cardno + '\'' + ", 余额=" + cash + '}';
		}
	}
}

 

输出结果：

张三正在操作MyAccount{卡号='95599200901215522', 余额=10000}账户，取款金额为-4000，当前金额为10000
张三操作MyAccount{卡号='95599200901215522', 余额=6000}账户成功，取款金额为-4000，当前金额为6000
============
张三他爹正在操作MyAccount{卡号='95599200901215522', 余额=6000}账户，存款金额为6000，当前金额为6000
张三他爹操作MyAccount{卡号='95599200901215522', 余额=12000}账户成功，存款金额为6000，当前金额为12000
============
张三正在操作MyAccount{卡号='95599200901215522', 余额=12000}账户，存款金额为800，当前金额为12000
张三操作MyAccount{卡号='95599200901215522', 余额=12800}账户成功，存款金额为800，当前金额为12800
============
张三他弟正在操作MyAccount{卡号='95599200901215522', 余额=12800}账户，取款金额为-8000，当前金额为12800
张三他弟操作MyAccount{卡号='95599200901215522', 余额=4800}账户成功，取款金额为-8000，当前金额为4800
============