并发包java.util.concurrent.locks.Lock

**
 *
 * @描述: Lock比传统线程模型中的synchronized方式更加面向对象、与生活中的锁类似,锁本身也应该是一个对象,两个线程执行的代码片段要实现同步互排的效果
 *        它们必须用同一个LOCK,锁是上线代表要操作的资源内部类的内部方法上,而不是线程的方法中 .
 * @作者: Wnj .
 * @创建时间: 2017年5月16日 .
 * @版本: 1.0 .
 */
public class LockTest {

    /**
     * @param args
     */
    public static void main(String[] args) {
        new LockTest().init();
    }

    private void init() {
        final Outputer outputer = new Outputer();

        //A
        new Thread(new Runnable() {
            @Override
            public void run() {
                while (true) {
                    try {
                        Thread.sleep(10);
                    }
                    catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    //如果A线程还没打印完成,B线程就被调度执行,那么打印就不完整
                    outputer.output("zhangxiaoxiang");
                }

            }
        }).start();

        //B
        new Thread(new Runnable() {
            @Override
            public void run() {
                while (true) {
                    try {
                        Thread.sleep(10);
                    }
                    catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    outputer.output("lihuoming");
                }

            }
        }).start();

    }

    /**
     *
     * @描述: 锁是上线代表要操作的资源内部类的内部方法上
     * @作者: Wnj .
     * @创建时间: 2017年5月16日 .
     * @版本: 1.0 .
     */
    static class Outputer {

        Lock lock = new ReentrantLock();

        /**
         * 使用lock
         * <功能详细描述>
         * @param name
         */
        public void output(String name) {
            int len = name.length();
            lock.lock();
            try {
                for (int i = 0; i < len; i++) {
                    System.out.print(name.charAt(i));
                }
                System.out.println();
            }
            finally {
                lock.unlock();
            }
        }
        /**
         * 使用synchronized
         * <功能详细描述>
         * @param name
         */
        public synchronized void output2(String name) {
            int len = name.length();
            for (int i = 0; i < len; i++) {
                System.out.print(name.charAt(i));
            }
            System.out.println();
        }
        /**
         * 使用synchronized
         * <功能详细描述>
         * @param name
         */
        public static synchronized void output3(String name) {
            int len = name.length();
            for (int i = 0; i < len; i++) {
                System.out.print(name.charAt(i));
            }
            System.out.println();
        }
    }
}
时间: 2024-10-08 13:35:35

并发包java.util.concurrent.locks.Lock的相关文章

java.util.concurrent.locks lock锁【2】

Lock 锁介绍 JDK1.5以前,我们实现线程同步都是通过synchroized关键字进行方法或者语句块锁定,以保证该关键字作用域内的操作都是原子性操作. JDK1.5以后,提供的并发包提供了更强大的功能和更为灵活,最为关键的是需要手工释放锁,需要unlock必须在finally方法内.这是非常值得注意的事情. 介绍一下Lock接口.实现类有3个,分别是 普通锁,读写锁-写锁,读写锁-读锁. API文档给出了相近的说明和demo. Lock l = ...; l.lock(); try { /

12、java5锁java.util.concurrent.locks.Lock之ReentrantLock

JDK文档描述: public interface LockLock 实现提供了比使用 synchronized 方法和语句可获得的更广泛的锁定操作.此实现允许更灵活的结构,可以具有差别很大的属性,可以支持多个相关的 Condition 对象. 锁是控制多个线程对共享资源进行访问的工具.通常,锁提供了对共享资源的独占访问.一次只能有一个线程获得锁,对共享资源的所有访问都需要首先获得锁.不过,某些锁可能允许对共享资源并发访问,如 ReadWriteLock 的读取锁. synchronized 方

java.util.concurrent.locks.Lock类的lock和lockInterruptibly方法的区别

什么是可中断的锁获取呢?就是:线程在等待获取锁的过程中,是否能够响应中断,以便在被中断的时候能够解除阻 塞状态,而不是傻傻地一直在等待.java对象的内置锁(synchronized)就是一种不可中断的锁,也就是说如果一个线 程在等待获取某个对象的内置锁,就算是该线程被其他线程中断,该线程仍然继续等待内置锁,而不是解除阻塞状 态,也不会抛出InterruptedException.Lock类的lock()类似synchronized,是不可中断的,在等待获取锁的过程中, 不响应中断请求:lock

简述synchronized和java.util.concurrent.locks.Lock的异同?

主要相同点:Lock能完成synchronized所实现的所有功能 . 主要不同点:Lock有比synchronized更精确的线程语义和更好的性能.synchronized会自动释放锁,而Lock一定要求程序员手工释放,并且必须在finally从句中释放.Lock还有更强大的功能,例如,它的tryLock方法可以非阻塞方式去拿锁. 举例说明(对下面的题用lock进行了改写): package com.huawei.interview; import java.util.concurrent.l

synchronized和java.util.concurrent.locks.Lock的区别

在看ConcurrentHashMap 源码的时候看到lock这个锁机制,不明白它和Synchronized的区别,查了一些资料记录下来,在Lock的文档中,对Lock的解释是:Lock实现比synchronized 提供了更多额外的锁操作,它有更灵活的结构,可以支持不同的属性,可以支持多个相关条件的对象.那下边看一下Lock可以提供哪些比synchronized 额外的操作,也就是解决synchronized 存在的问题: 1.它无法中断一个正在等候获得锁的线程 2.也无法通过投票得到锁,如果

简述synchronized和java.util.concurrent.locks.Lock异同

主要相同点:Lock能完成synchronized所实现的所有功能.主要不同点:Lock有比synchronized更精确的线程语义和更好的性能.syncronized会自动释放锁,而Lock一定要程序员手动释放,并且必须在finally从句中释放.Lock还有更强大的功能,例如它的tryLock()方法可以以非阻塞方式去拿锁. synchronized (lockObject) { // update object state }   Lock lock = new ReentrantLock

synchronized与java.util.concurrent.locks.Lock 的区别 [转]

简要答案: 1.Lock能完成几乎所有synchronized的功能,并有一些后者不具备的功能,如锁投票.定时锁等候.可中断锁等候等 2.synchronized 是Java 语言层面的,是内置的关键字:Lock 则是JDK 5中出现的一个包,在使用时,synchronized 同步的代码块可以由JVM自动释放:Lock 需要程序员在finally块中手工释放,如果不释放,可能会引起难以预料的后果(在多线程环境中). synchronized 快速回顾: 1.当代码块 加上 synchroziz

对比synchronized与java.util.concurrent.locks.Lock 的异同

主要区别 1.Lock能完成几乎所有synchronized的功能,并有一些后者不具备的功能,如公平锁.等待可中断.锁绑定多个条件等: 2.synchronized 是Java 语言层面的,是内置的关键字:Lock 则是JDK 5中出现的一个包,在使用时,synchronized 同步的代码块可以由JVM自动释放:Lock需要程序员在finally块中手工释放,如果不释放,可能会引起难以预料的后果. 重入锁 java.util.concurrent.lock 中的 Lock 框架是锁定的一个抽象

深入Synchronized和java.util.concurrent.locks.Lock的区别详解

主要相同点:Lock能完成Synchronized所实现的所有功能.主要不同点:Lock有比Synchronized更精确的线程予以和更好的性能.Synchronized会自动释放锁,但是Lock一定要求程序员手工释放,并且必须在finally从句中释放.synchronized 修饰方法时 表示同一个对象在不同的线程中 表现为同步队列如果实例化不同的对象 那么synchronized就不会出现同步效果了.1.对象的锁 所有对象都自动含有单一的锁. JVM负责跟踪对象被加锁的次数.如果一个对象被