当前位置:首页 > 开发 > 编程语言 > 多线程 > 正文

多线程——锁(lock)

发表于: 2011-12-13   作者:ciding   来源:转载   浏览次数:
摘要: 上一讲《多线程——同步(synchronized)下》   多线程——锁(lock)上   首先提出一个问题,synchronized与lock有哪些异同?是性能、适应范围、切入点?还是使用时的复杂度呢?   先了解一下java.util.concurrent.locks.Lock接口的实现类:ReentrantLock与ReentrantReadWrit

上一讲《多线程——同步(synchronized)下

 

多线程——锁(lock)上

 

首先提出一个问题,synchronized与lock有哪些异同?是性能、适应范围、切入点?还是使用时的复杂度呢?

 

先了解一下java.util.concurrent.locks.Lock接口的实现类:ReentrantLock与ReentrantReadWriteLock的内部类中的ReadLock与WriteLock;分别叫重入锁,读入锁,写入锁。

 

而本节中主要讲ReentrantLock的使用与特性。

 

在ReentrantLock中有这样一段描述:

一个可重入的互斥锁 Lock,它具有与使用 synchronized 方法和语句所访问的隐式监视器锁相同的一些基本行为和语义,但功能更强大。 (后面的先略过,需要的自己查看API。)

 

功能更强大? 编写思路:先通过一个例子看看实际效果,再分析ReentrantLock的lock()方法的实现方式,再比较synchronized的异同,最后得出两者的适用范围。

 

例子:

package thread_test;

import java.util.concurrent.locks.ReentrantLock;

/**
 * lock锁
 * 
 * @author ciding 
 * @createTime Dec 14, 2011 9:54:03 AM
 *
 */
public class LockThread {

	public static void main(String[] args) {
		Long t_start = System.currentTimeMillis();

		User_lock u = new User_lock("张三", 100);
		Thread_lock t1 = new Thread_lock("线程A", u, 20);
		Thread_lock t2 = new Thread_lock("线程B", u, -60);
		Thread_lock t3 = new Thread_lock("线程C", u, -80);
		Thread_lock t4 = new Thread_lock("线程D", u, -30);
		Thread_lock t5 = new Thread_lock("线程E", u, 100);
		Thread_lock t6 = new Thread_lock("线程F", u, 50);

		t1.start();
		t2.start();
		t3.start();
		t4.start();
		t5.start();
		t6.start();

		/**
		 * 以下代码用于计算时间,当然,它本身的运行也会需要一点点时间,但与分析运行效率无影响
		 */
		boolean flag = true;
		while (flag) {
			if (Thread_lock.activeCount() == 1) {
				Long t_end = System.currentTimeMillis();
				System.out.println("当前时间:" + (t_end - t_start));
				flag = false;
			}
		}
	}
}

class Thread_lock extends Thread {
	private User_lock u;
	private int y = 0;

	Thread_lock(String name, User_lock u, int y) {
		super(name); // 线程的名称
		this.u = u;
		this.y = y;
	}

	public void run() {
		u.oper(y);
	}
}

class User_lock {
	private String code;
	private Integer cash;
	private ReentrantLock myLock1 = new ReentrantLock();
	private ReentrantLock myLock2 = new ReentrantLock();

	User_lock(String code, int cash) {
		this.code = code;
		this.cash = cash;
	}

	public String getCode() {
		return code;
	}

	public void setCode(String code) {
		this.code = code;
	}

	/**
	 * 业务方法
	 * 
	 * @param x
	 *            添加x万元
	 */
	public synchronized void oper(int x) {
		try{
			Thread.sleep(1000);// 作用:增加运行时间
			this.cash += x;
			System.out.println(Thread.currentThread().getName() + "  运行结束1,增加“"
					+ x + "”,当前用户信息:" + toString());
		} catch (InterruptedException e) {
			e.printStackTrace();
		}

		try{
			Thread.sleep(1000);// 作用:增加运行时间
			this.code = "张三(2)";
		} catch (InterruptedException e) {
			e.printStackTrace();
		}

	}

	@Override
	public String toString() {
		return "User{" + "code='" + code + '\'' + ", cash=" + cash + '}';
	}
}

 

运行结果:
线程A  运行结束1,增加“20”,当前用户信息:User{code='张三', cash=120}
线程F  运行结束1,增加“50”,当前用户信息:User{code='张三(2)', cash=170}
线程E  运行结束1,增加“100”,当前用户信息:User{code='张三(2)', cash=270}
线程D  运行结束1,增加“-30”,当前用户信息:User{code='张三(2)', cash=240}
线程C  运行结束1,增加“-80”,当前用户信息:User{code='张三(2)', cash=160}
线程B  运行结束1,增加“-60”,当前用户信息:User{code='张三(2)', cash=100}
消靠时间:12016

 

例2:

package thread_test;

import java.util.concurrent.locks.ReentrantLock;

/**
 * lock锁
 * 
 * @author ciding 
 * @createTime Dec 14, 2011 9:54:03 AM
 *
 */
public class LockThread {

	public static void main(String[] args) {
		Long t_start = System.currentTimeMillis();

		User_lock u = new User_lock("张三", 100);
		Thread_lock t1 = new Thread_lock("线程A", u, 20);
		Thread_lock t2 = new Thread_lock("线程B", u, -60);
		Thread_lock t3 = new Thread_lock("线程C", u, -80);
		Thread_lock t4 = new Thread_lock("线程D", u, -30);
		Thread_lock t5 = new Thread_lock("线程E", u, 100);
		Thread_lock t6 = new Thread_lock("线程F", u, 50);

		t1.start();
		t2.start();
		t3.start();
		t4.start();
		t5.start();
		t6.start();

		/**
		 * 以下代码用于计算时间,当然,它本身的运行也会需要一点点时间,但与分析运行效率无影响
		 */
		boolean flag = true;
		while (flag) {
			if (Thread_lock.activeCount() == 1) {
				Long t_end = System.currentTimeMillis();
				System.out.println("当前时间:" + (t_end - t_start));
				flag = false;
			}
		}
	}
}

class Thread_lock extends Thread {
	private User_lock u;
	private int y = 0;

	Thread_lock(String name, User_lock u, int y) {
		super(name); // 线程的名称
		this.u = u;
		this.y = y;
	}

	public void run() {
		u.oper(y);
	}
}

class User_lock {
	private String code;
	private Integer cash;
	private ReentrantLock myLock1 = new ReentrantLock();
	private ReentrantLock myLock2 = new ReentrantLock();

	User_lock(String code, int cash) {
		this.code = code;
		this.cash = cash;
	}

	public String getCode() {
		return code;
	}

	public void setCode(String code) {
		this.code = code;
	}

	/**
	 * 业务方法
	 * 
	 * @param x
	 *            添加x万元
	 */
	public void oper(int x) {		
		synchronized(cash){
			try{
				Thread.sleep(1000);// 作用:增加运行时间
				this.cash += x;
				System.out.println(Thread.currentThread().getName() + "  运行结束1,增加“"
						+ x + "”,当前用户信息:" + toString());
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}

		synchronized(code) {
			try{
				Thread.sleep(1000);// 作用:增加运行时间
				this.code = "张三(2)";
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}

	}

	@Override
	public String toString() {
		return "User{" + "code='" + code + '\'' + ", cash=" + cash + '}';
	}
}

  

运行结果: 写道
线程A  运行结束1,增加“20”,当前用户信息:User{code='张三', cash=120}
线程F  运行结束1,增加“50”,当前用户信息:User{code='张三', cash=170}
线程E  运行结束1,增加“100”,当前用户信息:User{code='张三(2)', cash=270}
线程D  运行结束1,增加“-30”,当前用户信息:User{code='张三(2)', cash=240}
线程C  运行结束1,增加“-80”,当前用户信息:User{code='张三(2)', cash=160}
线程B  运行结束1,增加“-60”,当前用户信息:User{code='张三(2)', cash=100}
消靠时间:7031

  

 例3:

 

package thread_test;

import java.util.concurrent.locks.ReentrantLock;

/**
 * lock锁
 * 
 * @author ciding 
 * @createTime Dec 14, 2011 9:54:03 AM
 *
 */
public class LockThread {

	public static void main(String[] args) {
		Long t_start = System.currentTimeMillis();

		User_lock u = new User_lock("张三", 100);
		Thread_lock t1 = new Thread_lock("线程A", u, 20);
		Thread_lock t2 = new Thread_lock("线程B", u, -60);
		Thread_lock t3 = new Thread_lock("线程C", u, -80);
		Thread_lock t4 = new Thread_lock("线程D", u, -30);
		Thread_lock t5 = new Thread_lock("线程E", u, 100);
		Thread_lock t6 = new Thread_lock("线程F", u, 50);

		t1.start();
		t2.start();
		t3.start();
		t4.start();
		t5.start();
		t6.start();

		/**
		 * 以下代码用于计算时间,当然,它本身的运行也会需要一点点时间,但与分析运行效率无影响
		 */
		boolean flag = true;
		while (flag) {
			if (Thread_lock.activeCount() == 1) {
				Long t_end = System.currentTimeMillis();
				System.out.println("当前时间:" + (t_end - t_start));
				flag = false;
			}
		}
	}
}

class Thread_lock extends Thread {
	private User_lock u;
	private int y = 0;

	Thread_lock(String name, User_lock u, int y) {
		super(name); // 线程的名称
		this.u = u;
		this.y = y;
	}

	public void run() {
		u.oper(y);
	}
}

class User_lock {
	private String code;
	private Integer cash;
	private ReentrantLock myLock1 = new ReentrantLock();
	private ReentrantLock myLock2 = new ReentrantLock();

	User_lock(String code, int cash) {
		this.code = code;
		this.cash = cash;
	}

	public String getCode() {
		return code;
	}

	public void setCode(String code) {
		this.code = code;
	}

	/**
	 * 业务方法
	 * 
	 * @param x
	 *            添加x万元
	 */
	public  void oper(int x) {
		myLock1.lock();
		try{
			Thread.sleep(1000);// 作用:增加运行时间
			this.cash += x;
			System.out.println(Thread.currentThread().getName() + "  运行结束1,增加“"
					+ x + "”,当前用户信息:" + toString());
		} catch (InterruptedException e) {
			e.printStackTrace();
		} finally {
			myLock1.unlock();
		}
		
		myLock2.lock();
		try{
			Thread.sleep(1000);// 作用:增加运行时间
			this.code = "张三(2)";
		} catch (InterruptedException e) {
			e.printStackTrace();
		} finally {
			myLock2.unlock();
		}

	}

	@Override
	public String toString() {
		return "User{" + "code='" + code + '\'' + ", cash=" + cash + '}';
	}
}

  

 

运行结果:
线程A 运行结束1,增加“20”,当前用户信息:User{code='张三', cash=120}
线程B 运行结束1,增加“-60”,当前用户信息:User{code='张三', cash=60}
线程C 运行结束1,增加“-80”,当前用户信息:User{code='张三(2)', cash=-20}
线程D 运行结束1,增加“-30”,当前用户信息:User{code='张三(2)', cash=-50}
线程E 运行结束1,增加“100”,当前用户信息:User{code='张三(2)', cash=50}
线程F 运行结束1,增加“50”,当前用户信息:User{code='张三(2)', cash=100}
当前时间:7203

 

 

看上面的时间可以了解一下synchronized与lock的使用在性能上的差别。

单纯的看上面的测试结果:synchronized块是最快的。其实这是因为测试的数据量比较少,线程运行的时间很短。

 

当运行的线程数以千计的时候,那时对于CPU的上下文切换和调度所消靠的时间就会表现的比较明显。基本上,使用lock会比synchronized块的运行会快一点点,比synchronized方法就快很多了。

 

按照最开始给的思路,现在应该看看lock()方法的实现了。

 

/** * Acquires the lock. * * <p>Acquires the lock if it is not held by another thread and returns * immediately, setting the lock hold count to one. * * <p>If the current thread already holds the lock then the hold * count is incremented by one and the method returns immediately. * * <p>If the lock is held by another thread then the * current thread becomes disabled for thread scheduling * purposes and lies dormant until the lock has been acquired, * at which time the lock hold count is set to one. */ public void lock() { sync.lock(); }

 

 

 直接是通过调用sync的lock()方法。转到sync,发现这个抽象类的lock()方法有两个实现类,分别是NonfairSync与FairSync,刚好对应的一个是非公平锁,一个是公平锁。

 

非公平锁的代码:加点中文注释

/** * Sync object for non-fair locks */ final static class NonfairSync extends Sync { private static final long serialVersionUID = 7316153563782823691L; /** * Performs lock. Try immediate barge, backing up to normal * acquire on failure. */ final void lock() { //表示如果当前state=0,那么设置state=1,并返回true;否则返回false。由于未等待,所以线程不需加入到等待队列 if (compareAndSetState(0, 1)) setExclusiveOwnerThread(Thread.currentThread()); else acquire(1); } protected final boolean tryAcquire(int acquires) { return nonfairTryAcquire(acquires); } }

 

 

 

接下来代码所调用的我只写方法,

acquire(1)->acquireQueued(addWaiter(Node.EXCLUSIVE), arg)) 其中addWaiter负责增加节点

增加完成后selfInterrupt(),设置中断。->tryAcquire(arg)来判断->nonfairTryAcquire(arg)最后回到这个关键方法。

 

/** * Performs non-fair tryLock. tryAcquire is * implemented in subclasses, but both need nonfair * try for trylock method. */ final boolean nonfairTryAcquire(int acquires) { final Thread current = Thread.currentThread(); int c = getState(); if (c == 0) { if (compareAndSetState(0, acquires)) { setExclusiveOwnerThread(current); return true; } } else if (current == getExclusiveOwnerThread()) { int nextc = c + acquires; if (nextc < 0) // overflow throw new Error("Maximum lock count exceeded"); setState(nextc); return true; } return false; }

 

 

 

 (1)如果锁状态空闲(state=0),且通过原子的比较并设置操作,那么当前线程获得锁,并把当前线程设置为锁拥有者;
 (2)如果锁状态空闲,且原子的比较并设置操作失败,那么返回false,说明尝试获得锁失败;
 (3)否则,检查当前线程与锁拥有者线程是否相等(表示一个线程已经获得该锁,再次要求该锁,这种情况叫可重入锁),如果相等,维护锁状态,并返回true;
 (4)如果不是以上情况,说明锁已经被其他的线程持有,直接返回false;

到此,核心代码就分析完了。

引用一段别人的总结:

 

zhangxl 写道
ReentrantLock在采用非公平锁构造时,首先检查锁状态,如果锁可用,直接通过CAS设置成持有状态,且把当前线程设置为锁的拥有者。
如果当前锁已经被持有,那么接下来进行可重入检查,如果可重入,需要为锁状态加上请求数。如果不属于上面两种情况,那么说明锁是被其他线程持有,
当前线程应该放入等待队列。
在放入等待队列的过程中,首先要检查队列是否为空队列,如果为空队列,需要创建虚拟的头节点,然后把对当前线程封装的节点加入到队列尾部。由于设置尾部节点采用了CAS,为了保证尾节点能够设置成功,这里采用了无限循环的方式,直到设置成功为止。
在完成放入等待队列任务后,则需要维护节点的状态,以及及时清除处于Cancel状态的节点,以帮助垃圾收集器及时回收。如果当前节点之前的节点的等待状态小于1,说明当前节点之前的线程处于等待状态(挂起),那么当前节点的线程也应处于等待状态(挂起)。挂起的工作是由LockSupport类支持的,LockSupport通过JNI调用本地操作系统来完成挂起的任务(java中除了废弃的suspend等方法,没有其他的挂起操作)。
在当前等待的线程,被唤起后,检查中断状态,如果处于中断状态,那么需要中断当前线程。

 

 

先到这里,需要写的东西太多,突然有点下不了手的感觉

ReentrantLock对synchronized的性能改进:

ReentrantLock是通过实现一个接口Lock,把锁定做为了一java类来实现,而不是做为语言的特性;从而可能实现不同的调度算法、性能特性等。而这里,ReentrantLock拥有synchronized相同的并发性与内存语义,另外,又添加了类似锁投票,定时锁等候,可中断锁等候的一些特性。

ReentrantLock对synchronized的可伸缩改进:

在非公平锁中,CPU的处理时间中,只有很少的时间花在线程调度上,大多都用在实际工作上。

 

 

 

 

 怕越写越深,到我都控制不了的时候,就不好了;所以,最后还是用一个“围城”的比喻来说明synchronized与lock的差异来做为总结。

当我们看lock处处都比synchronized好的时候,请看下面:

在使用lock方法的时候,应该注意到一点,就是finally后面要加上unlock()方法,这个就有点像Java与C++在内存回收上的区别,所以写代码的时候,就要特别小心;另外,因为Lock是一个接口,它的实现也就是一个普通的类而已,所以JVM在生成线程转储时能够包括锁定信息的时候,synchronized可以指定到代码,而Lock就不行了,这对于调试,你懂的。

 

围城效应就在这两者之间来回的跑,就想当年喜欢内存回收之后,又去恶补JVM的内存回收机制是一样的。 

 

 

 

 

Java多线程及线程池专题 汇总http://ciding.iteye.com/blog/1300110

多线程——锁(lock)

  • 0

    开心

    开心

  • 0

    板砖

    板砖

  • 0

    感动

    感动

  • 0

    有用

    有用

  • 0

    疑问

    疑问

  • 0

    难过

    难过

  • 0

    无聊

    无聊

  • 0

    震惊

    震惊

编辑推荐
前文(深入JVM锁机制-synchronized)分析了JVM中的synchronized实现,本文继续分析JVM中的另一种锁L
本文继续分析JVM中的另一种锁Lock的实现。与synchronized不同的是,Lock完全用Java写成,在java这个
ABAP里为了控制并发,保持数据一致性,用了锁对象(lock object)对于abaper来说使用起来非常方便,
用一个锁Lock一组相关的对象 有时,需要按组来修改多个对象. 这样,在需要锁住其中一个的时候,必须连
通过冲突检测和(发生冲突时的)事务回滚,来防止并发业务事务中的冲突. 通常一个业务事务的执行,会跨
用一个锁Lock一组相关的对象 有时,需要按组来修改多个对象. 这样,在需要锁住其中一个的时候,必须连
转自:http://blog.csdn.net/chen77716/article/details/6641477 前文(深入JVM锁机制-synchronized
前文(深入JVM锁机制-synchronized)分析了JVM中的synchronized实现,本文继续分析JVM中的另一种锁L
前文(深入JVM锁机制-synchronized)分析了JVM中的synchronized实现,本文继续分析JVM中的另一种锁L
分类: JVM 2011-07-28 18:15 92人阅读 评论(0) 收藏 举报 前文(深入JVM锁机制-synchronized)分析
版权所有 IT知识库 CopyRight © 2009-2015 IT知识库 IT610.com , All Rights Reserved. 京ICP备09083238号