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锁机制--悲观锁和乐观锁 悲观锁:在获得数据时先加锁,只到数 ...
随机推荐
- Eclipse错误：Implicit super constructor ClassName is undefined for default constructor. Must define an explicit constructor
public class Test01 { private String name; private int age; public Test01(String name){ this.name = ...
- 利用GPGPU计算大规模群落仿真行为
0x00 前言 在今年6月的Unite Europe 2017大会上 Unity 的CTO Joachim Ante演示了未来Unity新的编程特性--C# Job系统,它提供了编写多线程代码的一种既 ...
- python3.4下django集成使用xadmin后台
环境:window7 x64.python3.4.django1.10 一.pip install xadmin安装报错 1.使用pip install xadmin命令安装可能报如下错误: 2.解决 ...
- CodeForces 797C Minimal string：贪心+模拟
题目链接:http://codeforces.com/problemset/problem/797/C 题意: 给你一个非空字符串s,空字符串t和u.有两种操作:(1)把s的首字符取出并添加到t的末尾 ...
- 原来，负载均衡可以这样用，多核CPU可以这样用
负载均衡作为一个处理高并发,大流量的访问的业务场景,已经几乎是常识性的知识了. 而本文的意义在于需求:由于大流量请求,导致服务无法正常响应,在不增加购买机器成本的场景下,如何提高服务器的业务处理能力? ...
- redux深入理解之中间件(middleware)
理解reduce函数 reduce() 方法接收一个函数作为累加器(accumulator),数组中的每个值(从左到右)开始缩减,最终为一个值. arr.reduce([callback, initi ...
- Spring-Boot快速搭建web项目详细总结
最近在学习Spring Boot 相关的技术,刚接触就有种相见恨晚的感觉,因为用spring boot进行项目的搭建是在太方便了,我们往往只需要很简单的几步,便可完成一个spring MVC项目的搭建 ...
- APP应用测试技巧
分页数据 测试分页数据,必须要满足一页数据,根据APP设置的分页数据准备一些测试数据. 满足一页数据的时候上下滑动瀑布流时, 页面数据是否会正常展示: 是否会出现第二页请求不到数据: 是否会出现重复加 ...
- KeepAlived+Nginx实现高可用负载
一.环境及安装版本: centos6.5.Nginx1.4.7.keepalived1.3.2 虚拟IP 真是IP Nginx端口 主从分配 10.0.90.215 10.0.90.217 80 MA ...
- 神经网络与深度学习笔记 Chapter 1.
转载请注明出处:http://www.cnblogs.com/zhangcaiwang/p/6875533.html sigmoid neuron 微小的输入变化导致微小的输出变化,这种特性将会使得学 ...