也来说说Java中的锁--并发编程关键知识点

也来说说Java中的锁

一,什么是java中的锁

1,从java语法上来说,java中的锁,指的就是java给我们提供的Lock接口以及相关的实现类。

public interface Lock ,通常我们这样来创建锁对象:

Lock lock = new ReentrantLock(); 

2,从架构上来说,锁是一种同步机制;

3,从功能上来说,锁是用来控制多个线程访问共享资源的方式,防止多个线程同时访问共享资源。

二,从JVM的角度来看锁

    说起锁,就要说一下synchronized关键字。锁是JDK5开始才引入的一个功能,而synchronized

关键字在JDK5之前就已经存在了,并且在没有锁的日子里,java就靠synchronized关键字来实现锁

的功能的。锁与synchronized关键字也相似的功能,区别就在于锁是显示的,而synchronized关键

字是隐式的。

1,锁的内存语义

    锁是一种同步机制,锁可以让临界区互斥的执行,在多线程环境下实现强同步,并且锁L在释放

时,释放锁L的A线程会通知获得锁L的B线程。这就是锁的内存语义。

2,锁的释放和获取的内存语义

    第一点:锁的释放的内存语义是:当线程A释放锁时,Java内存模型会把本地内存中的共享变量

的值刷新到主内存中。

    第二点:锁的获取的内存语义是:当线程A获取锁时,Java内存模型会把本地内存中的共享变量

的值置为无效,然后去主内存中读取新值。

    在这里补充说明一下,锁的释放和volatile关键字的写操作具有相同的内存语义,锁的获取和

volatile关键字的读具有相同的内存语义。并且从实现上来说,Java中锁机制的实现,依赖于

volatile关键字。

读者请思考:锁与volatile的不同点?

3,锁的内存语义的实现

    锁有很多种实现,这里我们仅仅以最常用的可重入锁ReentrantLock为例来说明,可重入锁

ReentrantLock的内存语义的实现是这样的:调用Lock方法获取锁,调用unlock方法释放锁。可重入

锁的实现依赖于AQS(AbstractQueueSynchronizer)同步器框架。而AQS实现的关键就是volatile关

键字,因此我们通常说,锁的内存语义的实现,依赖于volatile关键字。

三,从功能实现和使用的角度来看锁

    Java支持多线程,也就是多个线程可以同时访问同一个变量或者对象,由于每个对象都拥有这个

变量的拷贝,所以在程序的执行过程中,某个线程看到的变量的值不一定是最新的,因此就产生了线

程同步的问题。之所以每个线程都拥有一份拷贝,是为了加快程序的运行速度,这是很多多核处理器

的共性。

1,锁的使用方法

锁的使用方法比较简单,通过下面一段代码,就可以熟悉锁是如何使用的。

package com.spider.java;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
/**
 * 
 * @author yangcq
 * @desctiption Java中的锁
 *
 */
public class LockLearning {
	// 定义一个全局变量,账户余额
	private static int account_balance = 1000000000;
	public static void main(String[] args) {
		// 创建可重入锁对象lock
		Lock lock = new ReentrantLock();	
		// 在执行一段代码之前获取锁
		lock.lock();	
		// 执行代码,修改余额的值,这里可以是我们项目中任何一个需要加锁的操作
		updateAccountBalance(account_balance);	
		// 在执行一段代码之后释放锁
		lock.unlock();
	}
	private static int updateAccountBalance(Integer account_balance){
		return account_balance - 1000;
	}	
}

下面我们来看一下Lock接口:

public interface Lock {
    void lock();
    void lockInterruptibly() throws InterruptedException;
    boolean tryLock();
    boolean tryLock(long time, TimeUnit unit) throws InterruptedException;
    void unlock();
    Condition newCondition();
}

lock():获取锁,调用该方法后,当前线程马上获得锁,当锁获得后,从该方法返回。

lockInterruptibly():获取锁(支持中断获取锁)

tryLock():获取锁(非阻塞的获取锁,调用该方法后,会立即返回)

tryLock(long time, TimeUnit unit):获取锁(支持超时获取锁)

unlock():释放锁

newCondition():获取等待通知组件,该组件和当前的锁绑定,当前线程只有获得了锁,

才能调用该组件的wait方法,而调用后,当前线程将被释放锁。

源码中注释很详细,大家可以细细品味一番:

    /**
     * Returns a new {@link Condition} instance that is bound to this
     * {@code Lock} instance.
     *
     * <p>Before waiting on the condition the lock must be held by the
     * current thread.
     * A call to {@link Condition#await()} will atomically release the lock
     * before waiting and re-acquire the lock before the wait returns.
     *
     * <p><b>Implementation Considerations</b>
     *
     * <p>The exact operation of the {@link Condition} instance depends on
     * the {@code Lock} implementation and must be documented by that
     * implementation.
     *
     * @return A new {@link Condition} instance for this {@code Lock} instance
     * @throws UnsupportedOperationException if this {@code Lock}
     *         implementation does not support conditions
     */

2,锁与synchronized关键字的比较

说到锁,就不得不提锁的始祖synchronized关键字,首先来看一下synchronized关键字的使用。

package com.spider.java;
import java.util.logging.Logger;
/**
 * 
 * @author yangcq
 * @description synchronized关键字的使用方法
 *
 */
public class SynchronizedLearning {
	static Logger logger = Logger.getAnonymousLogger();
	public static void main(String[] args) {
		/**
		 * synchronized关键字实现同步有2种方式,同步方法和同步块
		 */
		// 同步块
		synchronized(SynchronizedLearning.class){
			logger.info("我是同步块...");
		}
		synchronizedMethod();
	}
	// 同步方法
	public static synchronized void synchronizedMethod(){
		logger.info("我是同步方法...");
	}
}

总结一下,锁与synchronized关键字都可以实现锁的功能,由于锁是诞生在

synchronized关键字之后,所以锁更具有先进性,它具有一些synchronized

关键字不具有的功能,主要有以下几个方面:

支持非阻塞的获取锁;

支持中断的获取锁;

支持超时获取锁;

四,AQS同步器框架(AbstractQueueSynchronizer)

    锁的实现,依赖的就是AQS,Lock接口的实现基本上都是通过聚合了一个同步

器的子类来完成线程访问控制的。AQS又叫队列同步器,是用来构建锁或者其他同

步组件的基础框架。AQS使用一个int成员变量来表示同步状态,通过内置的FIFO队

列来完成资源获取线程的排队工作。

    AQS的主要使用方法是继承,子类通过继承同步器AQS,然后实现它的抽象方法

来管理同步状态。

    队列同步器AQS是锁的实现的关键,在锁的实现中聚合队列同步器,利用队列同

步器实现锁的语义。可以这样理解二者之间的关系:锁是面向使用者的,同步器是面

向锁的实现类。

1,同步框架AQS的使用说明

首先自定义一个锁,独占锁,也就是说在同一时刻只有一个线程可以获得锁。

package com.spider.java;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.AbstractQueuedSynchronizer;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
/**
 * 
 * @author yangcq
 * @description 自定义锁 - 独占锁UserDefineLock,也就是在同一时刻,只有一个线程可以获得锁
 *
 */
public class UserDefineLock implements Lock {

	// 使用队列同步器AQS以后,我们只需要将锁的操作代理到自定义的同步器上就可以了
	private final SynchronizerDefine synchronizerDefine = new SynchronizerDefine();
	@Override
	public void lock() {
		synchronizerDefine.acquire(1);
	}

	@Override
	public void lockInterruptibly() throws InterruptedException {
		synchronizerDefine.acquireInterruptibly(1);
	}

	@Override
	public boolean tryLock() {
		return synchronizerDefine.tryAcquire(1);
	}

	@Override
	public boolean tryLock(long time, TimeUnit unit) throws InterruptedException {
		return synchronizerDefine.tryAcquireNanos(1, unit.toNanos(time));
	}

	@Override
	public void unlock() {
		synchronizerDefine.release(1);
	}

	@Override
	public Condition newCondition() {
		return synchronizerDefine.newCondition();
	}
	
	public boolean hasQueueThreads(){
		return synchronizerDefine.hasQueuedThreads();
	}
	
	public boolean isLocked(){
		return synchronizerDefine.isHeldExclusively();
	}

	// 静态内部类,自定义同步器
	private static class SynchronizerDefine extends AbstractQueuedSynchronizer{
		/**
		 * 
		 */
		private static final long serialVersionUID = -5572420543429760541L;
		// 判断当前锁是否处于占用状态
		protected boolean isHeldExclusively(){
			return getState() == 1;
		}
		// 当状态为0时,获取锁
		public boolean tryAcquire(int acquires){
			if(compareAndSetState(0,1)){
				// 官方注释:Sets the thread that currently owns exclusive access.
				setExclusiveOwnerThread(Thread.currentThread());
				return true;
			}
			return false;
		}
		// 释放锁之后,将状态设置为0
		protected boolean tryRelease(int releases){
			if(getState() == 0){
				throw new IllegalMonitorStateException();
			}
			setExclusiveOwnerThread(null);
			setState(0);
			return true;
		}
		// 返回一个Condition,每个Condition都包含一个condition实例
		Condition newCondition(){
			return new ConditionObject();
		}
	}
}

然后编写一个测试类,启动10个线程,竞争一个资源,每1.5秒打印一行信息

package com.spider.java;
import java.util.concurrent.locks.Lock;
import java.util.logging.Logger;
/**
 * 
 * @author yangcq
 * @description 队列同步器AbstractQueuedSynchronizer
 * @description public abstract class AbstractQueuedSynchronizer extends AbstractOwnableSynchronizer
 *
 */
public class AbstarctQueueSynchronizerLearning {
	// 打印logger日志
	static Logger logger = Logger.getAnonymousLogger();
	// 主方法
	public static void main(String[] args){
		test();
	}
	public static void test(){
		final Lock lock = new UserDefineLock();
		class ProductThread extends Thread{
			public void run(){
				while(true){
					lock.lock();
					try{
						sleep(1500);
						logger.info(Thread.currentThread().getName());
						sleep(1500);
					}
					catch(Exception e){
						lock.unlock();
					}
					finally{
						lock.unlock();
					}
				}
			}
		}
		// 启动5个线程
		for(int i=0;i<10;i++){
			ProductThread productThread = new ProductThread();
			productThread.setDaemon(true);
			productThread.start();
		}
		// 每隔1.5秒 打印 -----------
		for(int i=0;i<10;i++){
			try {
				ProductThread.sleep(1500);
				logger.info("-----------");
			} 
			catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
}

控制台输出信息(由于竞争关系,控制台输出是随机的,每次运行结果不同):

2016-7-31 1:44:04 com.spider.java.AbstarctQueueSynchronizerLearning test
信息: -----------
2016-7-31 1:44:04 com.spider.java.AbstarctQueueSynchronizerLearning$1ProductThread run
信息: Thread-1
2016-7-31 1:44:06 com.spider.java.AbstarctQueueSynchronizerLearning test
信息: -----------
2016-7-31 1:44:07 com.spider.java.AbstarctQueueSynchronizerLearning$1ProductThread run
信息: Thread-1
2016-7-31 1:44:07 com.spider.java.AbstarctQueueSynchronizerLearning test
信息: -----------
2016-7-31 1:44:09 com.spider.java.AbstarctQueueSynchronizerLearning test
信息: -----------
2016-7-31 1:44:10 com.spider.java.AbstarctQueueSynchronizerLearning test
信息: -----------
2016-7-31 1:44:10 com.spider.java.AbstarctQueueSynchronizerLearning$1ProductThread run
信息: Thread-1
2016-7-31 1:44:12 com.spider.java.AbstarctQueueSynchronizerLearning test
信息: -----------
2016-7-31 1:44:13 com.spider.java.AbstarctQueueSynchronizerLearning$1ProductThread run
信息: Thread-3
2016-7-31 1:44:13 com.spider.java.AbstarctQueueSynchronizerLearning test
信息: -----------
2016-7-31 1:44:15 com.spider.java.AbstarctQueueSynchronizerLearning test
信息: -----------
2016-7-31 1:44:16 com.spider.java.AbstarctQueueSynchronizerLearning test
信息: -----------
2016-7-31 1:44:16 com.spider.java.AbstarctQueueSynchronizerLearning$1ProductThread run
信息: Thread-3
2016-7-31 1:44:18 com.spider.java.AbstarctQueueSynchronizerLearning test
信息: -----------

五,可重入锁 java.util.concurrent.locks.ReentrantLock

1,什么是可重入锁

    可重入锁,就是支持重新进入的锁,也就是支持同一个线程重复的获取同一个锁。可

重入锁与我们之前定义的独占锁,有什么区别呢,一个明显的区别就是,如果我们在一个

线程A获取锁之后,再次调用lock.lock()方法,此时,线程A会被阻塞,线程A自己把自己

阻塞了,如果这样修改一下,上面程序的运行结果就会变成这样:

2016-7-31 1:58:50 com.spider.java.AbstarctQueueSynchronizerLearning test
信息: -----------
2016-7-31 1:58:51 com.spider.java.AbstarctQueueSynchronizerLearning test
信息: -----------
2016-7-31 1:58:53 com.spider.java.AbstarctQueueSynchronizerLearning test
信息: -----------
2016-7-31 1:58:54 com.spider.java.AbstarctQueueSynchronizerLearning test
信息: -----------
2016-7-31 1:58:56 com.spider.java.AbstarctQueueSynchronizerLearning test
信息: -----------
2016-7-31 1:58:57 com.spider.java.AbstarctQueueSynchronizerLearning test
信息: -----------
2016-7-31 1:58:59 com.spider.java.AbstarctQueueSynchronizerLearning test
信息: -----------
2016-7-31 1:59:00 com.spider.java.AbstarctQueueSynchronizerLearning test
信息: -----------
2016-7-31 1:59:02 com.spider.java.AbstarctQueueSynchronizerLearning test
信息: -----------
2016-7-31 1:59:03 com.spider.java.AbstarctQueueSynchronizerLearning test
信息: -----------

2,可重入锁是如何实现的

    可重入锁java.util.concurrent.locks.ReentrantLock中,有一个方法用来判断当前线程

是否是获取锁的线程,也就是说如果是一个已经获取锁的线程A,再次调用lock.lock()方法时,

可重入锁会将同步状态值加增加,然后返回true,表示获取锁成功。源代码如下:

        /**
         * 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;
        }

这样处理以后,释放锁时,相应的也要改变处理逻辑:

        protected final boolean tryRelease(int releases) {
            int c = getState() - releases;
            if (Thread.currentThread() != getExclusiveOwnerThread())
                throw new IllegalMonitorStateException();
            boolean free = false;
            if (c == 0) {
                free = true;
                setExclusiveOwnerThread(null);
            }
            setState(c);
            return free;
        }

3,可重入锁的公平与非公平竞争实现

    可重入锁支持以公平的方式,还是非公平的方式获取锁。设置很简单,通过下面的

代码,在创建锁对象时进行设置:

Lock lock = new ReentrantLock(true);    // 以公平的方式获取锁
Lock lock = new ReentrantLock(false);   // 以非公平的方式获取锁

源码如下:

    /**
     * Creates an instance of {@code ReentrantLock} with the
     * given fairness policy.
     *
     * @param fair {@code true} if this lock should use a fair ordering policy
     */
    public ReentrantLock(boolean fair) {
        sync = (fair)? new FairSync() : new NonfairSync();
    }

这2种获取锁的方式有什么区别呢?区别就在于,以公平方式获取锁时,会判断当前线程是

不是第一个请求获取该锁的线程。如果是第一个请求获取该锁的线程,则获取锁成功;否则

获取锁失败。

    /**
     * Sync object for fair locks  以公平的方式获取锁
     */
    final static class FairSync extends Sync {
        private static final long serialVersionUID = -3000897897090466540L;

        final void lock() {
            acquire(1);
        }
        protected final boolean tryAcquire(int acquires) {
            final Thread current = Thread.currentThread();
            int c = getState();
            if (c == 0) {
                // 区别就在于这里,以公平方式获取锁时,会判断当前线程是不是
                // 第一个请求获取该锁的线程。
                if (isFirst(current) && compareAndSetState(0, acquires)) {
                    setExclusiveOwnerThread(current);
                    return true;
                }
            }
            else if (current == getExclusiveOwnerThread()) {
                int nextc = c + acquires;
                if (nextc < 0)
                    throw new Error("Maximum lock count exceeded");
                setState(nextc);
                return true;
            }
            return false;
        }
    }
    /**
     * Sync object for non-fair locks 以非公平的方式获取锁
     */
    final static class NonfairSync extends Sync {
        private static final long serialVersionUID = 7316153563782823691L;
        final void lock() {
            if (compareAndSetState(0, 1))
                setExclusiveOwnerThread(Thread.currentThread());
            else
                acquire(1);
        }
        protected final boolean tryAcquire(int acquires) {
            return nonfairTryAcquire(acquires);
        }
    }
        // 非公平方式的方法实现nonfairTryAcquire
        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;
        }

六,读写锁 java.util.concurrent.locks.ReentrantReadWriteLock;

1,什么是读写锁

    读写锁这样一种锁,它允许多个线程在同一时刻同时访问某个资源。读写锁维护

了一对锁,一个读锁和一个写锁,其实原理就是读写分离,因为在以读为主的场景下,

大部分时间都是读取,我们都知道,多个读线程同时访问,始终能保持同步状态。所以

此时不加锁可以有效的提高程序的执行速度。

2,读写锁的实现原理

    读写锁的原理,其实就是维护了2个锁,一个读锁和一个写锁。在读操作时获取读

锁,写操作时获取写锁。当写锁被获取到时,后面的读写请求都被阻塞,写锁释放后,

后面的读写操作继续执行。

public class ReentrantReadWriteLock implements ReadWriteLock, java.io.Serializable
    /** Inner class providing readlock  读锁(内部类)*/
    private final ReentrantReadWriteLock.ReadLock readerLock;
    /** Inner class providing writelock 写锁(内部类)*/
    private final ReentrantReadWriteLock.WriteLock writerLock;
    /** Performs all synchronization mechanics 队列同步器AQS实现类*/
    private final Sync sync;

    读锁和写锁,都是ReentrantReadWriteLock的内部类,这2个锁,都是实现了Lock接口的

实现类。

public static class ReadLock implements Lock, java.io.Serializable   // 读锁
public static class WriteLock implements Lock, java.io.Serializable  // 写锁

七,Condition接口

1,Condition的作用

    Condition接口提供了类似Object的监视器方法,与锁配合可以实现等待/通知模式。我们

都知道,任意一个Java对象,都具有下面这几个方法:

wait();              // 等待

wait(long timeout);  // 超时等待

notify();            // 唤醒

notifyAll();         // 唤醒所有

这些方法我们很少用到,但是Java都提供给我们了。这些方法有什么作用呢?其实这些方法都

是Object对象的监视器,与synchronized关键字配合使用,可以实现等待/通知模式。

Condition接口也提供了类似的一些方法,源码如下:

public interface Condition {
    void await() throws InterruptedException;
    void awaitUninterruptibly();
    long awaitNanos(long nanosTimeout) throws InterruptedException;
    boolean await(long time, TimeUnit unit) throws InterruptedException;
    boolean awaitUntil(Date deadline) throws InterruptedException;
    void signal();
    void signalAll();
}

Condition接口与Lock配合,可以实现等待/通知模式。看到这里,大家可能有些疑惑了,

Object监视器    + synchronized关键字

Condition监视器 + Lock

这不就是等待/通知模式的升级版吗!

2,Condition的使用

package com.spider.java;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
import java.util.logging.Logger;
/**
 * 
 * @author yangcq
 * @description Condition接口 + Lock 实现等待/通知模式
 * @description 测试类 ConditionLearningTest
 *
 */
public class ConditionLearning {
	static Logger logger = Logger.getAnonymousLogger(); // 日志
	Lock lock = new ReentrantLock();
	Condition condition_get = lock.newCondition();
	
	// 定义一个Map
	Map<String,String> map = new HashMap<String,String>();
	
	// 取值 -- 如果值为空,则等待...
	public void conditionWait() throws InterruptedException{
		map.put("yangcq", "");
		lock.lock();
		try{
			while("".equals(map.get("yangcq"))){
				logger.info("key 'yangcq' 为空,不能取值...");
				condition_get.await();
			}
			logger.info("key 'yangcq' 的值为:" + map.get("yangcq"));
		}
		finally{
			lock.unlock();
		}
	}
	// 赋值 -- 赋值以后,有值了,唤醒
	public void conditionSignal() throws InterruptedException{
		map.put("yangcq", "1988");
		lock.lock();
		try{
			if("".equals(map.get("yangcq"))){
				logger.info("key 'yangcq' 为空,不能让其他方法从这里取值...");
			}
			else{
				logger.info("key 'yangcq' 有值,可以唤醒取值的方法");
				// 唤醒取值线程(消费者线程)
				condition_get.signal();
			}
		}
		finally{
			lock.unlock();
		}
	}
}

测试类:ConditionLearningTest.java

package com.spider.java;
/**
 * 
 * @author yangcq
 * @description Condition接口 + Lock 实现等待/通知模式测试
 *
 */
public class ConditionLearningTest {
	// 创建ConditionLearning对象
	static ConditionLearning conditionLearning = new ConditionLearning();
	
	public static void main(String[] args) {
		getValue(); // 初始值为空,消费者线程等待...
		putValue(); // 生产者赋值以后,有值了,通知消费者线程,然后消费者线程唤醒
	}
	
	@SuppressWarnings("static-access")
	public static void getValue(){
		// 消费者线程
		class ConsumerThread extends Thread{
			public void run(){
				try {
					conditionLearning.conditionWait();
				} 
				catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		}
		ConsumerThread ConsumerThread = new ConsumerThread();
		ConsumerThread.start();
		try {
			ConsumerThread.sleep(2000);
		} 
		catch (InterruptedException e) {
			e.printStackTrace();
		}
	}

	public static void putValue(){
		// 生产者线程
		class ProductThread extends Thread{
			public void run(){
				try {
					conditionLearning.conditionSignal();
				} 
				catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		}
		ProductThread ProductThread = new ProductThread();
		ProductThread.start();
	}
}

好了,写到这里,关于锁的讲解暂时告一段落,笔者水平有限,难免有不妥之处,请见谅。

    原文作者:java锁
    原文地址: https://blog.csdn.net/reggergdsg/article/details/52078265
    本文转自网络文章,转载此文章仅为分享知识,如有侵权,请联系博主进行删除。
点赞