java内置锁(synchronized)和显式锁(ReentrantLock)

最新推荐文章于 2024-02-12 17:23:21 发布

lb330776047

最新推荐文章于 2024-02-12 17:23:21 发布

阅读量522

点赞数

分类专栏： java锁机制文章标签： synchronized ReentrantLock 隐式锁显示锁 lock

java锁机制专栏收录该内容

1 篇文章 0 订阅

订阅专栏

Java中的内置锁和显式锁
一、java的内置锁synchronized
每个java对象都可以用做一个实现同步的锁，这些锁成为内置锁。线程进入同步代码块或方法的时候会自动获得该锁，在退出同步代码块或方法时会释放该锁。获得内置锁的唯一途径就是进入这个锁的保护的同步代码块或方法。
java内置锁是一个互斥锁，这就是意味着最多只有一个线程能够获得该锁，当线程A尝试去获得线程B持有的内置锁时，线程A必须等待或者阻塞，直到线程B释放这个锁，如果B线程不释放这个锁，那么A线程将永远等待下去。
1、基本使用
内置锁获得锁和释放锁是隐式的，进入synchronized修饰的代码就获得锁，走出相应的代码就释放锁。

synchronized(list){ //获得锁  
    list.append();  
    list.count();  
}//释放锁

2、线程间的通信
与Synchronized配套使用的通信方法通常有wait(),notify()。

wait()方法会立即释放当前锁，并进入等待状态，等待到相应的notify并重新获得锁过后才能继续执行；notify()不会立刻立刻释放锁，必须要等notify()所在线程执行完synchronized块中的所有代码才会释放。用如下代码来进行验证：

package com.kang;  
  
import java.util.LinkedList;  
import java.util.List;  
  
  
public class Demo1 {  
    public static void main(String[] args){  
        List list = new LinkedList();  
        Thread r = new Thread(new ReadList(list));  
        Thread w = new Thread(new WriteList(list));  
        r.start();//1.读线程先执行  
        w.start();//2、写线程后执行  
    }  
  
  
}  
class ReadList implements Runnable{  
  
  
    private List list;  
  
  
    public ReadList(List list){ this.list = list; }  
  
  
    @Override  
    public void run(){  
        System.out.println("ReadList begin at "+System.currentTimeMillis());  
        synchronized (list){//3、读线程获得线程锁  
            try {  
                Thread.sleep(1000);  
                System.out.println("list.wait() begin at "+System.currentTimeMillis());  
                list.wait();//4、读线程立即释放了线程锁,等待其他线程的notify操作  
                System.out.println("list.wait() end at "+System.currentTimeMillis());  
                //9、读线程获得线程执行权  
            } catch (InterruptedException e) {  
                e.printStackTrace();  
            }  
        }  
        System.out.println("ReadList end at "+System.currentTimeMillis());  
  
  
    }  
}  
  
  
class WriteList implements Runnable{  
  
  
    private List list;  
  
  
    public WriteList(List list){ this.list = list; }  
  
  
    @Override  
    public void run(){  
        System.out.println("WriteList begin at "+System.currentTimeMillis());  
        synchronized (list){//5、写线程获得了线程锁  
            System.out.println("get lock at "+System.currentTimeMillis());  
            list.notify();//6、唤醒其他线程并且在写线程在执行完线程块后立即释放线程锁  
            System.out.println("list.notify() at "+System.currentTimeMillis());  
            try {  
                Thread.sleep(2000);  
            } catch (InterruptedException e) {  
                e.printStackTrace();  
            }  
            System.out.println("get out of block at "+System.currentTimeMillis());  
        }//7、同步块执行完毕  
        System.out.println("WriteList end at "+System.currentTimeMillis());  
        //8、写线程获得抢到线程执行权  
  
  
    }  
}

运行结果如下：

可见读线程开始运行，开始wait过后，写线程才获得锁；写线程走出同步块而不是notify过后，读线程才wait结束，亦即获得锁。所以notify不会释放锁，wait会释放锁。值得一提的是，notifyall()会通知等待队列中的所有线程。

3、缺点：
内置锁在进入同步块时，采取的是无限等待的策略，一旦开始等待，就既不能中断也不能取消，容易产生饥饿与死锁的问题。
在线程调用notify方法时，会随机选择相应对象的等待队列的一个线程将其唤醒，而不是按照FIFO（先入先出策略）的方式，如果有强烈的公平性要求，就无法满足。
Synchronized在JDK1.5及之前性能（主要指吞吐率）比较差，扩展性也不如ReentrantLock。但是JDK1.6以后，修改了管理内置锁的算法，使得Synchronized和标准的ReentrantLock性能差别不大。

二、java中的显示锁ReentrantLock
ReentrantLock是显示锁，需要显示进行 lock 以及 unlock 操作。
1、基本使用
void lock(); //尝试获取锁,若得不到着等待(不可中断,类似于synchronized方式)
void lockInterruptibly() ; //可中断的尝试获取锁
boolean tryLock();尝试获取锁,不管得到与否立即返回
boolean tryLock(long time, TimeUnit unit)尝试获取锁,若得不到等到一段时间
void unlock();// 释放锁
Condition new Condition();//创建于该锁相关的条件变量,实现精确等待/唤醒
Lock lock = new ReentrantLock();
lock.lock();
try{

}finally{
lock.unlock();
}
相比于Synchronized要复杂一些，而且一定要记得在finally中释放锁而不是其他地方，这样才能保证即使出了异常也能释放锁。
2、线程间的通信
与ReentrantLock搭配的通行方式是Condition，如下：
private Lock lock = new ReentrantLock();
private Condition condition = lock.newCondition();
condition.await();//this.wait();
condition.signal();//this.notify();
condition.signalAll();//this.notifyAll();

Condition是被绑定到Lock上的，必须使用lock.newCondition()才能创建一个Condition。从上面的代码可以看出，Synchronized能实现的通信方式，Condition都可以实现，功能类似的代码写在同一行中。而Condition的优秀之处在于它可以为多个线程间建立不同的Condition，比如对象的读/写Condition，队列的空/满Condition，在JDK源码中的ArrayBlockingQueue中就使用了这个特性：

public ArrayBlockingQueue(int capacity, boolean fair) {  
    if (capacity <= 0)  
        throw new IllegalArgumentException();  
    this.items = new Object[capacity];  
    lock = new ReentrantLock(fair);  
    notEmpty = lock.newCondition();  
    notFull =  lock.newCondition();  
}  
public void put(E e) throws InterruptedException {  
    checkNotNull(e);  
    final ReentrantLock lock = this.lock;  
    lock.lockInterruptibly();  
    try {  
        while (count == items.length)  
            notFull.await();  
        enqueue(e);  
    } finally {  
        lock.unlock();  
    }  
}  
public E take() throws InterruptedException {  
    final ReentrantLock lock = this.lock;  
    lock.lockInterruptibly();  
    try {  
        while (count == 0)  
            notEmpty.await();  
        return dequeue();  
    } finally {  
        lock.unlock();  
    }  
}  
private void enqueue(E x) {  
    // assert lock.getHoldCount() == 1;  
    // assert items[putIndex] == null;  
    final Object[] items = this.items;  
    items[putIndex] = x;  
    if (++putIndex == items.length)  
        putIndex = 0;  
    count++;  
    notEmpty.signal();  
}  
private E dequeue() {  
    // assert lock.getHoldCount() == 1;  
    // assert items[takeIndex] != null;  
    final Object[] items = this.items;  
    @SuppressWarnings("unchecked")  
    E x = (E) items[takeIndex];  
    items[takeIndex] = null;  
    if (++takeIndex == items.length)  
        takeIndex = 0;  
    count--;  
    if (itrs != null)  
        itrs.elementDequeued();  
    notFull.signal();  
    return x;  
}

3、优缺点：

lock.lockInterruptibly() 可以使得线程在等待锁是支持响应中断；lock.tryLock() 可以使得线程在等待一段时间过后如果还未获得锁就停止等待而非一直等待。有了这两种机制就可以更好的制定获得锁的重试机制，而非盲目一直等待，可以更好的避免饥饿和死锁问题。

ReentrantLock可以成为公平锁（非默认的），所谓公平锁就是锁的等待队列的FIFO，不过公平锁会带来性能消耗，如果不是必须的不建议使用。这和CPU对指令进行重排序的理由是相似的，如果强行的按照代码的书写顺序来执行指令，就会浪费许多时钟周期，达不到最大利用率。
虽然Synchronized和标准的ReentrantLock性能差别不大，但是ReentrantLock还提供了一种非互斥的读写锁，也就是不强制每次最多只有一个线程能持有锁，它会避免“读/写”冲突，“写/写”冲突，但是不会排除“读/读”冲突，因为“读/读”并不影响数据的完整性，所以可以多个读线程同时持有锁，这样在读写比较高的情况下，性能会有很大的提升。

三、实例编写
下面用两种锁分别实现的线程安全的linkedlist：
1、显示锁实现方式

package com.kang;  
  
  
import java.util.LinkedList;  
import java.util.List;  
import java.util.concurrent.locks.Lock;  
import java.util.concurrent.locks.ReadWriteLock;  
import java.util.concurrent.locks.ReentrantReadWriteLock;  
  
  
public class Demo2 {  
    public static void main(String[] args) {  
        List list = new LinkedList();  
        for (int i = 0; i < 10000; i++) {  
            list.add(i);  
        }  
        final RWLockList rwLockList = new RWLockList(list);// 初始化数据  
  
  
        Thread writer = new Thread(new Runnable() {  
            @Override  
            public void run() {  
                for (int i = 0; i < 10000; i++) {  
                    rwLockList.put(i);  
                }  
            }  
        });  
        Thread reader1 = new Thread(new Runnable() {  
            @Override  
            public void run() {  
                for (int i = 0; i < 10000; i++) {  
                    rwLockList.get(i);  
                }  
            }  
        });  
        Thread reader2 = new Thread(new Runnable() {  
            @Override  
            public void run() {  
                for (int i = 0; i < 10000; i++) {  
                    rwLockList.get(i);  
                }  
            }  
        });  
        long begin = System.currentTimeMillis();  
        writer.start();  
        reader1.start();  
        reader2.start();  
        try {  
            writer.join();  
            reader1.join();  
            reader2.join();  
        } catch (InterruptedException e) {  
            e.printStackTrace();  
        }  
        System.out.println("RWLockList take "  
                + (System.currentTimeMillis() - begin) + "ms");  
    }  
  
  
}  
  
  
class RWLockList {// 读写锁  
  
  
    private List list;  
    private final ReadWriteLock lock = new ReentrantReadWriteLock();  
    private final Lock readLock = lock.readLock();  
    private final Lock writeLock = lock.writeLock();  
  
  
    public RWLockList(List list) {  
        this.list = list;  
    }  
  
  
    public int get(int k) {  
        readLock.lock();  
        try {  
            return (int) list.get(k);  
        } finally {  
            readLock.unlock();  
        }  
    }  
  
  
    public void put(int value) {  
        writeLock.lock();  
        try {  
            list.add(value);  
        } finally {  
            writeLock.unlock();  
        }  
    }  
}

2、内置锁的实现方式

package com.kang;  
  
  
import java.util.LinkedList;  
import java.util.List;  
  
  
public class Demo3 {  
    public static void main(String[] args) {  
        List list = new LinkedList();  
        for (int i = 0; i < 10000; i++) {  
            list.add(i);  
        }  
        final SyncList syncList = new SyncList(list);// 初始化数据  
        Thread writerS = new Thread(new Runnable() {  
            @Override  
            public void run() {  
                for (int i = 0; i < 10000; i++) {  
                    syncList.put(i);  
                }  
            }  
        });  
        Thread reader1S = new Thread(new Runnable() {  
            @Override  
            public void run() {  
                for (int i = 0; i < 10000; i++) {  
                    syncList.get(i);  
                }  
            }  
        });  
        Thread reader2S = new Thread(new Runnable() {  
            @Override  
            public void run() {  
                for (int i = 0; i < 10000; i++) {  
                    syncList.get(i);  
                }  
            }  
        });  
        long begin1 = System.currentTimeMillis();  
        writerS.start();  
        reader1S.start();  
        reader2S.start();  
        try {  
            writerS.join();  
            reader1S.join();  
            reader2S.join();  
        } catch (InterruptedException e) {  
            e.printStackTrace();  
        }  
        System.out.println("SyncList take "  
                + (System.currentTimeMillis() - begin1) + "ms");  
    }  
  
  
}  
  
  
class SyncList {  
  
  
    private List list;  
  
  
    public SyncList(List list) {  
        this.list = list;  
    }  
  
  
    public synchronized int get(int k) {  
        return (int) list.get(k);  
    }  
  
  
    public synchronized void put(int value) {  
        list.add(value);  
    }  
  
  
}

四、内置锁和显式锁的区别
1、显式锁可中断申请
如果使用synchronized申请一个内置锁时锁被其他线程持有, 那么当前线程将被挂起,等待锁重新可用, 而且等待期间无法中断。而显式锁提供了可中断的申请锁的方法：

package com.kang;  
  
  
import java.util.concurrent.locks.Lock;  
import java.util.concurrent.locks.ReentrantLock;  
  
  
public class InterruptedLock extends Thread {    
    private static Lock lock = new ReentrantLock();    
    
    @Override    
    public void run() {    
        try {    
            // 可中断的尝试获取锁，如果在尝试获取锁的过程中当前线程被中断（thread.interrupt()）, 将抛出InterruptedException异常    
            lock.lockInterruptibly();    
        } catch (InterruptedException e) {    
            System.out.println("interruption happened");    
            return;    
        }    
    
        // 如果运行到这里, 说明已经申请到锁, 且没有发生异常    
        try {    
            System.out.println("run is holding the lock");    
        } finally {    
            lock.unlock();    
        }    
    }    
    
    public static void main(String[] args) throws InterruptedException {    
        try {    
            lock.lock();    
            System.out.println("main is holding the lock.");    
            Thread thread = new InterruptedLock();    
            thread.start();    
            Thread.sleep(1000);//该线程此时应该阻塞在lockInterruptibly方法上    
            thread.interrupt();// 中断thread线程,导致其抛出InterruptedException异常.    
            Thread.sleep(1000);    
        } finally {    
            lock.unlock();    
        }    
    }    
}

2、显式锁可以做出尝试型申请
Lock.tryLock和Lock.tryLock(long time, TimeUnit unit)方法用于尝试获取锁。如果尝试没有成功, 则返回false, 否则返回true。而内置锁则不提供这种特性, 一旦开始申请内置锁, 在申请成功之前, 线程无法中断, 申请也无法取消。而尝试型申请也是可中断的。Lock的尝试型申请通常用于实现时间限定的task:

public boolean transferMoney(Account fromAcct, Account toAcct, DollarAmount amount, long timeout, TimeUnit unit)    
            throws InsufficientFundsException, InterruptedException {    
        long fixedDelay = getFixedDelayComponentNanos(timeout, unit);    
        long randMod = getRandomDelayModulusNanos(timeout, unit);    
        // 截止时间    
        long stopTime = System.nanoTime() + unit.toNanos(timeout);    
        
        while (true) {    
            if (fromAcct.lock.tryLock()) {    
                try {    
                    if (toAcct.lock.tryLock()) {    
                        try {    
                            if (fromAcct.getBalance().compareTo(amount) < 0)    
                                throw new InsufficientFundsException();    
                            else {    
                                fromAcct.debit(amount);    
                                toAcct.credit(amount);    
                                return true;    
                            }    
                        } finally {    
                            // 成功申请到锁时才需要释放锁    
                            toAcct.lock.unlock();    
                        }    
                    }    
                } finally {    
                    // 成功申请到锁时才需要释放锁    
                    fromAcct.lock.unlock();    
                }    
            }    
            // 如果已经超过截止时间直接返回false, 说明转账没有成功. 否则进行下次尝试.    
            if (System.nanoTime() < stopTime)    
                return false;    
            NANOSECONDS.sleep(fixedDelay + rnd.nextLong() % randMod);    
        }    
    }

3、锁的释放
对于内置锁, 只要代码运行到同步代码块之外, 就会自动释放锁, 开发者无需担心抛出异常。然而对于显式锁, 必须调用unlock方法才能释放锁. 此时需要开发者自己处理抛出异常, 方法返回等情况。通常会在finally代码块中进行锁的释放, 还需注意只有申请到锁之后才需要释放锁, 释放未持有的锁可能会抛出未检查异常。所以使用内置锁更容易一些, 而显式锁则繁琐很多。但是显式锁释放方式的繁琐也带来一个方便的地方: 锁的申请和释放不必在同一个代码块中。

4、公平锁
通过ReentrantLock(boolean fair)构造函数创建ReentranLock锁时可以为其指定公平策略, 默认情况下为不公平锁。多个线程申请公平锁时, 申请时间早的线程优先获得锁。然而不公平锁则允许插队, 当某个线程申请锁时如果锁恰好可用, 则该线程直接获得锁而不用排队。比如线程B申请某个不公平锁时该锁正在由线程A持有, 线程B将被挂起。当线程A释放锁时, 线程B将从挂起状态中恢复并打算再次申请(这个过程需要一定时间)。如果此时恰好线程C也来申请锁, 则不公平策略允许线程C立刻获得锁并开始运行。假设线程C在很短的一段时间之后就释放了锁, 那么可能线程B还没有完成恢复的过程。这样一来, 节省了线程C从挂起到恢复所需要的时间, 还没有耽误线程B的运行。所以在锁竞争激烈时, 不公平策略可以提高程序吞吐量。内置锁采用不公平策略, 而显式锁则可以指定是否使用不公平策略.

5、唤醒和等待
线程可以wait在内置锁上, 也可以通过调用内置锁的notify或notifyAll方法唤醒在其上等待的线程。但是如果有多个线程在内置锁上wait, 我们无法精确唤醒其中某个特定的线程.
显式锁也可以用于唤醒和等待. 调用Lock.newCondition方法可以获得Condition对象, 调用Condition.await方法将使得线程等待, 调用Condition.singal或Condition.singalAll方法可以唤醒在该Condition对象上等待的线程。由于同一个显式锁可以派生出多个Condition对象, 因此我们可以实现精确唤醒。

6、锁优化
JDK5.0加入显式锁后, 开发者发现显式锁相比内置锁具有明显的性能优势, 再加上显式锁的诸多新特性, 很多文章和书籍都推荐使用显式锁代替内置锁. 然而JDK6.0对内置锁做了大量优化, 显式锁已经不具备明显的性能优势. 所以如果使用的是JDK6.0及之后的版本, 且没有使用到显式锁提供的新特性, 则没有必要刻意使用显式锁, 原因如下:
1. 内置锁是JVM的内置特性, 更容易进行优化。
2. 监控程序(如thread dump)对内置锁具有更好的支持。
3. 大多数开发者更熟悉内置锁。

五、一道多线程的解答

1、题目
启动3个线程打印递增的数字, 线程1先打印1,2,3,4,5, 然后是线程2打印6,7,8,9,10, 然后是线程3打印11,12,13,14,15. 接着再由线程1打印16,17,18,19,20....以此类推, 直到打印到75. 程序的输出结果应该为:

线程1: 1
线程1: 2
线程1: 3
线程1: 4
线程1: 5

线程2: 6
线程2: 7
线程2: 8
线程2: 9
线程2: 10
...

线程3: 71
线程3: 72
线程3: 73
线程3: 74
线程3: 75

2、使用内置锁实现

package com.kang;  
  
  
public class NumberPrintDemo {  
    // n为即将打印的数字，是逐渐递增的。  
    private static int n = 1;  
    // state=1表示将由线程1打印数字, state=2表示将由线程2打印数字, state=3表示将由线程3打印数字  
    private static int state = 1;  
  
  
    public static void main(String[] args) {  
        final NumberPrintDemo pn = new NumberPrintDemo();  
        new Thread(new Runnable() {  
            public void run() {  
                // 3个线程打印75个数字, 单个线程每次打印5个连续数字, 因此每个线程只需执行5次打印任务. 3*5*5=75  
                for (int i = 0; i < 5; i++) {  
                    // 3个线程都使用pn对象做锁, 以保证每个交替期间只有一个线程在打印  
                    synchronized (pn) {  
                        // 如果state!=1, 说明此时尚未轮到线程1打印, 线程1将调用pn的wait()方法, 直到下次被唤醒，以此保证三个线程的执行顺序  
                        while (state != 1)//注意这里不能使用if  
                            try {  
                                pn.wait();  
                            } catch (InterruptedException e) {  
                                e.printStackTrace();  
                            }  
                        // 当state=1时, 轮到线程1打印5次数字  
                        for (int j = 0; j < 5; j++) {  
                            // 打印一次后n自增  
                            System.out.println(Thread.currentThread().getName()  
                                    + ": " + n++);  
                        }  
                        System.out.println();  
                        // 线程1打印完成后, 将state赋值为2, 表示接下来将轮到线程2打印，从而指定了线程的执行顺序  
                        state = 2;  
                        // notifyAll()方法唤醒在pn上wait的线程2和线程3, 同时线程1将退出同步代码块, 释放pn锁.   
                        // 因此3个线程将再次竞争pn锁  
                        // 假如线程1或线程3竞争到资源, 由于state不为1或3, 线程1或线程3将很快再次wait, 释放出刚到手的pn锁.   
                        // 只有线程2可以通过state判定, 所以线程2一定是执行下次打印任务的线程.  
                        pn.notifyAll();  
                    }  
                }  
            }  
        }, "线程1").start();  
  
  
        new Thread(new Runnable() {  
            public void run() {  
                for (int i = 0; i < 5; i++) {  
                    synchronized (pn) {  
                        while (state != 2)  
                            try {  
                                pn.wait();  
                            } catch (InterruptedException e) {  
                                e.printStackTrace();  
                            }  
                        for (int j = 0; j < 5; j++) {  
                            System.out.println(Thread.currentThread().getName()  
                                    + ": " + n++);  
                        }  
                        System.out.println();  
                        state = 3;  
                        pn.notifyAll();  
                    }  
                }  
            }  
        }, "线程2").start();  
  
  
        new Thread(new Runnable() {  
            public void run() {  
                for (int i = 0; i < 5; i++) {  
                    synchronized (pn) {  
                        while (state != 3)  
                            try {  
                                pn.wait();  
                            } catch (InterruptedException e) {  
                                e.printStackTrace();  
                            }  
                        for (int j = 0; j < 5; j++) {  
                            System.out.println(Thread.currentThread().getName()  
                                    + ": " + n++);  
                        }  
                        System.out.println();  
                        state = 1;  
                        pn.notifyAll();  
                    }  
                }  
            }  
        }, "线程3").start();  
    }  
}

3、使用显式锁实现

package com.kang;  
  
  
import java.util.concurrent.locks.Condition;  
import java.util.concurrent.locks.ReentrantLock;  
  
  
public class NumberPrint implements Runnable {  
    private int state = 1;  
    private int n = 1;  
    // 使用lock做锁  
    private ReentrantLock lock = new ReentrantLock();  
    // 获得lock锁的3个分支条件  
    private Condition c1 = lock.newCondition();  
    private Condition c2 = lock.newCondition();  
    private Condition c3 = lock.newCondition();  
  
  
    @Override  
    public void run() {  
        new Thread(new Runnable() {  
            public void run() {  
                for (int i = 0; i < 5; i++) {  
                    try {  
                        // 线程1获得lock锁后, 其他线程将无法进入需要lock锁的代码块.  
                        // 在lock.lock()和lock.unlock()之间的代码相当于使用了synchronized(lock){}  
                        lock.lock();  
                        while (state != 1)  
                            try {  
                                // 线程1竞争到了lock, 但是发现state不为1, 说明此时还未轮到线程1打印.   
                                // 因此线程1将在c1上wait  
                                // 与内置锁不同的是, 三个线程并非在同一个对象上wait, 也不由同一个对象唤醒  
                                c1.await();  
                            } catch (InterruptedException e) {  
                                e.printStackTrace();  
                            }  
                        // 如果线程1竞争到了lock, 也通过了state判定, 将执行打印任务  
                        for (int j = 0; j < 5; j++) {  
                            System.out.println(Thread.currentThread().getName()  
                                    + ": " + n++);  
                        }  
                        System.out.println();  
                        // 打印完成后将state赋值为2, 表示下一次的打印任务将由线程2执行  
                        state = 2;  
                        // 唤醒在c2分支上wait的线程2，这实际上是指定唤醒了线程2，线程3不会被唤醒。  
                        c2.signal();  
                    } finally {  
                        // 打印任务执行完成后需要确保锁被释放, 因此将释放锁的代码放在finally中  
                        lock.unlock();  
                    }  
                }  
            }  
        }, "线程1").start();  
  
  
        new Thread(new Runnable() {  
            public void run() {  
                for (int i = 0; i < 5; i++) {  
                    try {  
                        lock.lock();  
                        while (state != 2)  
                            try {  
                                c2.await();  
                            } catch (InterruptedException e) {  
                                e.printStackTrace();  
                            }  
                        for (int j = 0; j < 5; j++) {  
                            System.out.println(Thread.currentThread().getName()  
                                    + ": " + n++);  
                        }  
                        System.out.println();  
                        state = 3;  
                        c3.signal();  
                    } finally {  
                        lock.unlock();  
                    }  
                }  
            }  
        }, "线程2").start();  
  
  
        new Thread(new Runnable() {  
            public void run() {  
                for (int i = 0; i < 5; i++) {  
                    try {  
  
  
                        lock.lock();  
                        while (state != 3)  
                            try {  
                                c3.await();  
                            } catch (InterruptedException e) {  
                                e.printStackTrace();  
                            }  
                        for (int j = 0; j < 5; j++) {  
                            System.out.println(Thread.currentThread().getName()  
                                    + ": " + n++);  
                        }  
                        System.out.println();  
                        state = 1;  
                        c1.signal();  
                    } finally {  
                        lock.unlock();  
                    }  
                }  
            }  
        }, "线程3").start();  
    }  
      
    public static void main(String[] args) {  
        new NumberPrint().run();  
    }  
}

转载自> http://blog.csdn.net/xiaokang123456kao/article/details/72599061

lb330776047

关注

0
点赞
踩
3

收藏

觉得还不错? 一键收藏
0
评论
java内置锁(synchronized)和显式锁(ReentrantLock)

Java中的内置锁和显式锁一、java的内置锁synchronized每个java对象都可以用做一个实现同步的锁，这些锁成为内置锁。线程进入同步代码块或方法的时候会自动获得该锁，在退出同步代码块或方法时会释放该锁。获得内置锁的唯一途径就是进入这个锁的保护的同步代码块或方法。java内置锁是一个互斥锁，这就是意味着最多只有一个线程能够获得该锁，当线程A尝试去获得线程B持有的内置锁时，线程
复制链接

扫一扫

专栏目录