java锁机制
2.4 锁机制
临界区是指，使用同一个锁控制的同一段代码区或多段代码区之间，在同一时间内最多只能有一个线程在执行操作。这个概念与传统的临界区有略微的差别，这里不想强调这些概念上的差别，临界区的这样定义有利于我们对后面内容的理解。几乎所有设计到多线程的语言都会涉及到临界区和锁的概念，java也不例外，在java中可以有多种方式实现临界区语义，最常使用的是锁机制和Synchronized（Synchronized也是一种锁）关键字，有时也可以用阻塞队列达到同样的效果。（这里，我们不会对临界区的概念进行过多解释，相信已经有足够的书籍对这个概念进行了深入的探讨）。
2.4.1 Lock/Condition锁机制
Lock/Condition模式临界区控制是比较复杂的，却是使用范围最广的。在稍后我们会看到使用Lock/Condition方式保护临界区在某些情况下是唯一选择。但是由于Lock/Condition模式的复杂性，很容易造成死锁，所以使用起来也要特别慎重。
2.4.1 Lock
可以在临界区代码开始的位置执行Lock类的lock方法，为代码块加锁，而在临界区的出口使用相同Lock实例的unlock方法，释放临界区资源。
Demo2-12中，主线程先创建了一个lockTest对象test，然后将相同的test对象交给两个不同的线程执行。子线程1获取到了lock后，开始执行before sleep输出语句，遇到sleep后，线程1阻塞将会放弃执行权，这时线程2可以获取执行权，当线程2执行lock方法时，发现锁已经被别的线程获取，所以线程2阻塞等待lock的释放。线程1从sleep中被唤醒后，将继续执行after sleep语句，之后释放了锁，此时线程2从锁等待中被唤醒，执行临近区的内容，因此Demo2-12的输出是先线程1的两条语句，之后才输出线程2的两条语句。而Demo2-13在没有锁的保护下，程序无法保证先将线程1的两条语句输出后再执行线程2的输出，因此，Demo2-13的输出结果是交叉的。
Demo2-12和Demo2-13中使用的sleep语句使得当前线程放弃执行权一段时间，其他线程可以获取执行机会，此外，临界区是相对于同一个锁对象而言的，一般而言，被同一个锁锁住的同一个或者不同的临界区不能同时被两个以上线程同时执行。临界区的概念与前面提到的同步概念不同，同步强调不同线程间协调进度，而锁更强调的是保护代码不会被多个线程冲突执行。Demo2-14给出了这点说明。
Demo2-14中，两个线程调用了不同的执行方法，但是这两个方法使用相同的锁进行加锁和解锁，因此他们属于线程冲突的。所以临界区是相对于锁对象来说的。同一时刻，有且仅有一个线程对同一个锁的一个或多个临界区进行操作。
Demo2-12 有锁的多线程临界区
package com.upc.upcgrid.guan.advancedJava.chapter02;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
class lockTest implements Runnable{
Lock lock = new ReentrantLock();
@Override
public void run() {
lock.lock();
try{
System.err.println(Thread.currentThread().getName() + " before Sleep ");
try {
Thread.sleep(10);
} catch (InterruptedException e) {}
System.err.println(Thread.currentThread().getName() + " after sleep ");
}finally{
lock.unlock();
}
}
}
public class LockSyn {
public static void main(String[] args) throws InterruptedException {
lockTest test = new lockTest();
new Thread(test).start();
new Thread(test).start();
}
}
Demo 2-12 执行结果：
Thread-0 before Sleep
Thread-0 after sleep
Thread-1 before Sleep
Thread-1 after sleep
Demo1-13 没有锁的临界区
package com.upc.upcgrid.guan.advancedJava.chapter02;
class NolockTest implements Runnable{
@Override
public void run() {
System.err.println(Thread.currentThread().getName() + " before Sleep ");
try {
Thread.sleep(10);
} catch (InterruptedException e) {}
System.err.println(Thread.currentThread().getName() + " after sleep ");
}
}
public class NoLockSyn {
public static void main(String[] args) throws InterruptedException {
NolockTest test = new NolockTest();
new Thread(test).start();
new Thread(test).start();
}
}
Demo2-13的执行结果：
Thread-0 before Sleep
Thread-1 before Sleep
Thread-0 after sleep
Thread-1 after sleep
Demo2-14 临界区是相对锁
package com.upc.upcgrid.guan.advancedJava.chapter02;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
class lockTestMuti implements Runnable{
Lock lock = new ReentrantLock();
volatile boolean isFunction1 = false;
private void function1()
{
lock.lock();
try{
System.err.println("function1");
System.err.println(Thread.currentThread().getName() + " before Sleep ");
try {
Thread.sleep(10);
} catch (InterruptedException e) {}
System.err.println(Thread.currentThread().getName() + " after sleep ");
}finally{
lock.unlock();
}
}
private void function2()
{
lock.lock();
try{
System.err.println("function2");
System.err.println(Thread.currentThread().getName() + " before Sleep ");
try {
Thread.sleep(10);
} catch (InterruptedException e) {}
System.err.println(Thread.currentThread().getName() + " after sleep ");
}finally{
lock.unlock();
}
}
@Override
public void run() {
isFunction1 = !isFunction1;
if(isFunction1)
{
function1();
}else
{
function2();
}
}
}
public class LockSynMutiMethods {
public static void main(String[] args) throws InterruptedException {
lockTestMuti test = new lockTestMuti();
new Thread(test).start();
new Thread(test).start();
}
}
Demo2-14 执行结果
function1
Thread-0 before Sleep
Thread-0 after sleep
function2
Thread-1 before Sleep
Thread-1 after sleep
2.4.2 可重入锁
ReentrantLock是实现Lock接口的一个锁的实现，被称为可重入锁。所谓锁的可重入性是指，同一个线程可以多次获取相同的锁对象。ReentrantLock锁内部维护一个关于锁的计数，每次调用lock方法，这个计数加一，每次调用一次unlock方法，这个计数减一，直至ReentrantLock中的计数值减少为0时，锁才会真正被释放。
Demo2-15中，主线程开启了一个子线程，在子线程中创建了一个可重入锁，线程在执行function1时获取了锁，在function1调用function2时又需要获取锁，这时lock的计数应当是2，当离开function2时执行了unlock方法，此时的计数是1，当离开function1时，调用了unlock方法，此时的锁计数为0，锁被释放。Demo2-16给出了可重入锁的模拟实现，在这个示例中，通过一个阻塞队列完成锁的阻塞功能，代码原理请读者自行分析。
Demo2-15
package com.upc.upcgrid.guan.advancedJava.chapter02;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class ReentrantLockSyn {
public static void main(String[] args) {
new Thread(new Runnable() {
Lock lock = new ReentrantLock();
private void function1()
{
lock.lock();
try{
System.err.println(Thread.currentThread().getName());
function2();
}finally{
lock.unlock();
}
}
private void function2()
{
lock.lock();
try{
System.err.println(Thread.currentThread().getName());
}finally{
lock.unlock();
}
}
@Override
public void run() {
function1();
}
}).start();
}
}
输出结果：
Thread-0
Thread-0
Demo2-16 模拟可重入锁
package com.upc.upcgrid.guan.advancedJava.chapter02;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
class LockElement{
public LockElement(Thread thread) {
this.thread = thread;
}
public int count = 1;
public Thread thread;
}
public class MyReentrantLock {
private BlockingQueue<LockElement> queue = new ArrayBlockingQueue<LockElement>(1);
public void lock() throws InterruptedException
{
LockElement element = queue.peek();
if(element != null && element.thread == Thread.currentThread())//锁的重入
++element.count;
else if(element != null)
queue.put(element);//队列空，直接获取锁
else
{
queue.put(new LockElement(Thread.currentThread()));//队列非空，需要阻塞等待放入新锁
}
}
public void unlock() throws InterruptedException
{
LockElement element = queue.peek();
if(element != null && element.thread == Thread.currentThread())//重入锁释放
{
if(--element.count <= 0)//计数减到0，释放锁资源,否则仅对计数减少1
queue.take();
}else{//这是异常，正常情况下不能出现
System.err.println("锁释放错误");
}
}
}
2.4 锁机制
临界区是指，使用同一个锁控制的同一段代码区或多段代码区之间，在同一时间内最多只能有一个线程在执行操作。这个概念与传统的临界区有略微的差别，这里不想强调这些概念上的差别，临界区的这样定义有利于我们对后面内容的理解。几乎所有设计到多线程的语言都会涉及到临界区和锁的概念，java也不例外，在java中可以有多种方式实现临界区语义，最常使用的是锁机制和Synchronized（Synchronized也是一种锁）关键字，有时也可以用阻塞队列达到同样的效果。（这里，我们不会对临界区的概念进行过多解释，相信已经有足够的书籍对这个概念进行了深入的探讨）。
2.4.1 Lock/Condition锁机制
Lock/Condition模式临界区控制是比较复杂的，却是使用范围最广的。在稍后我们会看到使用Lock/Condition方式保护临界区在某些情况下是唯一选择。但是由于Lock/Condition模式的复杂性，很容易造成死锁，所以使用起来也要特别慎重。
2.4.1 Lock
可以在临界区代码开始的位置执行Lock类的lock方法，为代码块加锁，而在临界区的出口使用相同Lock实例的unlock方法，释放临界区资源。
Demo2-12中，主线程先创建了一个lockTest对象test，然后将相同的test对象交给两个不同的线程执行。子线程1获取到了lock后，开始执行before sleep输出语句，遇到sleep后，线程1阻塞将会放弃执行权，这时线程2可以获取执行权，当线程2执行lock方法时，发现锁已经被别的线程获取，所以线程2阻塞等待lock的释放。线程1从sleep中被唤醒后，将继续执行after sleep语句，之后释放了锁，此时线程2从锁等待中被唤醒，执行临近区的内容，因此Demo2-12的输出是先线程1的两条语句，之后才输出线程2的两条语句。而Demo2-13在没有锁的保护下，程序无法保证先将线程1的两条语句输出后再执行线程2的输出，因此，Demo2-13的输出结果是交叉的。
Demo2-12和Demo2-13中使用的sleep语句使得当前线程放弃执行权一段时间，其他线程可以获取执行机会，此外，临界区是相对于同一个锁对象而言的，一般而言，被同一个锁锁住的同一个或者不同的临界区不能同时被两个以上线程同时执行。临界区的概念与前面提到的同步概念不同，同步强调不同线程间协调进度，而锁更强调的是保护代码不会被多个线程冲突执行。Demo2-14给出了这点说明。
Demo2-14中，两个线程调用了不同的执行方法，但是这两个方法使用相同的锁进行加锁和解锁，因此他们属于线程冲突的。所以临界区是相对于锁对象来说的。同一时刻，有且仅有一个线程对同一个锁的一个或多个临界区进行操作。
Demo2-12 有锁的多线程临界区
package com.upc.upcgrid.guan.advancedJava.chapter02;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
class lockTest implements Runnable{
Lock lock = new ReentrantLock();
@Override
public void run() {
lock.lock();
try{
System.err.println(Thread.currentThread().getName() + " before Sleep ");
try {
Thread.sleep(10);
} catch (InterruptedException e) {}
System.err.println(Thread.currentThread().getName() + " after sleep ");
}finally{
lock.unlock();
}
}
}
public class LockSyn {
public static void main(String[] args) throws InterruptedException {
lockTest test = new lockTest();
new Thread(test).start();
new Thread(test).start();
}
}
Demo 2-12 执行结果：
Thread-0 before Sleep
Thread-0 after sleep
Thread-1 before Sleep
Thread-1 after sleep
Demo1-13 没有锁的临界区
package com.upc.upcgrid.guan.advancedJava.chapter02;
class NolockTest implements Runnable{
@Override
public void run() {
System.err.println(Thread.currentThread().getName() + " before Sleep ");
try {
Thread.sleep(10);
} catch (InterruptedException e) {}
System.err.println(Thread.currentThread().getName() + " after sleep ");
}
}
public class NoLockSyn {
public static void main(String[] args) throws InterruptedException {
NolockTest test = new NolockTest();
new Thread(test).start();
new Thread(test).start();
}
}
Demo2-13的执行结果：
Thread-0 before Sleep
Thread-1 before Sleep
Thread-0 after sleep
Thread-1 after sleep
Demo2-14 临界区是相对锁
package com.upc.upcgrid.guan.advancedJava.chapter02;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
class lockTestMuti implements Runnable{
Lock lock = new ReentrantLock();
volatile boolean isFunction1 = false;
private void function1()
{
lock.lock();
try{
System.err.println("function1");
System.err.println(Thread.currentThread().getName() + " before Sleep ");
try {
Thread.sleep(10);
} catch (InterruptedException e) {}
System.err.println(Thread.currentThread().getName() + " after sleep ");
}finally{
lock.unlock();
}
}
private void function2()
{
lock.lock();
try{
System.err.println("function2");
System.err.println(Thread.currentThread().getName() + " before Sleep ");
try {
Thread.sleep(10);
} catch (InterruptedException e) {}
System.err.println(Thread.currentThread().getName() + " after sleep ");
}finally{
lock.unlock();
}
}
@Override
public void run() {
isFunction1 = !isFunction1;
if(isFunction1)
{
function1();
}else
{
function2();
}
}
}
public class LockSynMutiMethods {
public static void main(String[] args) throws InterruptedException {
lockTestMuti test = new lockTestMuti();
new Thread(test).start();
new Thread(test).start();
}
}
Demo2-14 执行结果
function1
Thread-0 before Sleep
Thread-0 after sleep
function2
Thread-1 before Sleep
Thread-1 after sleep
2.4.2 可重入锁
ReentrantLock是实现Lock接口的一个锁的实现，被称为可重入锁。所谓锁的可重入性是指，同一个线程可以多次获取相同的锁对象。ReentrantLock锁内部维护一个关于锁的计数，每次调用lock方法，这个计数加一，每次调用一次unlock方法，这个计数减一，直至ReentrantLock中的计数值减少为0时，锁才会真正被释放。
Demo2-15中，主线程开启了一个子线程，在子线程中创建了一个可重入锁，线程在执行function1时获取了锁，在function1调用function2时又需要获取锁，这时lock的计数应当是2，当离开function2时执行了unlock方法，此时的计数是1，当离开function1时，调用了unlock方法，此时的锁计数为0，锁被释放。Demo2-16给出了可重入锁的模拟实现，在这个示例中，通过一个阻塞队列完成锁的阻塞功能，代码原理请读者自行分析。
Demo2-15
package com.upc.upcgrid.guan.advancedJava.chapter02;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class ReentrantLockSyn {
public static void main(String[] args) {
new Thread(new Runnable() {
Lock lock = new ReentrantLock();
private void function1()
{
lock.lock();
try{
System.err.println(Thread.currentThread().getName());
function2();
}finally{
lock.unlock();
}
}
private void function2()
{
lock.lock();
try{
System.err.println(Thread.currentThread().getName());
}finally{
lock.unlock();
}
}
@Override
public void run() {
function1();
}
}).start();
}
}
输出结果：
Thread-0
Thread-0
Demo2-16 模拟可重入锁
package com.upc.upcgrid.guan.advancedJava.chapter02;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
class LockElement{
public LockElement(Thread thread) {
this.thread = thread;
}
public int count = 1;
public Thread thread;
}
public class MyReentrantLock {
private BlockingQueue<LockElement> queue = new ArrayBlockingQueue<LockElement>(1);
public void lock() throws InterruptedException
{
LockElement element = queue.peek();
if(element != null && element.thread == Thread.currentThread())//锁的重入
++element.count;
else if(element != null)
queue.put(element);//队列空，直接获取锁
else
{
queue.put(new LockElement(Thread.currentThread()));//队列非空，需要阻塞等待放入新锁
}
}
public void unlock() throws InterruptedException
{
LockElement element = queue.peek();
if(element != null && element.thread == Thread.currentThread())//重入锁释放
{
if(--element.count <= 0)//计数减到0，释放锁资源,否则仅对计数减少1
queue.take();
}else{//这是异常，正常情况下不能出现
System.err.println("锁释放错误");
}
}
}
2.4 锁机制
临界区是指，使用同一个锁控制的同一段代码区或多段代码区之间，在同一时间内最多只能有一个线程在执行操作。这个概念与传统的临界区有略微的差别，这里不想强调这些概念上的差别，临界区的这样定义有利于我们对后面内容的理解。几乎所有设计到多线程的语言都会涉及到临界区和锁的概念，java也不例外，在java中可以有多种方式实现临界区语义，最常使用的是锁机制和Synchronized（Synchronized也是一种锁）关键字，有时也可以用阻塞队列达到同样的效果。（这里，我们不会对临界区的概念进行过多解释，相信已经有足够的书籍对这个概念进行了深入的探讨）。
2.4.1 Lock/Condition锁机制
Lock/Condition模式临界区控制是比较复杂的，却是使用范围最广的。在稍后我们会看到使用Lock/Condition方式保护临界区在某些情况下是唯一选择。但是由于Lock/Condition模式的复杂性，很容易造成死锁，所以使用起来也要特别慎重。
2.4.1 Lock
可以在临界区代码开始的位置执行Lock类的lock方法，为代码块加锁，而在临界区的出口使用相同Lock实例的unlock方法，释放临界区资源。
Demo2-12中，主线程先创建了一个lockTest对象test，然后将相同的test对象交给两个不同的线程执行。子线程1获取到了lock后，开始执行before sleep输出语句，遇到sleep后，线程1阻塞将会放弃执行权，这时线程2可以获取执行权，当线程2执行lock方法时，发现锁已经被别的线程获取，所以线程2阻塞等待lock的释放。线程1从sleep中被唤醒后，将继续执行after sleep语句，之后释放了锁，此时线程2从锁等待中被唤醒，执行临近区的内容，因此Demo2-12的输出是先线程1的两条语句，之后才输出线程2的两条语句。而Demo2-13在没有锁的保护下，程序无法保证先将线程1的两条语句输出后再执行线程2的输出，因此，Demo2-13的输出结果是交叉的。
Demo2-12和Demo2-13中使用的sleep语句使得当前线程放弃执行权一段时间，其他线程可以获取执行机会，此外，临界区是相对于同一个锁对象而言的，一般而言，被同一个锁锁住的同一个或者不同的临界区不能同时被两个以上线程同时执行。临界区的概念与前面提到的同步概念不同，同步强调不同线程间协调进度，而锁更强调的是保护代码不会被多个线程冲突执行。Demo2-14给出了这点说明。
Demo2-14中，两个线程调用了不同的执行方法，但是这两个方法使用相同的锁进行加锁和解锁，因此他们属于线程冲突的。所以临界区是相对于锁对象来说的。同一时刻，有且仅有一个线程对同一个锁的一个或多个临界区进行操作。
Demo2-12 有锁的多线程临界区
package com.upc.upcgrid.guan.advancedJava.chapter02;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
class lockTest implements Runnable{
Lock lock = new ReentrantLock();
@Override
public void run() {
lock.lock();
try{
System.err.println(Thread.currentThread().getName() + " before Sleep ");
try {
Thread.sleep(10);
} catch (InterruptedException e) {}
System.err.println(Thread.currentThread().getName() + " after sleep ");
}finally{
lock.unlock();
}
}
}
public class LockSyn {
public static void main(String[] args) throws InterruptedException {
lockTest test = new lockTest();
new Thread(test).start();
new Thread(test).start();
}
}
Demo 2-12 执行结果：
Thread-0 before Sleep
Thread-0 after sleep
Thread-1 before Sleep
Thread-1 after sleep
Demo1-13 没有锁的临界区
package com.upc.upcgrid.guan.advancedJava.chapter02;
class NolockTest implements Runnable{
@Override
public void run() {
System.err.println(Thread.currentThread().getName() + " before Sleep ");
try {
Thread.sleep(10);
} catch (InterruptedException e) {}
System.err.println(Thread.currentThread().getName() + " after sleep ");
}
}
public class NoLockSyn {
public static void main(String[] args) throws InterruptedException {
NolockTest test = new NolockTest();
new Thread(test).start();
new Thread(test).start();
}
}
Demo2-13的执行结果：
Thread-0 before Sleep
Thread-1 before Sleep
Thread-0 after sleep
Thread-1 after sleep
Demo2-14 临界区是相对锁
package com.upc.upcgrid.guan.advancedJava.chapter02;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
class lockTestMuti implements Runnable{
Lock lock = new ReentrantLock();
volatile boolean isFunction1 = false;
private void function1()
{
lock.lock();
try{
System.err.println("function1");
System.err.println(Thread.currentThread().getName() + " before Sleep ");
try {
Thread.sleep(10);
} catch (InterruptedException e) {}
System.err.println(Thread.currentThread().getName() + " after sleep ");
}finally{
lock.unlock();
}
}
private void function2()
{
lock.lock();
try{
System.err.println("function2");
System.err.println(Thread.currentThread().getName() + " before Sleep ");
try {
Thread.sleep(10);
} catch (InterruptedException e) {}
System.err.println(Thread.currentThread().getName() + " after sleep ");
}finally{
lock.unlock();
}
}
@Override
public void run() {
isFunction1 = !isFunction1;
if(isFunction1)
{
function1();
}else
{
function2();
}
}
}
public class LockSynMutiMethods {
public static void main(String[] args) throws InterruptedException {
lockTestMuti test = new lockTestMuti();
new Thread(test).start();
new Thread(test).start();
}
}
Demo2-14 执行结果
function1
Thread-0 before Sleep
Thread-0 after sleep
function2
Thread-1 before Sleep
Thread-1 after sleep
2.4.2 可重入锁
ReentrantLock是实现Lock接口的一个锁的实现，被称为可重入锁。所谓锁的可重入性是指，同一个线程可以多次获取相同的锁对象。ReentrantLock锁内部维护一个关于锁的计数，每次调用lock方法，这个计数加一，每次调用一次unlock方法，这个计数减一，直至ReentrantLock中的计数值减少为0时，锁才会真正被释放。
Demo2-15中，主线程开启了一个子线程，在子线程中创建了一个可重入锁，线程在执行function1时获取了锁，在function1调用function2时又需要获取锁，这时lock的计数应当是2，当离开function2时执行了unlock方法，此时的计数是1，当离开function1时，调用了unlock方法，此时的锁计数为0，锁被释放。Demo2-16给出了可重入锁的模拟实现，在这个示例中，通过一个阻塞队列完成锁的阻塞功能，代码原理请读者自行分析。
Demo2-15
package com.upc.upcgrid.guan.advancedJava.chapter02;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class ReentrantLockSyn {
public static void main(String[] args) {
new Thread(new Runnable() {
Lock lock = new ReentrantLock();
private void function1()
{
lock.lock();
try{
System.err.println(Thread.currentThread().getName());
function2();
}finally{
lock.unlock();
}
}
private void function2()
{
lock.lock();
try{
System.err.println(Thread.currentThread().getName());
}finally{
lock.unlock();
}
}
@Override
public void run() {
function1();
}
}).start();
}
}
输出结果：
Thread-0
Thread-0
Demo2-16 模拟可重入锁
package com.upc.upcgrid.guan.advancedJava.chapter02;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
class LockElement{
public LockElement(Thread thread) {
this.thread = thread;
}
public int count = 1;
public Thread thread;
}
public class MyReentrantLock {
private BlockingQueue<LockElement> queue = new ArrayBlockingQueue<LockElement>(1);
public void lock() throws InterruptedException
{
LockElement element = queue.peek();
if(element != null && element.thread == Thread.currentThread())//锁的重入
++element.count;
else if(element != null)
queue.put(element);//队列空，直接获取锁
else
{
queue.put(new LockElement(Thread.currentThread()));//队列非空，需要阻塞等待放入新锁
}
}
public void unlock() throws InterruptedException
{
LockElement element = queue.peek();
if(element != null && element.thread == Thread.currentThread())//重入锁释放
{
if(--element.count <= 0)//计数减到0，释放锁资源,否则仅对计数减少1
queue.take();
}else{//这是异常，正常情况下不能出现
System.err.println("锁释放错误");
}
}
}
2.4 锁机制
临界区是指，使用同一个锁控制的同一段代码区或多段代码区之间，在同一时间内最多只能有一个线程在执行操作。这个概念与传统的临界区有略微的差别，这里不想强调这些概念上的差别，临界区的这样定义有利于我们对后面内容的理解。几乎所有设计到多线程的语言都会涉及到临界区和锁的概念，java也不例外，在java中可以有多种方式实现临界区语义，最常使用的是锁机制和Synchronized（Synchronized也是一种锁）关键字，有时也可以用阻塞队列达到同样的效果。（这里，我们不会对临界区的概念进行过多解释，相信已经有足够的书籍对这个概念进行了深入的探讨）。
2.4.1 Lock/Condition锁机制
Lock/Condition模式临界区控制是比较复杂的，却是使用范围最广的。在稍后我们会看到使用Lock/Condition方式保护临界区在某些情况下是唯一选择。但是由于Lock/Condition模式的复杂性，很容易造成死锁，所以使用起来也要特别慎重。
2.4.1 Lock
可以在临界区代码开始的位置执行Lock类的lock方法，为代码块加锁，而在临界区的出口使用相同Lock实例的unlock方法，释放临界区资源。
Demo2-12中，主线程先创建了一个lockTest对象test，然后将相同的test对象交给两个不同的线程执行。子线程1获取到了lock后，开始执行before sleep输出语句，遇到sleep后，线程1阻塞将会放弃执行权，这时线程2可以获取执行权，当线程2执行lock方法时，发现锁已经被别的线程获取，所以线程2阻塞等待lock的释放。线程1从sleep中被唤醒后，将继续执行after sleep语句，之后释放了锁，此时线程2从锁等待中被唤醒，执行临近区的内容，因此Demo2-12的输出是先线程1的两条语句，之后才输出线程2的两条语句。而Demo2-13在没有锁的保护下，程序无法保证先将线程1的两条语句输出后再执行线程2的输出，因此，Demo2-13的输出结果是交叉的。
Demo2-12和Demo2-13中使用的sleep语句使得当前线程放弃执行权一段时间，其他线程可以获取执行机会，此外，临界区是相对于同一个锁对象而言的，一般而言，被同一个锁锁住的同一个或者不同的临界区不能同时被两个以上线程同时执行。临界区的概念与前面提到的同步概念不同，同步强调不同线程间协调进度，而锁更强调的是保护代码不会被多个线程冲突执行。Demo2-14给出了这点说明。
Demo2-14中，两个线程调用了不同的执行方法，但是这两个方法使用相同的锁进行加锁和解锁，因此他们属于线程冲突的。所以临界区是相对于锁对象来说的。同一时刻，有且仅有一个线程对同一个锁的一个或多个临界区进行操作。
Demo2-12 有锁的多线程临界区
package com.upc.upcgrid.guan.advancedJava.chapter02;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
class lockTest implements Runnable{
Lock lock = new ReentrantLock();
@Override
public void run() {
lock.lock();
try{
System.err.println(Thread.currentThread().getName() + " before Sleep ");
try {
Thread.sleep(10);
} catch (InterruptedException e) {}
System.err.println(Thread.currentThread().getName() + " after sleep ");
}finally{
lock.unlock();
}
}
}
public class LockSyn {
public static void main(String[] args) throws InterruptedException {
lockTest test = new lockTest();
new Thread(test).start();
new Thread(test).start();
}
}
Demo 2-12 执行结果：
Thread-0 before Sleep
Thread-0 after sleep
Thread-1 before Sleep
Thread-1 after sleep
Demo1-13 没有锁的临界区
package com.upc.upcgrid.guan.advancedJava.chapter02;
class NolockTest implements Runnable{
@Override
public void run() {
System.err.println(Thread.currentThread().getName() + " before Sleep ");
try {
Thread.sleep(10);
} catch (InterruptedException e) {}
System.err.println(Thread.currentThread().getName() + " after sleep ");
}
}
public class NoLockSyn {
public static void main(String[] args) throws InterruptedException {
NolockTest test = new NolockTest();
new Thread(test).start();
new Thread(test).start();
}
}
Demo2-13的执行结果：
Thread-0 before Sleep
Thread-1 before Sleep
Thread-0 after sleep
Thread-1 after sleep
Demo2-14 临界区是相对锁
package com.upc.upcgrid.guan.advancedJava.chapter02;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
class lockTestMuti implements Runnable{
Lock lock = new ReentrantLock();
volatile boolean isFunction1 = false;
private void function1()
{
lock.lock();
try{
System.err.println("function1");
System.err.println(Thread.currentThread().getName() + " before Sleep ");
try {
Thread.sleep(10);
} catch (InterruptedException e) {}
System.err.println(Thread.currentThread().getName() + " after sleep ");
}finally{
lock.unlock();
}
}
private void function2()
{
lock.lock();
try{
System.err.println("function2");
System.err.println(Thread.currentThread().getName() + " before Sleep ");
try {
Thread.sleep(10);
} catch (InterruptedException e) {}
System.err.println(Thread.currentThread().getName() + " after sleep ");
}finally{
lock.unlock();
}
}
@Override
public void run() {
isFunction1 = !isFunction1;
if(isFunction1)
{
function1();
}else
{
function2();
}
}
}
public class LockSynMutiMethods {
public static void main(String[] args) throws InterruptedException {
lockTestMuti test = new lockTestMuti();
new Thread(test).start();
new Thread(test).start();
}
}
Demo2-14 执行结果
function1
Thread-0 before Sleep
Thread-0 after sleep
function2
Thread-1 before Sleep
Thread-1 after sleep
2.4.2 可重入锁
ReentrantLock是实现Lock接口的一个锁的实现，被称为可重入锁。所谓锁的可重入性是指，同一个线程可以多次获取相同的锁对象。ReentrantLock锁内部维护一个关于锁的计数，每次调用lock方法，这个计数加一，每次调用一次unlock方法，这个计数减一，直至ReentrantLock中的计数值减少为0时，锁才会真正被释放。
Demo2-15中，主线程开启了一个子线程，在子线程中创建了一个可重入锁，线程在执行function1时获取了锁，在function1调用function2时又需要获取锁，这时lock的计数应当是2，当离开function2时执行了unlock方法，此时的计数是1，当离开function1时，调用了unlock方法，此时的锁计数为0，锁被释放。Demo2-16给出了可重入锁的模拟实现，在这个示例中，通过一个阻塞队列完成锁的阻塞功能，代码原理请读者自行分析。
Demo2-15
package com.upc.upcgrid.guan.advancedJava.chapter02;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class ReentrantLockSyn {
public static void main(String[] args) {
new Thread(new Runnable() {
Lock lock = new ReentrantLock();
private void function1()
{
lock.lock();
try{
System.err.println(Thread.currentThread().getName());
function2();
}finally{
lock.unlock();
}
}
private void function2()
{
lock.lock();
try{
System.err.println(Thread.currentThread().getName());
}finally{
lock.unlock();
}
}
@Override
public void run() {
function1();
}
}).start();
}
}
输出结果：
Thread-0
Thread-0
Demo2-16 模拟可重入锁
package com.upc.upcgrid.guan.advancedJava.chapter02;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
class LockElement{
public LockElement(Thread thread) {
this.thread = thread;
}
public int count = 1;
public Thread thread;
}
public class MyReentrantLock {
private BlockingQueue<LockElement> queue = new ArrayBlockingQueue<LockElement>(1);
public void lock() throws InterruptedException
{
LockElement element = queue.peek();
if(element != null && element.thread == Thread.currentThread())//锁的重入
++element.count;
else if(element != null)
queue.put(element);//队列空，直接获取锁
else
{
queue.put(new LockElement(Thread.currentThread()));//队列非空，需要阻塞等待放入新锁
}
}
public void unlock() throws InterruptedException
{
LockElement element = queue.peek();
if(element != null && element.thread == Thread.currentThread())//重入锁释放
{
if(--element.count <= 0)//计数减到0，释放锁资源,否则仅对计数减少1
queue.take();
}else{//这是异常，正常情况下不能出现
System.err.println("锁释放错误");
}
}
}
java锁机制的更多相关文章
- 转 : 深入解析Java锁机制
深入解析Java锁机制 https://mp.weixin.qq.com/s?__biz=MzU0OTE4MzYzMw%3D%3D&mid=2247485524&idx=1&s ...
- Java 锁机制总结
锁的种类 独享锁 VS 共享锁 独享锁:锁只能被一个线程持有(synchronized) 共享锁:锁可以被多个程序所持有(读写锁) 乐观锁 VS 悲观锁 乐观锁:每次去拿数据的时候都乐观地认为别人不会 ...
- java锁机制的面试题
java锁机制的面试题 1.ABA问题 2.CAS乐观锁 3.synchronize实现原理 4.synchronize与lock的区别 5.volatile实现原理 6.乐观锁的业务场景及实现方式 ...
- Java锁机制深入理解
Java锁机制 背景知识 指令流水线 CPU的基本工作是执行存储的指令序列,即程序.程序的执行过程实际上是不断地取出指令.分析指令.执行指令的过程. 几乎所有的冯•诺伊曼型计算机的CPU,其工 ...
- Java锁机制了解一下
前言 回顾前面: 多线程三分钟就可以入个门了! Thread源码剖析 多线程基础必要知识点!看了学习多线程事半功倍 只有光头才能变强! 本文章主要讲的是Java多线程加锁机制,有两种: Synchro ...
- JAVA锁机制-可重入锁,可中断锁，公平锁，读写锁，自旋锁,
如果需要查看具体的synchronized和lock的实现原理,请参考:解决多线程安全问题-无非两个方法synchronized和lock 具体原理(百度) 在并发编程中,经常遇到多个线程访问同一个 ...
- JAVA锁机制(上)
在实际开发中经常会用到多线程协作来处理问题,锁是处理线程安全不可缺少的机制.在JAVA中可以通过至少三种方式来实现线程锁. 1. synchronized修饰符,这种锁机制是虚拟机实现的一种锁. 2 ...
- java 锁机制(synchronized 与 Lock)
在java中,解决同步问题,很多时候都会使用到synchronized和Lock,这两者都是在多线程并发时候常使用的锁机制. synchronized是java中的一个关键字,也就是说是java内置的 ...
- 【面试专栏】JAVA锁机制
1. 悲观锁 / 乐观锁 在Java和数据库中都存在悲观锁和乐观锁的应用.Mysql锁机制中的悲观锁和乐观锁请查看: Mysql锁机制--悲观锁和乐观锁 悲观锁:在获得数据时先加锁,只到数 ...
随机推荐
- YAML - 简介
YAML - YAML An't a Markup Lanague P.S. YAML was originally was side to mean Yet Another Markup Langu ...
- gitlab 实现自动部署（简单Python实现）
功能说明: 当本地master分支执行push动作的时候,服务器端会自动执行master分支的pull操作(还可以执行一些自动化脚本) 原理: git hooks就是那些在git执行特定事件(如com ...
- semantic UI first web
官方文档:https://semantic-ui.com/introduction/getting-started.html semantic UI: SemanticUI是一款语义化设计的前端开源 ...
- mysql存储过程详细讲解及完整实例下载
一.存储过程概念 1.存储过程(Stored Procedure)是一组为了完成特定功能的SQL语句集.经编译后存储在数据库 中. 2.存储过程是数据库中的一个重要对象,用户通过指定存储过程的名字并给 ...
- IE浏览器-官网下载地址
这里仅列出IE浏览器在微软官网的下载地址,便于日常使用. WindowsXP | IE6下载地址:http://www.microsoft.com/zh-CN/download/details.asp ...
- JAVASCRIPT 调用 其他应用程序的方法
在上一篇中就已经提供了一种方法,就是通过自己写OCX 给OCX 传入路径,通过OCX 启动应用程序.当然这种方法可扩展性很多,不一定是启动应用程序了.今天提供另一种比较简单的可以启动应用程序的方法,不 ...
- 关于JS脚本语言的基础语法
JS脚本语言的基础语法:输出语法 alert("警告!"); confirm("确定吗?"); prompt("请输入密码");为弱 ...
- Oracle用户操作
1.超级管理员的身份登录oracle:sqlplus / as sysdba 2.显示当前连接用户SQL> show user 3.新建用户并授权SQL> create user a ...
- kali linux安装到U盘并增加persistence功能
这里写两种方法,其实本质是一样的,都是利用grub4dos重新写mbr,同时建立persistence分区并写入配置文件. 一, 1,首先将U盘分区,分两个即可,一个可当U盘使用存储数据,另一个则用来 ...
- 【转载】由浅入深分析mybatis通过动态代理实现拦截器（插件）的原理
转自:http://zhangbo-peipei-163-com.iteye.com/blog/2033832?utm_source=tuicool&utm_medium=referral 我 ...